Skip to content

Instantly share code, notes, and snippets.

@XingLiangLondon

XingLiangLondon/1.1_1Dtensors_v2.ipynb

Created July 13, 2020 09:53
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save XingLiangLondon/42d3966e86ab0df6b8799b749c7b2a47 to your computer and use it in GitHub Desktop.
Save XingLiangLondon/42d3966e86ab0df6b8799b749c7b2a47 to your computer and use it in GitHub Desktop.
Download ZIP
Created on Skills Network Labs
Display the source blob
Display the rendered blob
Raw
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> "
]
},
{
"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\" />"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h1>Torch Tensors in 1D</h1>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2>Table of Contents</h2>"
]
},
{
"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",
"</ul>\n",
"\n",
"<p>Estimated Time Needed: <b>25 min</b></p>\n",
"<hr>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2>Preparation</h2>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Import the following libraries that you'll use for this lab:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"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": [
"This is the function for plotting diagrams. You will use this function to plot the vectors in Coordinate system."
]
},
{
"cell_type": "code",
"execution_count": 4,
"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-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"Types_Shape\">Types and Shape</h2>"
]
},
{
"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 method <code>torch.tensor()</code>:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separate topics-->"
]
},
{
"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>:"
]
},
{
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<b>Note: The elements in the list that will be converted to tensor must have the same type.</b>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"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:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"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": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"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:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"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-->"
]
},
{
"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."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The size of the new_float_tensor: torch.Size([5])\n",
"The dimension of the new_float_tensor: 1\n"
]
}
],
"source": [
"# Introduce the tensor_obj.size() & tensor_ndimension.size() methods\n",
"\n",
"print(\"The size of the new_float_tensor: \", new_float_tensor.size())\n",
"print(\"The dimension of the new_float_tensor: \",new_float_tensor.ndimension())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"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>"
]
},
{
"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."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Original Size: tensor([0., 1., 2., 3., 4.])\n",
"Size after view method tensor([[0.],\n",
" [1.],\n",
" [2.],\n",
" [3.],\n",
" [4.]])\n"
]
}
],
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<b>Note: The number of elements in a tensor must remain constant after applying view.</b>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"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."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Original Size: tensor([0., 1., 2., 3., 4.])\n",
"Size after view method tensor([[0.],\n",
" [1.],\n",
" [2.],\n",
" [3.],\n",
" [4.]])\n"
]
}
],
"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>."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can also convert a <b>numpy</b> array to a <b>tensor</b>, for example: "
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The dtype of new tensor: torch.float64\n",
"The type of new tensor: torch.DoubleTensor\n"
]
}
],
"source": [
"# Convert a numpy array to a tensor\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-->"
]
},
{
"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:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The numpy array from tensor: [0. 0. 0. 0. 0.]\n",
"The dtype of numpy array: float64\n"
]
}
],
"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."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The new tensor points to numpy_array : tensor([0., 0., 0., 0., 0.], dtype=torch.float64)\n",
"and back to numpy array points to the tensor: [0. 0. 0. 0. 0.]\n"
]
}
],
"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-->"
]
},
{
"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. "
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The new tensor from numpy array: tensor([ 0.1000, 2.0000, 0.3000, 10.1000], dtype=torch.float64)\n",
"The dtype of new tensor: torch.float64\n",
"The type of new tensor: torch.DoubleTensor\n"
]
}
],
"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)\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": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3>Practice</h3>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Try to convert <code>your_tensor</code> to a 1X5 tensor."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor([[1],\n",
" [2],\n",
" [3],\n",
" [4],\n",
" [5]])\n"
]
}
],
"source": [
"# Practice: convert the following tensor to a tensor object with 1 row and 5 columns\n",
"\n",
"your_tensor = torch.tensor([1, 2, 3, 4, 5])\n",
"my_tensor = your_tensor.view(-1, 1)\n",
"print(my_tensor)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Double-click <b>here</b> for the solution.\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",
"-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"Index_Slice\">Indexing and Slicing</h2>"
]
},
{
"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:"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The value on index 0: tensor(0)\n",
"The value on index 1: tensor(1)\n",
"The value on index 2: tensor(2)\n",
"The value on index 3: tensor(3)\n",
"The value on index 4: tensor(4)\n"
]
}
],
"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>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The index is shown in the following figure: "
]
},
{
"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\" />"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now, you'll see how to change the values on certain indexes."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Suppose you have a tensor as shown here: "
]
},
{
"cell_type": "code",
"execution_count": 19,
"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:"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Inital value on index 0: tensor(20)\n",
"Modified tensor: tensor([100, 1, 2, 3, 4])\n"
]
}
],
"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:"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Inital value on index 4: tensor(4)\n",
"Modified tensor: tensor([100, 1, 2, 3, 0])\n"
]
}
],
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"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. "
]
},
{
"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."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Original tensor sample: tensor([100, 1, 2, 3, 0])\n",
"The subset of tensor sample: tensor([1, 2, 3])\n"
]
}
],
"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>."
]
},
{
"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>."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As for assigning values to the certain index, you can also assign the value to the slices:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Change the value of <code>tensor_sample</code> from index 3 to index 4:"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Inital value on index 3 and index 4: tensor([3, 0])\n",
"Modified tensor: tensor([100, 1, 2, 300, 400])\n"
]
}
],
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"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: "
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The inital tensor_sample tensor([100, 1, 2, 300, 400])\n",
"The subset of tensor_sample with the values on index 3 and 4: tensor([300, 400])\n"
]
}
],
"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-->"
]
},
{
"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>:"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The inital tensor_sample tensor([100, 1, 2, 300, 400])\n",
"Modified tensor with one value: tensor([ 100, 100000, 2, 100000, 400])\n"
]
}
],
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<b>Note: You can use only one value for the assignment.</b>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3>Practice</h3>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Try to change the values on index 3, 4, 7 of the following tensor to 0."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor([2, 7, 3, 0, 0, 2, 3, 0, 2])\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",
"index=[3, 4, 7]\n",
"practice_tensor_modify= practice_tensor[index]=0\n",
"print(practice_tensor)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Double-click <b>here</b> for the solution.\n",
"<!-- \n",
"selected_indexes = [3, 4, 7]\n",
"practice_tensor[selected_indexes] = 0\n",
"print(\"New Practice Tensor: \", practice_tensor)\n",
"-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"Tensor_Func\">Tensor Functions</h2>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For this section, you'll work with some methods that you can apply to tensor objects."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3>Mean and Standard Deviation</h3>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You'll review the mean and standard deviation methods first. They are two basic statistical methods."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create a tensor with values <i>[1.0, -1, 1, -1]</i>:"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Tensor example: tensor([ 1., -1., 1., -1.])\n"
]
}
],
"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-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here is the mean method: "
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The mean of math_tensor: tensor(0.)\n"
]
}
],
"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-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The standard deviation can also be calculated by using <code><i>tensor_obj</i>.std()</code>:"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The standard deviation of math_tensor: tensor(1.1547)\n"
]
}
],
"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-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3>Max and Min</h3>"
]
},
{
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create a <code>max_min_tensor</code>: "
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Tensor example: tensor([1, 1, 3, 5, 5])\n"
]
}
],
"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>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Apply <code><i>tensor_obj</i>.max()</code> on <code>max_min_tensor</code>:"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Maximum number in the tensor: tensor(5)\n"
]
}
],
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Use <code><i>tensor_obj</i>.min()</code> on <code>max_min_tensor</code>:"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Minimum number in the tensor: tensor(1)\n"
]
}
],
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3>Sin</h3>"
]
},
{
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"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:"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The sin result of pi_tensor: tensor([ 0.0000, 1.0000, -0.0000])\n"
]
}
],
"source": [
"# Method for calculating the sin result of each element in the tensor\n",
"\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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3>Create Tensor by <code>torch.linspace()</code></h3>"
]
},
{
"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>."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"First Try on linspace tensor([-2., -1., 0., 1., 2.])\n"
]
}
],
"source": [
"# First try on using linspace to create tensor\n",
"\n",
"len_5_tensor = torch.linspace(-2, 2, steps = 5)\n",
"print (\"First Try on linspace\", len_5_tensor)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Assign <code>steps</code> with 9:"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Second Try on linspace tensor([-2.0000, -1.5000, -1.0000, -0.5000, 0.0000, 0.5000, 1.0000, 1.5000,\n",
" 2.0000])\n"
]
}
],
"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-->"
]
},
{
"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): "
]
},
{
"cell_type": "code",
"execution_count": 36,
"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."
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7f01278917f0>]"
]
},
"execution_count": 37,
"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": [
"# 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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3>Practice</h3>"
]
},
{
"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."
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Max Number: tensor(1.5708)\n",
"Min Number tensor(0.)\n"
]
},
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7f0127831b00>]"
]
},
"execution_count": 38,
"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",
"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",
"# Type your code here"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Double-click <b>here</b> for the solution.\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",
"-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"Tensor_Op\">Tensor Operations</h2>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the following section, you'll work with operations that you can apply to a tensor."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3>Tensor Addition</h3>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can perform addition between two tensors."
]
},
{
"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:"
]
},
{
"cell_type": "code",
"execution_count": 39,
"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:"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The result tensor: tensor([1, 1])\n"
]
}
],
"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>."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Plot the result to to get a clearer picture."
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"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": [
"# 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-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3>Try</h3> "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Implement the tensor subtraction with <code>u</code> and <code>v</code> as u-v."
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The result tensor: 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",
"print(\"The result tensor: \", u-v)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Double-click <b>here</b> for the solution.\n",
"<!--\n",
"print(\"The result tensor: \", u-v)\n",
"-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can add a scalar to the tensor. Use <code>u</code> as the sample tensor:"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Addition Result: tensor([2, 3, 4, 0])\n"
]
}
],
"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:"
]
},
{
"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\" />"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3>Tensor Multiplication </h3>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now, you'll review the multiplication between a tensor and a scalar."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create a tensor with value <code>[1, 2]</code> and then multiply it by 2:"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The result of 2 * u: tensor([2, 4])\n"
]
}
],
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can use multiplication between two tensors."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create two tensors <code>u</code> and <code>v</code> and then multiply them together:"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The result of u * v tensor([3, 4])\n"
]
}
],
"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>."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3>Dot Product</h3>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The dot product is a special operation for a vector that you can use in Torch."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here is the dot product of the two tensors <code>u</code> and <code>v</code>:"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Dot Product of u, v: tensor(7)\n"
]
}
],
"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>."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3>Practice</h3>"
]
},
{
"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:"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The Dot Product is 0\n"
]
},
{
"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",
"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",
"# Type your code here"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Double-click <b>here</b> for the solution.\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",
" -->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->"
]
},
{
"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."
]
},
{
"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."
]
},
{
"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> "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<hr>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Copyright &copy; 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>."
]
}
],
"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.7"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment