1 1_2_Two-Dimensional_Tensors_v2__M.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rptmfEmxzmmr"
      },
      "source": [
        "<p style=\"text-align:center\">\n",
        "    <a href=\"https://skills.network\" target=\"_blank\">\n",
        "    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/assets/logos/SN_web_lightmode.png\" width=\"200\" alt=\"Skills Network Logo\">\n",
        "    </a>\n",
        "</p>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AL18-a9bzmmt"
      },
      "source": [
        "<h1>Two-Dimensional Tensors</h1>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VOsGTh9vzmmt"
      },
      "source": [
        "<h2>Objective</h2><ul><li> How to perform tensor operations on 2D tensors.</li></ul>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zncxi5n-zmmt"
      },
      "source": [
        "<h2>Table of Contents</h2>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XHKIHmAZzmmu"
      },
      "source": [
        "<p>In this lab, you will learn the basics of tensor operations on 2D tensors.</p>\n",
        "<ul>\n",
        "    <li><a href=\"#Types_Shape\">Types and Shape </a></li>\n",
        "    <li><a href=\"#Index_Slice\">Indexing and Slicing</a></li>\n",
        "    <li><a href=\"#Tensor_Op\">Tensor Operations</a></li>\n",
        "</ul>\n",
        "\n",
        "<p>Estimated Time Needed: <b>10 min</b></p>\n",
        "<hr>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ATmwQ4pxzmmu"
      },
      "source": [
        "<h2>Preparation</h2>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dWxG57g9zmmu"
      },
      "source": [
        "The following are the libraries we are going to use for this lab.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "r26Iw-qMzmmu"
      },
      "outputs": [],
      "source": [
        "# These are the libraries will be used for this lab.\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import torch\n",
        "import pandas as pd"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FwS0d9Nwzmmv"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FQdJIWnhzmmw"
      },
      "source": [
        "<h2 id=\"Types_Shape\">Types and Shape</h2>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kVDxezeezmmw"
      },
      "source": [
        "The methods and types for 2D tensors is similar to the methods and types for 1D tensors which has been introduced in <i>Previous Lab</i>.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oPj2GtdJzmmw"
      },
      "source": [
        "Let us see how to convert a 2D list to a 2D tensor. First, let us create a 3X3 2D tensor. Then let us try to use <code>torch.tensor()</code> which we used for converting a 1D list to 1D tensor. Is it going to work?\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s-fGItjlzmmw",
        "outputId": "e1f369b9-7698-4531-c3e0-29ce80374b82"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The New 2D Tensor:  tensor([[11, 12, 13],\n",
            "        [21, 22, 23],\n",
            "        [31, 32, 33]])\n"
          ]
        }
      ],
      "source": [
        "# Convert 2D List to 2D Tensor\n",
        "\n",
        "twoD_list = [[11, 12, 13], [21, 22, 23], [31, 32, 33]]\n",
        "twoD_tensor = torch.tensor(twoD_list)\n",
        "print(\"The New 2D Tensor: \", twoD_tensor)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rOZGtLKnzmmx"
      },
      "source": [
        "Bravo! The method <code>torch.tensor()</code> works perfectly.Now, let us try other functions we studied in the <i>Previous Lab</i>.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xDJxHGuazmmx"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0RtZTJVozmmx"
      },
      "source": [
        "Let us try <code><i>tensor_obj</i>.ndimension()</code> (<code>tensor_obj</code>: This can be any tensor object), <code><i>tensor_obj</i>.shape</code>, and <code><i>tensor_obj</i>.size()</code>\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mVqU_r6_zmmx",
        "outputId": "03e56189-bf23-4a61-ba65-d00b4d39a5cc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The dimension of twoD_tensor:  2\n",
            "The shape of twoD_tensor:  torch.Size([3, 3])\n",
            "The shape of twoD_tensor:  torch.Size([3, 3])\n",
            "The number of elements in twoD_tensor:  9\n"
          ]
        }
      ],
      "source": [
        "# Try tensor_obj.ndimension(), tensor_obj.shape, tensor_obj.size()\n",
        "\n",
        "print(\"The dimension of twoD_tensor: \", twoD_tensor.ndimension())\n",
        "print(\"The shape of twoD_tensor: \", twoD_tensor.shape)\n",
        "print(\"The shape of twoD_tensor: \", twoD_tensor.size())\n",
        "print(\"The number of elements in twoD_tensor: \", twoD_tensor.numel())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lfNUNABIzmmx"
      },
      "source": [
        "Because it is a 2D 3X3 tensor,  the outputs are correct.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kr7Ra_Pvzmmy"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QK1W9KMnzmmy"
      },
      "source": [
        "Now, let us try converting the tensor to a numpy array and convert the numpy array back to a tensor.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IVufq8nQzmmy",
        "outputId": "c6d154f5-f685-441a-9fb9-8a8673617ee0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tensor -> Numpy Array:\n",
            "The numpy array after converting:  [[11 12 13]\n",
            " [21 22 23]\n",
            " [31 32 33]]\n",
            "Type after converting:  int64\n",
            "================================================\n",
            "Numpy Array -> Tensor:\n",
            "The tensor after converting: tensor([[11, 12, 13],\n",
            "        [21, 22, 23],\n",
            "        [31, 32, 33]])\n",
            "Type after converting:  torch.int64\n"
          ]
        }
      ],
      "source": [
        "# Convert tensor to numpy array; Convert numpy array to tensor\n",
        "\n",
        "twoD_numpy = twoD_tensor.numpy()\n",
        "print(\"Tensor -> Numpy Array:\")\n",
        "print(\"The numpy array after converting: \", twoD_numpy)\n",
        "print(\"Type after converting: \", twoD_numpy.dtype)\n",
        "\n",
        "print(\"================================================\")\n",
        "\n",
        "new_twoD_tensor = torch.from_numpy(twoD_numpy)\n",
        "print(\"Numpy Array -> Tensor:\")\n",
        "print(\"The tensor after converting:\", new_twoD_tensor)\n",
        "print(\"Type after converting: \", new_twoD_tensor.dtype)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sLaJubVDzmmy"
      },
      "source": [
        "The result shows the tensor has successfully been converted to a numpy array and then converted back to a tensor.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "usvNHtmWzmmy"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YwCR4Wmqzmmy"
      },
      "source": [
        "Now let us try to convert a Pandas Dataframe to a tensor. The process is the  Same as the 1D conversion, we can obtain the numpy array via the attribute <code>values</code>. Then, we can use <code>torch.from_numpy()</code> to convert the value of the Pandas Series to a tensor.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A5E20090zmmy",
        "outputId": "d65b0dcc-fa7a-498f-e194-8ce272d1ecec"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Pandas Dataframe to numpy:  [[ 11  12]\n",
            " [ 21  22]\n",
            " [ 31 312]]\n",
            "Type BEFORE converting:  int64\n",
            "================================================\n",
            "Tensor AFTER converting:  tensor([[ 11,  12],\n",
            "        [ 21,  22],\n",
            "        [ 31, 312]])\n",
            "Type AFTER converting:  torch.int64\n"
          ]
        }
      ],
      "source": [
        "# Try to convert the Panda Dataframe to tensor\n",
        "\n",
        "df = pd.DataFrame({'a':[11,21,31],'b':[12,22,312]})\n",
        "\n",
        "print(\"Pandas Dataframe to numpy: \", df.values)\n",
        "print(\"Type BEFORE converting: \", df.values.dtype)\n",
        "\n",
        "print(\"================================================\")\n",
        "\n",
        "new_tensor = torch.from_numpy(df.values)\n",
        "print(\"Tensor AFTER converting: \", new_tensor)\n",
        "print(\"Type AFTER converting: \", new_tensor.dtype)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kSN_Zhlmzmmz"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tVTmlGRKzmmz"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BfpH-flbzmmz"
      },
      "source": [
        "<h3>Practice</h3>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hr0PpcIMzmmz"
      },
      "source": [
        "Try to convert the following Pandas Dataframe  to a tensor\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "xAllw3VLzmmz"
      },
      "outputs": [],
      "source": [
        "# Practice: try to convert Pandas Series to tensor\n",
        "\n",
        "df = pd.DataFrame({'A':[11, 33, 22],'B':[3, 3, 2]})"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z48u_i1Dzmmz"
      },
      "source": [
        "Double-click <b>here</b> for the solution.\n",
        "\n",
        "<!--\n",
        "converted_tensor = torch.tensor(df.values)\n",
        "print (\"Tensor: \", converted_tensor)\n",
        "-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vwfC0p87zmmz"
      },
      "source": [
        "<h2 id=\"Index_Slice\">Indexing and Slicing</h2>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aCMGoihrzmmz"
      },
      "source": [
        "You can use rectangular brackets to access the different elements of the tensor. The correspondence between the rectangular brackets and the list and the rectangular representation is shown in the following figure for a 3X3 tensor:  \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uSMKU0Qazmmz"
      },
      "source": [
        "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter%201/1.2index1.png\" width=\"500\" alt=\"Matrix Structure Introduce\">\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "23apqqWczmm0"
      },
      "source": [
        "You can access the 2nd-row 3rd-column as shown in the following figure:\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s7qEXyKhzmm0"
      },
      "source": [
        "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter%201/1.2index.png\" width=\"500\" alt=\"Example of Matrix Index\">\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PGjO4kJpzmm0"
      },
      "source": [
        "You simply use the square brackets and the indices corresponding to the element that you want.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HsQZ_fZNzmm0"
      },
      "source": [
        "Now, let us try to access the value on position 2nd-row 3rd-column. Remember that the index is always 1 less than how we count rows and columns. There are two ways to access the certain value of a tensor. The example in code will be the same as the example picture above.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WsYX7UwXzmm0",
        "outputId": "bc43d0c9-074f-4975-fe4b-68a1bf31cedb"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "What is the value on 2nd-row 3rd-column?  tensor(23)\n",
            "What is the value on 2nd-row 3rd-column?  tensor(23)\n"
          ]
        }
      ],
      "source": [
        "# Use tensor_obj[row, column] and tensor_obj[row][column] to access certain position\n",
        "\n",
        "tensor_example = torch.tensor([[11, 12, 13], [21, 22, 23], [31, 32, 33]])\n",
        "print(\"What is the value on 2nd-row 3rd-column? \", tensor_example[1, 2])\n",
        "print(\"What is the value on 2nd-row 3rd-column? \", tensor_example[1][2])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pn3qX4nvzmm0"
      },
      "source": [
        "As we can see, both methods return the true value (the same value as the picture above). Therefore, both of the methods work.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "71VaDtYJzmm0"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "te5ZAQiUzmm1"
      },
      "source": [
        "Consider the elements shown in the following figure:\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IQdLu9o3zmm1"
      },
      "source": [
        "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter%201/1.2_index2.png\" width=\"500\" alt=\"Example of Matrix Index\">\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Nyct-Tzzmm1"
      },
      "source": [
        "Use the method above, we can access the 1st-row 1st-column by <code>tensor_example[0][0]</code>\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GrEh2yLazmm1",
        "outputId": "f8f3025f-fb5f-4a25-e81e-b358b9dfda32"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(11)"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ],
      "source": [
        "tensor_example[0][0]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R1W5WNZFzmm1"
      },
      "source": [
        "But what if we want to get the value on both 1st-row 1st-column and 1st-row 2nd-column?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OOmW9V2jzmm1"
      },
      "source": [
        "You can also use slicing in a tensor. Consider the following figure. You want to obtain the 1st two columns in the 1st row:  \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JZla_8kAzmm1"
      },
      "source": [
        "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter%201/1.2sliceing.png\" width=\"500\" alt=\"Example of Matrix Index and Slicing\">\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QG1hNj1Kzmm2"
      },
      "source": [
        "## Let us see how  we use slicing with 2D tensors to get the values in the above picture.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4cWiwQcjzmm2",
        "outputId": "0727f0db-a49d-4df4-d288-c59910014e81"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "What is the value on 1st-row first two columns?  tensor([11, 12])\n",
            "What is the value on 1st-row first two columns?  tensor([11, 12])\n"
          ]
        }
      ],
      "source": [
        "# Use tensor_obj[begin_row_number: end_row_number, begin_column_number: end_column number]\n",
        "# and tensor_obj[row][begin_column_number: end_column number] to do the slicing\n",
        "\n",
        "tensor_example = torch.tensor([[11, 12, 13], [21, 22, 23], [31, 32, 33]])\n",
        "print(\"What is the value on 1st-row first two columns? \", tensor_example[0, 0:2])\n",
        "print(\"What is the value on 1st-row first two columns? \", tensor_example[0][0:2])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hbvmxvI1zmm2"
      },
      "source": [
        "We get the result as <code>tensor([11, 12])</code> successfully.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fBtLJkXWzmm2"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0beX5rqIzmm2"
      },
      "source": [
        "But we <b>can't</b> combine using slicing on row and pick one column by using the code <code>tensor_obj[begin_row_number: end_row_number][begin_column_number: end_column number]</code>. The reason is that the slicing will be applied on the tensor first. The result type will be a two dimension again. The second bracket will no longer represent the index of the column it will be the index of the row at that time. Let us see an example.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kptKqZlHzmm2",
        "outputId": "0e3a888a-c94d-4268-aae4-0b01d279a58c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1. Slicing step on tensor_example: \n",
            "Result after tensor_example[1:3]:  tensor([[21, 22, 23],\n",
            "        [31, 32, 33]])\n",
            "Dimension after tensor_example[1:3]:  2\n",
            "================================================\n",
            "2. Pick an index on sliced_tensor_example: \n",
            "Result after sliced_tensor_example[1]:  tensor([31, 32, 33])\n",
            "Dimension after sliced_tensor_example[1]:  1\n",
            "================================================\n",
            "3. Combine these step together:\n",
            "Result:  tensor([31, 32, 33])\n",
            "Dimension:  1\n"
          ]
        }
      ],
      "source": [
        "# Give an idea on tensor_obj[number: number][number]\n",
        "\n",
        "tensor_example = torch.tensor([[11, 12, 13], [21, 22, 23], [31, 32, 33]])\n",
        "sliced_tensor_example = tensor_example[1:3]\n",
        "print(\"1. Slicing step on tensor_example: \")\n",
        "print(\"Result after tensor_example[1:3]: \", sliced_tensor_example)\n",
        "print(\"Dimension after tensor_example[1:3]: \", sliced_tensor_example.ndimension())\n",
        "print(\"================================================\")\n",
        "print(\"2. Pick an index on sliced_tensor_example: \")\n",
        "print(\"Result after sliced_tensor_example[1]: \", sliced_tensor_example[1])\n",
        "print(\"Dimension after sliced_tensor_example[1]: \", sliced_tensor_example[1].ndimension())\n",
        "print(\"================================================\")\n",
        "print(\"3. Combine these step together:\")\n",
        "print(\"Result: \", tensor_example[1:3][1])\n",
        "print(\"Dimension: \", tensor_example[1:3][1].ndimension())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iumXaAFOzmm3"
      },
      "source": [
        "See the results and dimensions in 2 and 3 are the same. Both of them contains the 3rd row in the <code>tensor_example</code>, but not the last two values in the 3rd column.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hIJpbyf2zmm3"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z2MLdVZZzmm3"
      },
      "source": [
        "So how can we get the elements in the 3rd column with the last two rows? As the below picture.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "46rhNCXszmm3"
      },
      "source": [
        "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter%201/1.2slicing2.png\" width=\"500\" alt=\"Example of Matrix Index and Slicing\">\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9xZQ3ZKazmm3"
      },
      "source": [
        "Let's see the code below.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CNU-uDa0zmm3",
        "outputId": "07a80f05-96bb-4094-887a-07216d90a16d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "What is the value on 3rd-column last two rows?  tensor([23, 33])\n"
          ]
        }
      ],
      "source": [
        "# Use tensor_obj[begin_row_number: end_row_number, begin_column_number: end_column number]\n",
        "\n",
        "tensor_example = torch.tensor([[11, 12, 13], [21, 22, 23], [31, 32, 33]])\n",
        "print(\"What is the value on 3rd-column last two rows? \", tensor_example[1:3, 2])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lEKTwaghzmm3"
      },
      "source": [
        "Fortunately, the code <code>tensor_obj[begin_row_number: end_row_number, begin_column_number: end_column number]</code> is still works.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "za67MhkTzmm4"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pl9d5yBKzmm4"
      },
      "source": [
        "<h3>Practice</h3>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G0scyWzCzmm4"
      },
      "source": [
        "Try to change the values on the second column and the last two rows to 0. Basically, change the values on <code>tensor_ques[1][1]</code> and <code>tensor_ques[2][1]</code> to 0.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5hSzAet-zmm4",
        "outputId": "efcfe20b-adf9-4c56-ca89-eeb35b3887f3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The result:  tensor([[11, 12, 13],\n",
            "        [21,  0, 23],\n",
            "        [31,  0, 33]])\n"
          ]
        }
      ],
      "source": [
        "# Practice: Use slice and index to change the values on the matrix tensor_ques.\n",
        "\n",
        "tensor_ques = torch.tensor([[11, 12, 13], [21, 22, 23], [31, 32, 33]])\n",
        "tensor_ques[1:3, 1] = 0\n",
        "print(\"The result: \", tensor_ques)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x6SuWeA4zmm4"
      },
      "source": [
        "Double-click <b>here</b> for the solution.\n",
        "\n",
        "<!--\n",
        "tensor_ques[1:3, 1] = 0\n",
        "print(\"The result: \", tensor_ques)\n",
        "-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1r-tOeeuzmm4"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xShH6Oljzmm4"
      },
      "source": [
        "<h2 id=\"Tensor_Op\">Tensor Operations</h2>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "86FRCLqQzmm4"
      },
      "source": [
        "We can also do some calculations on 2D tensors.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wwKi4V8kzmm5"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WEV02U2Vzmm5"
      },
      "source": [
        "<h3>Tensor Addition</h3>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XOBZ-a7Uzmm5"
      },
      "source": [
        "You can also add tensors; the process is identical to matrix addition. Matrix addition of <b>X</b> and <b>Y</b> is shown in the following figure:\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q8SKZJ2Mzmm5"
      },
      "source": [
        "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter%201/1.2add.png\" width=\"500\" alt=\"Tensor Addition in 2D\">\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k56Y52C3zmm5"
      },
      "source": [
        "Let us see how tensor addition works with <code>X</code> and <code>Y</code>.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cQsk8yuxzmm5",
        "outputId": "74e2aa6f-a364-4fb5-e804-05d2214ddc13"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The result of X + Y:  tensor([[3, 1],\n",
            "        [1, 3]])\n"
          ]
        }
      ],
      "source": [
        "# Calculate [[1, 0], [0, 1]] + [[2, 1], [1, 2]]\n",
        "\n",
        "X = torch.tensor([[1, 0],[0, 1]])\n",
        "Y = torch.tensor([[2, 1],[1, 2]])\n",
        "X_plus_Y = X + Y\n",
        "print(\"The result of X + Y: \", X_plus_Y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JoKlx7jqzmm5"
      },
      "source": [
        "Like the result shown in the picture above. The result is <code>[[3, 1], [1, 3]]</code>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9mb-jKmizmm5"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o4Q_rDijzmm6"
      },
      "source": [
        "<h3> Scalar Multiplication </h3>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bCnARJmxzmm6"
      },
      "source": [
        "Multiplying a tensor by a scalar is identical to multiplying a matrix by a scaler. If you multiply the matrix <b>Y</b> by the scalar 2, you simply multiply every element in the matrix by 2 as shown in the figure:\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K9Uc1t6qzmm6"
      },
      "source": [
        "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter%201/1.2scaller_mult.png\" width=\"500\" alt=\"The product of tensor and scalar\">\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oBwrg0d1zmm6"
      },
      "source": [
        "Let us try to calculate the product of <b>2Y</b>.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VzYVBTBHzmm6",
        "outputId": "abd49dbc-7320-4f3e-c219-d547af89fc20"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The result of 2Y:  tensor([[4, 2],\n",
            "        [2, 4]])\n"
          ]
        }
      ],
      "source": [
        "# Calculate 2 * [[2, 1], [1, 2]]\n",
        "\n",
        "Y = torch.tensor([[2, 1], [1, 2]])\n",
        "two_Y = 2 * Y\n",
        "print(\"The result of 2Y: \", two_Y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hBVvNyntzmm7"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oYQKO_2wzmm7"
      },
      "source": [
        "<h3>Element-wise Product/Hadamard Product</h3>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cXEL2EWFzmm7"
      },
      "source": [
        "Multiplication of two tensors corresponds to an element-wise product or Hadamard product.  Consider matrix the <b>X</b> and <b>Y</b> with the same size. The Hadamard product corresponds to multiplying each of the elements at the same position, that is, multiplying elements with the same color together. The result is a new matrix that is the same size as matrix <b>X</b> and <b>Y</b> as shown in the following figure:\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FBRrun9Ozmm7"
      },
      "source": [
        " <a><img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter%201/1.2tensor_pruduct.png\" width=\"500\" align=\"center\"> </a>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iFhDxzavzmm-"
      },
      "source": [
        "The code below calculates the element-wise product of the tensor <strong>X</strong> and <strong>Y</strong>:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j_tL2uRczmm-",
        "outputId": "7a782ac5-a9db-4905-ea22-b11be4a37f68"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The result of X * Y:  tensor([[2, 0],\n",
            "        [0, 2]])\n"
          ]
        }
      ],
      "source": [
        "# Calculate [[1, 0], [0, 1]] * [[2, 1], [1, 2]]\n",
        "\n",
        "X = torch.tensor([[1, 0], [0, 1]])\n",
        "Y = torch.tensor([[2, 1], [1, 2]])\n",
        "X_times_Y = X * Y\n",
        "print(\"The result of X * Y: \", X_times_Y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ROo2NJfOzmm-"
      },
      "source": [
        "This is a simple calculation. The result from the code matches the result shown in the picture.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t3cdrDZwzmm-"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pYjuN7MIzmm_"
      },
      "source": [
        "<h3>Matrix Multiplication </h3>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wry6xHJjzmm_"
      },
      "source": [
        "We can also apply matrix multiplication to two tensors, if you have learned linear algebra, you should know that in the multiplication of two matrices order matters. This means if <i>X * Y</i> is valid, it does not mean <i>Y * X</i> is valid. The number of columns of the matrix on the left side of the multiplication sign must equal to the number of rows of the matrix on the right side.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mCdCt5P3zmm_"
      },
      "source": [
        "First, let us create a tensor <code>X</code> with size 2X3. Then, let us create another tensor <code>Y</code> with size 3X2. Since the number of columns of <code>X</code> is equal to the number of rows of <code>Y</code>. We are able to perform the multiplication.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dFcXTGYgzmm_"
      },
      "source": [
        "We use <code>torch.mm()</code> for calculating the multiplication between tensors with different sizes.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BpFC2QeTzmm_",
        "outputId": "5c610e76-dac4-471f-9ad6-bd28449d49ac"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The result of A * B:  tensor([[0, 2],\n",
            "        [0, 2]])\n"
          ]
        }
      ],
      "source": [
        "# Calculate [[0, 1, 1], [1, 0, 1]] * [[1, 1], [1, 1], [-1, 1]]\n",
        "\n",
        "A = torch.tensor([[0, 1, 1], [1, 0, 1]])\n",
        "B = torch.tensor([[1, 1], [1, 1], [-1, 1]])\n",
        "A_times_B = torch.mm(A,B)\n",
        "print(\"The result of A * B: \", A_times_B)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I6iGRyfkzmm_"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fwutPeI_zmm_"
      },
      "source": [
        "<h3>Practice</h3>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F_0CcgZTzmm_"
      },
      "source": [
        "Try to create your own two tensors (<code>X</code> and <code>Y</code>) with different sizes, and multiply them.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vFqJrof5zmnA",
        "outputId": "81670478-8c13-4fb7-ab22-28113d254867"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The result of X * Y:  tensor([[2, 1, 2],\n",
            "        [3, 0, 4]])\n"
          ]
        }
      ],
      "source": [
        "# Practice: Calculate the product of two tensors (X and Y) with different sizes\n",
        "\n",
        "# Type your code here\n",
        "X = torch.tensor([[0, 1], [1, 2]])\n",
        "Y = torch.tensor([[-1, -2, 0], [2, 1, 2]])\n",
        "X_times_Y = torch.mm(X, Y)\n",
        "print(\"The result of X * Y: \", X_times_Y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SxdkOffhzmnA"
      },
      "source": [
        "Double-click <b>here</b> for the solution.\n",
        "\n",
        "<!--\n",
        "X = torch.tensor([[0, 1], [1, 2]])\n",
        "Y = torch.tensor([[-1, -2, 0], [2, 1, 2]])\n",
        "X_times_Y = torch.mm(X, Y)\n",
        "print(\"The result of X * Y: \", X_times_Y)\n",
        "-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r-cfYEWpzmnA"
      },
      "source": [
        "<a href=\"https://dataplatform.cloud.ibm.com/registration/stepone?utm_source=skills_network&utm_content=in_lab_content_link&utm_id=Lab-IBMDeveloperSkillsNetwork-DL0110EN-SkillsNetwork&context=cpdaas&apps=data_science_experience%2Cwatson_machine_learning\"><img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-DL0110EN-SkillsNetwork/Template/module%201/images/Watson_Studio.png\"></a>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PXyXnMB0zmnA"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4s53e74KzmnA"
      },
      "source": [
        "<h2>About the Authors:</h2>\n",
        "\n",
        "<a href=\"https://www.linkedin.com/in/joseph-s-50398b136/\">Joseph Santarcangelo</a> has a PhD in Electrical Engineering, his research focused on using machine learning, signal processing, and computer vision to determine how videos impact human cognition. Joseph has been working for IBM since he completed his PhD.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "41psh1_ozmnA"
      },
      "source": [
        "Other contributors: <a href=\"https://www.linkedin.com/in/michelleccarey/\">Michelle Carey</a>, <a href=\"www.linkedin.com/in/jiahui-mavis-zhou-a4537814a\">Mavis Zhou</a>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NobzMnsezmnA"
      },
      "source": [
        "<!--\n",
        "## Change Log\n",
        "\n",
        "|  Date (YYYY-MM-DD) |  Version | Changed By  |  Change Description |\n",
        "|---|---|---|---|\n",
        "| 2020-09-21  | 2.0  | Shubham  |  Migrated Lab to Markdown and added to course repo in GitLab |\n",
        "\n",
        "-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wgo0uqikzmnA"
      },
      "source": [
        "<hr>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uGKZ59cbzmnA"
      },
      "source": [
        "## <h3 align=\"center\"> &#169; IBM Corporation. All rights reserved. <h3/>\n"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python",
      "language": "python",
      "name": "conda-env-python-py"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.12"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}