coursera_deep_neural_network/2.1Prediction1Dregression_v3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-DL0110EN-SkillsNetwork/Template/module%201/images/IDSNlogo.png\" width=\"300\" alt=\"cognitiveclass.ai logo\"  />\n",
    "</center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Linear Regression 1D: Prediction</h1>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Objective</h2><ul><li> How to make the prediction for multiple inputs.</li><li> How to use linear class to build more complex models.</li><li> How to build a custom module.</li></ul> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Table of Contents</h2>\n",
    "<p>In this lab, we will  review how to make a prediction in several different ways by using PyTorch.</h2>\n",
    "<ul>\n",
    "    <li><a href=\"#Prediction\">Prediction</a></li>\n",
    "    <li><a href=\"#Linear\">Class Linear</a></li>\n",
    "    <li><a href=\"#Cust\">Build Custom Modules</a></li>\n",
    "</ul>\n",
    "<p>Estimated Time Needed: <strong>15 min</strong></p>\n",
    "\n",
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Preparation</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following are the libraries we are going to use for this lab.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:45:13.853622Z",
     "start_time": "2021-07-09T08:45:13.412353Z"
    }
   },
   "outputs": [],
   "source": [
    "# These are the libraries will be used for this lab.\n",
    "\n",
    "import torch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Prediction\">Prediction</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us create the following expressions:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$b=-1,w=2$\n",
    "\n",
    "$\\hat{y}=-1+2x$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, define the parameters:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:45:16.019120Z",
     "start_time": "2021-07-09T08:45:16.016648Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define w = 2 and b = -1 for y = wx + b\n",
    "\n",
    "w = torch.tensor(2.0, requires_grad = True)\n",
    "b = torch.tensor(-1.0, requires_grad = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, define the function <code>forward(x, w, b)</code> makes the prediction: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:45:16.916064Z",
     "start_time": "2021-07-09T08:45:16.911105Z"
    }
   },
   "outputs": [],
   "source": [
    "# Function forward(x) for prediction\n",
    "\n",
    "def forward(x):\n",
    "    yhat = w * x + b\n",
    "    return yhat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make the following prediction at <i>x = 1</i>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\hat{y}=-1+2x$\n",
    "\n",
    "$\\hat{y}=-1+2(1)$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:45:18.396891Z",
     "start_time": "2021-07-09T08:45:18.390110Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction:  tensor([[1.]], grad_fn=<AddBackward0>)\n"
     ]
    }
   ],
   "source": [
    "# Predict y = 2x - 1 at x = 1\n",
    "\n",
    "x = torch.tensor([[1.0]])\n",
    "yhat = forward(x)\n",
    "print(\"The prediction: \", yhat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let us try to make the prediction for multiple inputs:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter2/2.1.2.png\" width=\"500\" alt=\"Linear Regression Multiple Input Samples\" />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us construct the <code>x</code> tensor first. Check the shape of <code>x</code>.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:45:22.802827Z",
     "start_time": "2021-07-09T08:45:22.800279Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shape of x:  torch.Size([2, 1])\n"
     ]
    }
   ],
   "source": [
    "# Create x Tensor and check the shape of x tensor\n",
    "\n",
    "x = torch.tensor([[1.0], [2.0]])\n",
    "print(\"The shape of x: \", x.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now make the prediction: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:45:24.817965Z",
     "start_time": "2021-07-09T08:45:24.806653Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction:  tensor([[1.],\n",
      "        [3.]], grad_fn=<AddBackward0>)\n"
     ]
    }
   ],
   "source": [
    "# Make the prediction of y = 2x - 1 at x = [1, 2]\n",
    "\n",
    "yhat = forward(x)\n",
    "print(\"The prediction: \", yhat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is the same as what it is in the image above.\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": [
    "Make a prediction of the following <code>x</code> tensor using the <code>w</code> and <code>b</code> from above.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:45:46.427999Z",
     "start_time": "2021-07-09T08:45:46.420875Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1.],\n",
       "        [3.],\n",
       "        [5.]], grad_fn=<AddBackward0>)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Practice: Make a prediction of y = 2x - 1 at x = [[1.0], [2.0], [3.0]]\n",
    "\n",
    "x = torch.tensor([[1.0], [2.0], [3.0]])\n",
    "forward(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click <b>here</b> for the solution.\n",
    "\n",
    "<!-- Your answer is below:\n",
    "yhat = forward(x)\n",
    "print(\"The prediction: \", yhat)\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Linear\">Class Linear</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The linear class can be used to make a prediction. We can also use the linear class to build more complex models. Let's import the module:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:45:54.564548Z",
     "start_time": "2021-07-09T08:45:54.559201Z"
    }
   },
   "outputs": [],
   "source": [
    "# Import Class Linear\n",
    "\n",
    "from torch.nn import Linear"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set the random seed because the parameters are randomly initialized:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:45:55.735722Z",
     "start_time": "2021-07-09T08:45:55.725571Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f627c187790>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set random seed\n",
    "\n",
    "torch.manual_seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us create the linear object by using the constructor. The parameters are randomly created. Let us print out to see what <i>w</i> and <i>b</i>. The parameters of an <code>torch.nn.Module</code> model are contained in the model’s parameters accessed with <code>lr.parameters()</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:45:58.012240Z",
     "start_time": "2021-07-09T08:45:58.008836Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters w and b:  [Parameter containing:\n",
      "tensor([[0.5153]], requires_grad=True), Parameter containing:\n",
      "tensor([-0.4414], requires_grad=True)]\n"
     ]
    }
   ],
   "source": [
    "# Create Linear Regression Model, and print out the parameters\n",
    "\n",
    "lr = Linear(in_features=1, out_features=1, bias=True)\n",
    "print(\"Parameters w and b: \", list(lr.parameters()))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is equivalent to the following expression:  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$b=-0.44, w=0.5153$\n",
    "\n",
    "$\\hat{y}=-0.44+0.5153x$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A method  <code>state_dict()</code> Returns a Python dictionary object corresponding to the layers of each parameter  tensor. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:46:09.349292Z",
     "start_time": "2021-07-09T08:46:09.342259Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python dictionary:  OrderedDict([('weight', tensor([[0.5153]])), ('bias', tensor([-0.4414]))])\n",
      "keys:  odict_keys(['weight', 'bias'])\n",
      "values:  odict_values([tensor([[0.5153]]), tensor([-0.4414])])\n"
     ]
    }
   ],
   "source": [
    "print(\"Python dictionary: \",lr.state_dict())\n",
    "print(\"keys: \",lr.state_dict().keys())\n",
    "print(\"values: \",lr.state_dict().values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keys correspond to the name of the attributes and the values correspond to the parameter value.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:46:16.544084Z",
     "start_time": "2021-07-09T08:46:16.532782Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight: Parameter containing:\n",
      "tensor([[0.5153]], requires_grad=True)\n",
      "bias: Parameter containing:\n",
      "tensor([-0.4414], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "print(\"weight:\",lr.weight)\n",
    "print(\"bias:\",lr.bias)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let us make a single prediction at <i>x = [[1.0]]</i>.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:46:20.382593Z",
     "start_time": "2021-07-09T08:46:20.378689Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction:  tensor([[0.0739]], grad_fn=<AddmmBackward>)\n"
     ]
    }
   ],
   "source": [
    "# Make the prediction at x = [[1.0]]\n",
    "\n",
    "x = torch.tensor([[1.0]])\n",
    "yhat = lr(x)\n",
    "print(\"The prediction: \", yhat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, you can make multiple predictions:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter2/2.1.2vector_function.png\" width=\"500\" alt=\"Linear Class Sample with Multiple Inputs\" />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use model <code>lr(x)</code> to predict the result.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:46:27.131081Z",
     "start_time": "2021-07-09T08:46:27.127713Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction:  tensor([[0.0739],\n",
      "        [0.5891]], grad_fn=<AddmmBackward>)\n"
     ]
    }
   ],
   "source": [
    "# Create the prediction using linear model\n",
    "\n",
    "x = torch.tensor([[1.0], [2.0]])\n",
    "yhat = lr(x)\n",
    "print(\"The prediction: \", yhat)"
   ]
  },
  {
   "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": [
    "Make a prediction of the following <code>x</code> tensor using the linear regression model <code>lr</code>.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:46:39.306749Z",
     "start_time": "2021-07-09T08:46:39.294716Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.0739],\n",
       "        [0.5891],\n",
       "        [1.1044]], grad_fn=<AddmmBackward>)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Practice: Use the linear regression model object lr to make the prediction.\n",
    "\n",
    "x = torch.tensor([[1.0],[2.0],[3.0]])\n",
    "lr(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click <b>here</b> for the solution.\n",
    "\n",
    "<!-- Your answer is below:\n",
    "x=torch.tensor([[1.0],[2.0],[3.0]])\n",
    "yhat = lr(x)\n",
    "print(\"The prediction: \", yhat)\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Cust\">Build Custom Modules</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's build a custom module. We can make more complex models by using this method later on. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, import the following library.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:46:43.363501Z",
     "start_time": "2021-07-09T08:46:43.357940Z"
    }
   },
   "outputs": [],
   "source": [
    "# Library for this section\n",
    "\n",
    "from torch import nn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let us define the class: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:46:44.156909Z",
     "start_time": "2021-07-09T08:46:44.150722Z"
    }
   },
   "outputs": [],
   "source": [
    "# Customize Linear Regression Class\n",
    "\n",
    "class LR(nn.Module):\n",
    "    \n",
    "    # Constructor\n",
    "    def __init__(self, input_size, output_size):\n",
    "        \n",
    "        # Inherit from parent\n",
    "        super(LR, self).__init__()\n",
    "        self.linear = nn.Linear(input_size, output_size)\n",
    "    \n",
    "    # Prediction function\n",
    "    def forward(self, x):\n",
    "        out = self.linear(x)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create an object by using the constructor. Print out the parameters we get and the model.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:46:58.993248Z",
     "start_time": "2021-07-09T08:46:58.981267Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The parameters:  [Parameter containing:\n",
      "tensor([[-0.1939]], requires_grad=True), Parameter containing:\n",
      "tensor([0.4694], requires_grad=True)]\n",
      "Linear model:  Linear(in_features=1, out_features=1, bias=True)\n"
     ]
    }
   ],
   "source": [
    "# Create the linear regression model. Print out the parameters.\n",
    "\n",
    "lr = LR(1, 1)\n",
    "print(\"The parameters: \", list(lr.parameters()))\n",
    "print(\"Linear model: \", lr.linear)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us try to make a prediction of a single input sample.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:47:01.076417Z",
     "start_time": "2021-07-09T08:47:01.069892Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction:  tensor([[0.2755]], grad_fn=<AddmmBackward>)\n"
     ]
    }
   ],
   "source": [
    "# Try our customize linear regression model with single input\n",
    "\n",
    "x = torch.tensor([[1.0]])\n",
    "yhat = lr(x)\n",
    "print(\"The prediction: \", yhat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let us try another example with multiple samples.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:47:04.954253Z",
     "start_time": "2021-07-09T08:47:04.950089Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction:  tensor([[0.2755],\n",
      "        [0.0816]], grad_fn=<AddmmBackward>)\n"
     ]
    }
   ],
   "source": [
    "# Try our customize linear regression model with multiple input\n",
    "\n",
    "x = torch.tensor([[1.0], [2.0]])\n",
    "yhat = lr(x)\n",
    "print(\"The prediction: \", yhat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the parameters are also stored in an ordered dictionary :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:47:06.669104Z",
     "start_time": "2021-07-09T08:47:06.662047Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python dictionary:  OrderedDict([('linear.weight', tensor([[-0.1939]])), ('linear.bias', tensor([0.4694]))])\n",
      "keys:  odict_keys(['linear.weight', 'linear.bias'])\n",
      "values:  odict_values([tensor([[-0.1939]]), tensor([0.4694])])\n"
     ]
    }
   ],
   "source": [
    "print(\"Python dictionary: \", lr.state_dict())\n",
    "print(\"keys: \",lr.state_dict().keys())\n",
    "print(\"values: \",lr.state_dict().values())\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": [
    "Create an object <code>lr1</code> from the class we created before and make a prediction by using the following tensor: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-09T08:47:21.753624Z",
     "start_time": "2021-07-09T08:47:21.741993Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.2755],\n",
       "        [ 0.0816],\n",
       "        [-0.1122]], grad_fn=<AddmmBackward>)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Practice: Use the LR class to create a model and make a prediction of the following tensor.\n",
    "\n",
    "x = torch.tensor([[1.0], [2.0], [3.0]])\n",
    "lr(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click <b>here</b> for the solution.\n",
    "\n",
    "<!-- Your answer is below:\n",
    "x=torch.tensor([[1.0],[2.0],[3.0]])\n",
    "lr1=LR(1,1)\n",
    "yhat=lr(x)\n",
    "yhat\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <!-- Your answer is below:\n",
    "x=torch.tensor([[1.0],[2.0],[3.0]])\n",
    "lr1=LR(1,1)\n",
    "yhat=lr1(x)\n",
    "yhat\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://dataplatform.cloud.ibm.com/registration/stepone?context=cpdaas&apps=data_science_experience,watson_machine_learning\"><img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-DL0110EN-SkillsNetwork/Template/module%201/images/Watson_Studio.png\"/></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": [
    "## <h3 align=\"center\"> © IBM Corporation 2020. All rights reserved. <h3/>\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}