1.1_1Dtensors_v2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"http://cocl.us/pytorch_link_top\">\n",
    "    <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/Pytochtop.png\" width=\"750\" alt=\"IBM Product \" />\n",
    "</a> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/cc-logo-square.png\" width=\"200\" alt=\"cognitiveclass.ai logo\" />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Torch Tensors in 1D</h1>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Objective</h2><ul><li> How tensor operations work in pytorch.</li></ul> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Table of Contents</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>In this lab, you will learn the basics of tensor operations. Tensors are an essential part of PyTorch; there are complex mathematical objects in and of themselves. Fortunately, most of the intricacies are not necessary. In this section, you will compare them to vectors and numpy arrays.</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_Func\">Tensor Functions</a></li>\n",
    "    <li><a href=\"#Tensor_Op\">Tensor Operations</a></li>\n",
    "    <li><a href=\"#Device_Op\">Device_Op Operations</a></li>\n",
    "</ul>\n",
    "\n",
    "<p>Estimated Time Needed: <b>25 min</b></p>\n",
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Preparation</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import the following libraries that you'll use for this lab:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# These are the libraries will be used for this lab.\n",
    "\n",
    "import torch \n",
    "import numpy as np \n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check PyTorch version:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.3.1'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the function for plotting diagrams. You will use this function to plot the vectors in Coordinate system.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Plot vecotrs, please keep the parameters in the same length\n",
    "# @param: Vectors = [{\"vector\": vector variable, \"name\": name of vector, \"color\": color of the vector on diagram}]\n",
    "    \n",
    "def plotVec(vectors):\n",
    "    ax = plt.axes()\n",
    "    \n",
    "    # For loop to draw the vectors\n",
    "    for vec in vectors:\n",
    "        ax.arrow(0, 0, *vec[\"vector\"], head_width = 0.05,color = vec[\"color\"], head_length = 0.1)\n",
    "        plt.text(*(vec[\"vector\"] + 0.1), vec[\"name\"])\n",
    "    \n",
    "    plt.ylim(-2,2)\n",
    "    plt.xlim(-2,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Types_Shape\">Types and Shape</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find the type of the following list of integers <i>[0, 1, 2, 3, 4]</i> by applying the constructor <code>torch.tensor()</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dtype of tensor object after converting it to tensor:  torch.int64\n",
      "The type of tensor object after converting it to tensor:  torch.LongTensor\n"
     ]
    }
   ],
   "source": [
    "# Convert a integer list with length 5 to a tensor\n",
    "\n",
    "ints_to_tensor = torch.tensor([0, 1, 2, 3, 4])\n",
    "print(\"The dtype of tensor object after converting it to tensor: \", ints_to_tensor.dtype)\n",
    "print(\"The type of tensor object after converting it to tensor: \", ints_to_tensor.type())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a result, the integer list has been converted to a long tensor.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Python type is still <code>torch.Tensor</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Tensor"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(ints_to_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separate topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find the type of this float list <i>[0.0, 1.0, 2.0, 3.0, 4.0]</i> by applying the method <code>torch.tensor()</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dtype of tensor object after converting it to tensor:  torch.float32\n",
      "The type of tensor object after converting it to tensor:  torch.FloatTensor\n"
     ]
    }
   ],
   "source": [
    "# Convert a float list with length 5 to a tensor\n",
    "\n",
    "floats_to_tensor = torch.tensor([0.0, 1.0, 2.0, 3.0, 4.0])\n",
    "print(\"The dtype of tensor object after converting it to tensor: \", floats_to_tensor.dtype)\n",
    "print(\"The type of tensor object after converting it to tensor: \", floats_to_tensor.type())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The float list is converted to a float tensor.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_floats=[0.0, 1.0, 2.0, 3.0, 4.0]\n",
    "\n",
    "floats_int_tensor=torch.tensor(list_floats,dtype=torch.int64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dtype of tensor object is:  torch.int64\n",
      "The type of tensor object is:  torch.LongTensor\n"
     ]
    }
   ],
   "source": [
    "print(\"The dtype of tensor object is: \", floats_int_tensor.dtype)\n",
    "print(\"The type of tensor object is: \", floats_int_tensor.type())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Note: The elements in the list that will be converted to tensor must have the same type.</b>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the previous examples, you see that <code>torch.tensor()</code> converts the list to the tensor type, which is similar to the original list type. However, what if you want to convert the list to a certain tensor type? <code>torch</code> contains the methods required to do this conversion. The following code  converts an integer list to float tensor:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of the new_float_tensor: torch.FloatTensor\n"
     ]
    }
   ],
   "source": [
    "# Convert a integer list with length 5 to float tensor\n",
    "\n",
    "new_float_tensor = torch.FloatTensor([0, 1, 2, 3, 4])\n",
    "new_float_tensor.type()\n",
    "print(\"The type of the new_float_tensor:\", new_float_tensor.type())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_float_tensor = torch.FloatTensor([0, 1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also convert an existing tensor object (<code><i>tensor_obj</i></code>) to another tensor type. Convert the integer tensor to a float tensor:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of the new_float_tensor: torch.FloatTensor\n"
     ]
    }
   ],
   "source": [
    "# Another method to convert the integer list to float tensor\n",
    "\n",
    "old_int_tensor = torch.tensor([0, 1, 2, 3, 4])\n",
    "new_float_tensor = old_int_tensor.type(torch.FloatTensor)\n",
    "print(\"The type of the new_float_tensor:\", new_float_tensor.type())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <code><i>tensor_obj</i>.size()</code> helps you to find out the size of the <code><i>tensor_obj</i></code>.\n",
    "The <code><i>tensor_obj</i>.ndimension()</code> shows the dimension of the tensor object.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The size of the new_float_tensor:  torch.Size([3, 2])\n",
      "The dimension of the new_float_tensor:  2\n"
     ]
    }
   ],
   "source": [
    "# Introduce the tensor_obj.size() & tensor_ndimension.size() methods\n",
    "list_of_arrays = [[1,2], [3,4], [5,6]]\n",
    "test_tensor = torch.tensor(list_of_arrays)\n",
    "print(\"The size of the new_float_tensor: \", test_tensor.size())\n",
    "print(\"The dimension of the new_float_tensor: \", test_tensor.ndimension())\n",
    "\n",
    "#ndimension is tg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <code><i>tensor_obj</i>.view(<i>row, column</i>)</code> is used for reshaping a tensor object.<br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if you have a tensor object with <code>torch.Size([5])</code> as a <code>new_float_tensor</code> as shown in the previous example?<br>\n",
    "After you execute <code>new_float_tensor.view(5, 1)</code>, the size of <code>new_float_tensor</code> will be <code>torch.Size([5, 1])</code>.<br>\n",
    "This means that the tensor object <code>new_float_tensor</code> has been reshaped from a one-dimensional  tensor object with 5 elements to a two-dimensional tensor object with 5 rows and 1 column.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Introduce the tensor_obj.view(row, column) method\n",
    "\n",
    "twoD_float_tensor = new_float_tensor.view(5, 1)\n",
    "print(\"Original Size: \", new_float_tensor)\n",
    "print(\"Size after view method\", twoD_float_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the original size is 5. The tensor after reshaping becomes a 5X1 tensor analog to a column vector.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Note: The number of elements in a tensor must remain constant after applying view.</b>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if you have a tensor with dynamic size but you want to reshape it? You can use <b>-1</b> to do just that.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Introduce the use of -1 in tensor_obj.view(row, column) method\n",
    "\n",
    "twoD_float_tensor = new_float_tensor.view(-1, 1)\n",
    "print(\"Original Size: \", new_float_tensor)\n",
    "print(\"Size after view method\", twoD_float_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You get the same result as the previous example. The <b>-1</b> can represent any size. However, be careful because you can set only one argument as <b>-1</b>.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also convert a <b>numpy</b> array to a <b>tensor</b>, for example: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert a numpy array to a tensor\n",
    "# np_array ---torch.from_numpy() --- > torch tensor. \n",
    "# torch_tensor ----.numpy() ---> np_array.\n",
    "\n",
    "numpy_array = np.array([0.0, 1.0, 2.0, 3.0, 4.0])\n",
    "new_tensor = torch.from_numpy(numpy_array)\n",
    "\n",
    "print(\"The dtype of new tensor: \", new_tensor.dtype)\n",
    "print(\"The type of new tensor: \", new_tensor.type())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Converting a <b>tensor</b> to a <b>numpy</b> is also supported in PyTorch. The syntax is shown below:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert a tensor to a numpy array\n",
    "\n",
    "back_to_numpy = new_tensor.numpy()\n",
    "print(\"The numpy array from tensor: \", back_to_numpy)\n",
    "print(\"The dtype of numpy array: \", back_to_numpy.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>back_to_numpy</code> and <code>new_tensor</code> still point to <code>numpy_array</code>. As a result if we change <code>numpy_array</code> both <code>back_to_numpy</code> and <code>new_tensor</code> will change. For example if we set all the elements in <code>numpy_array</code> to zeros, <code>back_to_numpy</code> and <code> new_tensor</code> will follow suit.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set all elements in numpy array to zero \n",
    "numpy_array[:] = 0\n",
    "print(\"The new tensor points to numpy_array : \", new_tensor)\n",
    "print(\"and back to numpy array points to the tensor: \", back_to_numpy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Pandas Series</b> can also be converted by using the numpy array that is stored in <code>pandas_series.values</code>. Note that <code>pandas_series</code> can be any pandas_series object. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert a panda series to a tensor\n",
    "\n",
    "pandas_series=pd.Series([0.1, 2, 0.3, 10.1])\n",
    "new_tensor=torch.from_numpy(pandas_series.values) #pandas_series.values turns the content into a numpy array.\n",
    "print(\"The new tensor from numpy array: \", new_tensor)\n",
    "print(\"The dtype of new tensor: \", new_tensor.dtype)\n",
    "print(\"The type of new tensor: \", new_tensor.type())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "consider the following tensor \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "this_tensor=torch.tensor([0,1, 2,3]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method <code>item()</code> returns the value of this tensor as a standard Python number. This only works for one element. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "this_tensor=torch.tensor([0,1, 2,3]) \n",
    "\n",
    "print(\"the first item is given by\",this_tensor[0].item(),\"the first tensor value is given by \",this_tensor[0])\n",
    "print(\"the second item is given by\",this_tensor[1].item(),\"the second tensor value is given by \",this_tensor[1])\n",
    "print(\"the third  item is given by\",this_tensor[2].item(),\"the third tensor value is given by \",this_tensor[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can use the method <code> tolist()</code> to return a list \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch_to_list=this_tensor.tolist()\n",
    "\n",
    "print('tensor:', this_tensor,\"\\nlist:\",torch_to_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Practice</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try to convert <code>your_tensor</code> to a 1X5 tensor.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1],\n",
      "        [2],\n",
      "        [3],\n",
      "        [4],\n",
      "        [5]]) torch.Size([5, 1])\n"
     ]
    }
   ],
   "source": [
    "# Practice: convert the following tensor to a tensor object with 1 row and 5 columns\n",
    "\n",
    "import torch\n",
    "your_tensor = torch.tensor([1, 2, 3, 4, 5])\n",
    "new_tensor = your_tensor.view(5,1)\n",
    "print(new_tensor, new_tensor.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click <b>here</b> for the solution.\n",
    "\n",
    "<!-- \n",
    "your_new_tensor = your_tensor.view(1, 5)\n",
    "print(\"Original Size: \", your_tensor)\n",
    "print(\"Size after view method\", your_new_tensor)\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Index_Slice\">Indexing and Slicing</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, <b>the index starts with 0</b>. Therefore, the last index will always be 1 less than the length of the tensor object.\n",
    "You can access the value on a certain index by using the square bracket, for example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A tensor for showing how the indexs work on tensors\n",
    "\n",
    "index_tensor = torch.tensor([0, 1, 2, 3, 4])\n",
    "print(\"The value on index 0:\",index_tensor[0])\n",
    "print(\"The value on index 1:\",index_tensor[1])\n",
    "print(\"The value on index 2:\",index_tensor[2])\n",
    "print(\"The value on index 3:\",index_tensor[3])\n",
    "print(\"The value on index 4:\",index_tensor[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Note that the <code>index_tensor[5]</code> will create an error.</b>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The index is shown in the following figure: \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter%201/idex_1.png\" width=\"500\" alt=\"Python Index\" />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you'll see how to change the values on certain indexes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose you have a tensor as shown here: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# A tensor for showing how to change value according to the index\n",
    "\n",
    "tensor_sample = torch.tensor([20, 1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assign the value on index 0 as 100:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Change the value on the index 0 to 100\n",
    "\n",
    "print(\"Inital value on index 0:\", tensor_sample[0])\n",
    "tensor_sample[0] = 100\n",
    "print(\"Modified tensor:\", tensor_sample)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the value on index 0 changes. Change the value on index 4 to 0:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Change the value on the index 4 to 0\n",
    "\n",
    "print(\"Inital value on index 4:\", tensor_sample[4])\n",
    "tensor_sample[4] = 0\n",
    "print(\"Modified tensor:\", tensor_sample)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The value on index 4 turns to 0.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are familiar with Python, you know that there is a feature called slicing on a list. Tensors support the same feature. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get the subset of <code>tensor_sample</code>. The subset should contain the values in <code>tensor_sample</code> from index 1 to index 3.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Slice tensor_sample\n",
    "\n",
    "subset_tensor_sample = tensor_sample[1:4]\n",
    "print(\"Original tensor sample: \", tensor_sample)\n",
    "print(\"The subset of tensor sample:\", subset_tensor_sample)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a result, the <code>subset_tensor_sample</code> returned only the values on index 1, index 2, and index 3. Then, it stored them in a <code>subset_tensor_sample</code>.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Note: The number on the left side of the colon represents the index of the first value. The number on the right side of the colon is always 1 larger than the index of the last value. For example, <code>tensor_sample[1:4]</code> means you get values from the index 1 to index 3 <i>(4-1)</i></b>.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As for assigning values to the certain index, you can also assign the value to the slices:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Change the value of <code>tensor_sample</code> from index 3 to index 4:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change the values on index 3 and index 4\n",
    "\n",
    "print(\"Inital value on index 3 and index 4:\", tensor_sample[3:5])\n",
    "tensor_sample[3:5] = torch.tensor([300.0, 400.0])\n",
    "print(\"Modified tensor:\", tensor_sample)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The values on both index 3 and index 4 were changed. The values on other indexes remain the same.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use a variable to contain the selected indexes and pass that variable to a tensor slice operation as a parameter, for example:  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# Using variable to contain the selected index, and pass it to slice operation\n",
    "\n",
    "selected_indexes = [3, 4]\n",
    "subset_tensor_sample = tensor_sample[selected_indexes]\n",
    "print(\"The inital tensor_sample\", tensor_sample)\n",
    "print(\"The subset of tensor_sample with the values on index 3 and 4: \", subset_tensor_sample)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also assign one value to the selected indexes by using the variable. For example, assign 100,000 to all the <code>selected_indexes</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "#Using variable to assign the value to the selected indexes\n",
    "\n",
    "print(\"The inital tensor_sample\", tensor_sample)\n",
    "selected_indexes = [1, 3]\n",
    "tensor_sample[selected_indexes] = 100000\n",
    "print(\"Modified tensor with one value: \", tensor_sample)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The values on index 1 and index 3 were changed to 100,000. Others remain the same.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Note: You can use only one value for the assignment.</b>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Practice</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try to change the values on index 3, 4, 7 of the following tensor to 0.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ True, False, False, False, False,  True, False,  True,  True])\n",
      "tensor([0, 7, 3, 4, 6, 0, 3, 0, 0])\n"
     ]
    }
   ],
   "source": [
    "# Practice: Change the values on index 3, 4, 7 to 0\n",
    "\n",
    "practice_tensor = torch.tensor([2, 7, 3, 4, 6, 2, 3, 1, 2])\n",
    "idxs = practice_tensor < 3 \n",
    "print(idxs)\n",
    "practice_tensor[idxs] = 0\n",
    "print(practice_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click <b>here</b> for the solution.\n",
    "\n",
    "<!-- \n",
    "selected_indexes = [3, 4, 7]\n",
    "practice_tensor[selected_indexes] = 0\n",
    "print(\"New Practice Tensor: \", practice_tensor)\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Tensor_Func\">Tensor Functions</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this section, you'll work with some methods that you can apply to tensor objects.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Mean and Standard Deviation</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll review the mean and standard deviation methods first. They are two basic statistical methods.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a tensor with values <i>[1.0, -1, 1, -1]</i>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# Sample tensor for mathmatic calculation methods on tensor\n",
    "\n",
    "math_tensor = torch.tensor([1.0, -1.0, 1, -1])\n",
    "print(\"Tensor example: \", math_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the mean method:  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "#Calculate the mean for math_tensor\n",
    "\n",
    "mean = math_tensor.mean()\n",
    "print(\"The mean of math_tensor: \", mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The standard deviation can also be calculated by using <code><i>tensor_obj</i>.std()</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "#Calculate the standard deviation for math_tensor\n",
    "\n",
    "standard_deviation = math_tensor.std()\n",
    "print(\"The standard deviation of math_tensor: \", standard_deviation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Max and Min</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you'll review another two useful methods: <code><i>tensor_obj</i>.max()</code> and <code><i>tensor_obj</i>.min()</code>. These two methods are used for finding the maximum value and the minimum value in the tensor.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a <code>max_min_tensor</code>: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Sample for introducing max and min methods\n",
    "\n",
    "max_min_tensor = torch.tensor([1, 1, 3, 5, 5])\n",
    "print(\"Tensor example: \", max_min_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Note: There are two minimum numbers as 1 and two maximum numbers as 5 in the tensor. Can you guess how PyTorch is going to deal with the duplicates?</b>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply <code><i>tensor_obj</i>.max()</code> on <code>max_min_tensor</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Method for finding the maximum value in the tensor\n",
    "\n",
    "max_val = max_min_tensor.max()\n",
    "print(\"Maximum number in the tensor: \", max_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The answer is <code>tensor(5)</code>. Therefore, the method <code><i>tensor_obj</i>.max()</code> is grabbing the maximum value but not the elements that contain the maximum value in the tensor.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " max_min_tensor.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use <code><i>tensor_obj</i>.min()</code> on <code>max_min_tensor</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Method for finding the minimum value in the tensor\n",
    "\n",
    "min_val = max_min_tensor.min()\n",
    "print(\"Minimum number in the tensor: \", min_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The answer is <code>tensor(1)</code>. Therefore, the method <code><i>tensor_obj</i>.min()</code> is grabbing the minimum value but not the elements that contain the minimum value in the tensor.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Sin</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin is the trigonometric function of an angle. Again, you will not be introducedvto any mathematic functions. You'll focus on Python.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a tensor with 0, π/2 and π. Then, apply the sin function on the tensor. Notice here that the <code>sin()</code> is not a method of tensor object but is a function of torch:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sin result of pi_tensor:  tensor([ 0.0000e+00,  1.0000e+00, -8.7423e-08])\n"
     ]
    }
   ],
   "source": [
    "# Method for calculating the sin result of each element in the tensor\n",
    "\n",
    "import numpy as np\n",
    "pi_tensor = torch.tensor([0, np.pi/2, np.pi])\n",
    "sin = torch.sin(pi_tensor)\n",
    "print(\"The sin result of pi_tensor: \", sin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The resultant tensor <code>sin</code> contains the result of the <code>sin</code> function applied to each element in the <code>pi_tensor</code>.<br>\n",
    "This is different from the previous methods. For <code><i>tensor_obj</i>.mean()</code>, <code><i>tensor_obj</i>.std()</code>, <code><i>tensor_obj</i>.max()</code>, and <code><i>tensor_obj</i>.min()</code>, the result is a tensor with only one number because these are aggregate methods.<br>\n",
    "However, the <code>torch.sin()</code> is not. Therefore, the resultant tensors have the same length as the input tensor.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Create Tensor by <code>torch.linspace()</code></h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A useful function for plotting mathematical functions is <code>torch.linspace()</code>. <code>torch.linspace()</code> returns evenly spaced numbers over a specified interval. You specify the starting point of the sequence and the ending point of the sequence. The parameter <code>steps</code> indicates the number of samples to generate. Now, you'll work with <code>steps = 5</code>.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# First try on using linspace to create tensor\n",
    "\n",
    "len_5_tensor = torch.linspace(-2, 2, steps = 5) # will create 5 elements between -2 and 2, equally spaced.\n",
    "print (\"First Try on linspace\", len_5_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assign <code>steps</code> with 9:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Second try on using linspace to create tensor\n",
    "\n",
    "len_9_tensor = torch.linspace(-2, 2, steps = 9)\n",
    "print (\"Second Try on linspace\", len_9_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use both <code>torch.linspace()</code> and <code>torch.sin()</code> to construct a tensor that contains the 100 sin result in range from 0 (0 degree) to 2π (360 degree): \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Construct the tensor within 0 to 360 degree\n",
    "\n",
    "pi_tensor = torch.linspace(0, 2*np.pi, 100)\n",
    "sin_result = torch.sin(pi_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the result to get a clearer picture. You must cast the tensor to a numpy array before plotting it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Plot sin_result\n",
    "\n",
    "plt.plot(pi_tensor.numpy(), sin_result.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you know the trigonometric function, you will notice this is the diagram of the sin result in the range 0 to 360 degrees.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Practice</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Construct a tensor with 25 steps in the range 0 to π/2. Print out the Maximum and Minimum number. Also, plot  a graph showing the diagram that shows the result.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(1.5708)\n",
      "tensor(0.)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7efea4bfc400>]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Practice: Create your tensor, print max and min number, plot the sin result diagram\n",
    "\n",
    "import numpy as np\n",
    "import torch \n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Creating the random numbers.\n",
    "nums = np.random.randn(100) # 100 random floats normally distributed. \n",
    "#plt.scatter(np.arange(0,100), nums)\n",
    "\n",
    "#make the tensor out of the np array.\n",
    "tens = torch.from_numpy(nums)\n",
    "\n",
    "lintens = torch.linspace(0, np.pi/2, 25)\n",
    "print(lintens.max())\n",
    "print(lintens.min())\n",
    "sins = torch.sin(lintens)\n",
    "plt.plot(lintens.numpy(), sins.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click <b>here</b> for the solution.\n",
    "\n",
    "<!-- \n",
    "pi_tensor = torch.linspace(0, np.pi/2, 100)\n",
    "print(\"Max Number: \", pi_tensor.max())\n",
    "print(\"Min Number\", pi_tensor.min())\n",
    "sin_result = torch.sin(pi_tensor)\n",
    "plt.plot(pi_tensor.numpy(), sin_result.numpy())\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Tensor_Op\">Tensor Operations</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following section, you'll work with operations that you can apply to a tensor.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Tensor Addition</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can perform addition between two tensors.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a tensor <code>u</code> with 1 dimension and 2 elements. Then, create another tensor <code>v</code> with the same number of dimensions and the same number of elements:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Create two sample tensors\n",
    "\n",
    "u = torch.tensor([1, 0])\n",
    "v = torch.tensor([0, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add <code>u</code> and <code>v</code> together:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Add u and v\n",
    "\n",
    "w = u + v\n",
    "print(\"The result tensor: \", w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is <code>tensor([1, 1])</code>. The behavior is <i>[1 + 0, 0 + 1]</i>.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the result to to get a clearer picture.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Plot u, v, w\n",
    "\n",
    "plotVec([\n",
    "    {\"vector\": u.numpy(), \"name\": 'u', \"color\": 'r'},\n",
    "    {\"vector\": v.numpy(), \"name\": 'v', \"color\": 'b'},\n",
    "    {\"vector\": w.numpy(), \"name\": 'w', \"color\": 'g'}\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Try</h3> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement the tensor subtraction with <code>u</code> and <code>v</code> as u-v.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 1, -1])\n"
     ]
    }
   ],
   "source": [
    "# Try by yourself to get a result of u-v\n",
    "\n",
    "u = torch.tensor([1, 0])\n",
    "v = torch.tensor([0, 1])\n",
    "\n",
    "print(u-v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click <b>here</b> for the solution.\n",
    "\n",
    "<!--\n",
    "print(\"The result tensor: \", u-v)\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tensors must be of the same data type to perform addition as well as other operations.If you uncomment the  following code and try to run it you will get an error as the two tensors are of two different data types. **NOTE This lab was created on a older PyTorch version so in the current version we are using this is possible and will produce a float64 tensor.**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#torch.tensor([1,2,3],dtype=torch.int64)+torch.tensor([1,2,3],dtype=torch.float64)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can add a scalar to the tensor. Use <code>u</code> as the sample tensor:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tensor + scalar\n",
    "\n",
    "u = torch.tensor([1, 2, 3, -1])\n",
    "v = u + 1\n",
    "print (\"Addition Result: \", v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is simply adding 1 to each element in tensor <code>u</code> as shown in the following image:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = \"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter%201/brodcasting.gif\" width = \"500\" alt=\"tensor addition\" />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Tensor Multiplication </h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you'll review the multiplication between a tensor and a scalar.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a tensor with value <code>[1, 2]</code> and then multiply it by 2:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# tensor * scalar\n",
    "\n",
    "u = torch.tensor([1, 2])\n",
    "v = 2 * u\n",
    "print(\"The result of 2 * u: \", v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is <code>tensor([2, 4])</code>, so the code <code>2 \\* u</code> multiplies each element in the tensor by 2. This is how you get the product between a vector or matrix and a scalar in linear algebra.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use multiplication between two tensors.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create two tensors <code>u</code> and <code>v</code> and then multiply them together:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# tensor * tensor\n",
    "\n",
    "u = torch.tensor([1, 2])\n",
    "v = torch.tensor([3, 2])\n",
    "w = u * v\n",
    "print (\"The result of u * v\", w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is simply <code>tensor([3, 4])</code>. This result is achieved by multiplying every element in <code>u</code> with the corresponding element in the same position <code>v</code>, which is similar to <i>[1 * 3, 2 * 2]</i>.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Dot Product</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dot product is a special operation for a vector that you can use in Torch.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the dot product of the two tensors <code>u</code> and <code>v</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate dot product of u, v\n",
    "\n",
    "u = torch.tensor([1, 2])\n",
    "v = torch.tensor([3, 2])\n",
    "\n",
    "print(\"Dot Product of u, v:\", torch.dot(u,v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is <code>tensor(7)</code>. The function is <i>1 x 3 + 2 x 2 = 7</i>.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Practice</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the list <i>[-1, 1]</i> and <i>[1, 1]</i> to tensors <code>u</code> and <code>v</code>. Then, plot the tensor <code>u</code> and <code>v</code> as a vector by using the function <code>plotVec</code> and find the dot product:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jupyterlab/conda/envs/python/lib/python3.6/site-packages/ipykernel_launcher.py:6: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  \n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "iteration over a 0-d array",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-49-8f2371cdea82>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      9\u001b[0m     \u001b[0;34m{\u001b[0m\u001b[0;34m\"vector\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mt1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"name\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m't1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"color\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'r'\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0;34m{\u001b[0m\u001b[0;34m\"vector\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mt2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"name\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m't2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"color\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'b'\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m     \u001b[0;34m{\u001b[0m\u001b[0;34m\"vector\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mt3\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"name\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m't3'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"color\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'g'\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m ])\n",
      "\u001b[0;32m<ipython-input-34-2a8c0da2eb3f>\u001b[0m in \u001b[0;36mplotVec\u001b[0;34m(vectors)\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;31m# For loop to draw the vectors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mvec\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mvectors\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m         \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marrow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mvec\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"vector\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhead_width\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0.05\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcolor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvec\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"color\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhead_length\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m         \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvec\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"vector\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvec\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"name\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: iteration over a 0-d array"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Practice: calculate the dot product of u and v, and plot out two vectors\n",
    "\n",
    "# Type your code here\n",
    "t1 = torch.tensor([-3,1])\n",
    "t2 = torch.tensor([1,4])\n",
    "\n",
    "plotVec([\n",
    "    {\"vector\": t1.numpy(), \"name\": 't1', \"color\": 'r'},\n",
    "    {\"vector\": t2.numpy(), \"name\": 't2', \"color\": 'b'},\n",
    "    {\"vector\": t3.numpy(), \"name\": 't3', \"color\": 'g'}\n",
    "])\n",
    "\n",
    "print(torch.dot())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click <b>here</b> for the solution.\n",
    "\n",
    "<!-- \n",
    "u= torch.tensor([-1, 1])\n",
    "v= torch.tensor([1, 1])\n",
    "plotVec([\n",
    "    {\"vector\": u.numpy(), \"name\": 'u', \"color\": 'r'},\n",
    "    {\"vector\": v.numpy(), \"name\": 'v', \"color\": 'b'}\n",
    "])\n",
    "print(\"The Dot Product is\",np.dot(u, v))\n",
    " -->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See <a href=\"https://docs.scipy.org/doc/numpy-1.13.0/user/basics.broadcasting.html\">Broadcasting</a> for more information on numpy that is similar to PyTorch.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"http://cocl.us/pytorch_link_bottom\">\n",
    "    <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/notebook_bottom%20.png\" width=\"750\" alt=\"PyTorch Bottom\" />\n",
    "</a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "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": {},
   "source": [
    "## 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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright © 2018 <a href=\"cognitiveclass.ai?utm_source=bducopyrightlink&utm_medium=dswb&utm_campaign=bdu\">cognitiveclass.ai</a>. This notebook and its source code are released under the terms of the <a href=\"https://bigdatauniversity.com/mit-license/\">MIT License</a>.\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.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}