5 1 logistic_regression_prediction_v2__M.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:center\">\n",
    "    <a href=\"https://skills.network\" target=\"_blank\">\n",
    "    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/assets/logos/SN_web_lightmode.png\" width=\"200\" alt=\"Skills Network Logo\">\n",
    "    </a>\n",
    "</p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Logistic Regression</h1>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Objective</h2><ul><li> How to create a logistic regression object with the nn.Sequential model.</li></ul> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Table of Contents</h2>\n",
    "<p>In this lab, we will cover logistic regression using PyTorch.</p>\n",
    "\n",
    "<ul>\n",
    "    <li><a href=\"#Log\">Logistic Function</a></li>\n",
    "    <li><a href=\"#Seq\">Build a Logistic Regression Using nn.Sequential</a></li>\n",
    "    <li><a href=\"#Model\">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": [
    "We'll need the following libraries:  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the libraries we need for this lab\n",
    "\n",
    "import torch.nn as nn\n",
    "import torch\n",
    "import matplotlib.pyplot as plt "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set the random seed:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7fc600035e30>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set the random seed\n",
    "\n",
    "torch.manual_seed(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Log\">Logistic Function</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a tensor ranging from -100 to 100:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tensor:  tensor([[-100.0000],\n",
      "        [ -99.9000],\n",
      "        [ -99.8000],\n",
      "        ...,\n",
      "        [  99.7000],\n",
      "        [  99.8000],\n",
      "        [  99.9000]])\n"
     ]
    }
   ],
   "source": [
    "z = torch.arange(-100, 100, 0.1).view(-1, 1)\n",
    "print(\"The tensor: \", z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a sigmoid object: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create sigmoid object\n",
    "\n",
    "sig = nn.Sigmoid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the element-wise function Sigmoid with the object:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use sigmoid object to calculate the \n",
    "\n",
    "yhat = sig(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the results: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'yhat')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(z.numpy(), yhat.numpy())\n",
    "plt.xlabel('z')\n",
    "plt.ylabel('yhat')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the element-wise Sigmoid from the function module and plot the results:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fc581e6abd0>]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "yhat = torch.sigmoid(z)\n",
    "plt.plot(z.numpy(), yhat.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Seq\">Build a Logistic Regression with <code>nn.Sequential</code></h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a 1x1 tensor where x represents one data sample with one dimension, and 2x1 tensor X represents two data samples of one dimension:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =  tensor([[1.]])\n",
      "X =  tensor([[  1.],\n",
      "        [100.]])\n"
     ]
    }
   ],
   "source": [
    "# Create x and X tensor\n",
    "\n",
    "x = torch.tensor([[1.0]])\n",
    "X = torch.tensor([[1.0], [100]])\n",
    "print('x = ', x)\n",
    "print('X = ', X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a logistic regression object with the <code>nn.Sequential</code> model with a one-dimensional input:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use sequential function to create model\n",
    "\n",
    "model = nn.Sequential(nn.Linear(1, 1), nn.Sigmoid())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The object is represented in the following diagram: \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter3/3.1.1_logistic_regression_block_diagram.png\" width=\"800,\" align=\"center\" alt=\"logistic regression block diagram\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, the parameters are randomly initialized. You can view them the following ways:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list(model.parameters()):\n",
      "  [Parameter containing:\n",
      "tensor([[0.2294]], requires_grad=True), Parameter containing:\n",
      "tensor([-0.2380], requires_grad=True)]\n",
      "\n",
      "model.state_dict():\n",
      "  OrderedDict([('0.weight', tensor([[0.2294]])), ('0.bias', tensor([-0.2380]))])\n"
     ]
    }
   ],
   "source": [
    "# Print the parameters\n",
    "\n",
    "print(\"list(model.parameters()):\\n \", list(model.parameters()))\n",
    "print(\"\\nmodel.state_dict():\\n \", model.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a prediction with one sample:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction:  tensor([[0.4979]], grad_fn=<SigmoidBackward>)\n"
     ]
    }
   ],
   "source": [
    "# The prediction for x\n",
    "\n",
    "yhat = model(x)\n",
    "print(\"The prediction: \", yhat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling the object with tensor <code>X</code> performed the following operation <b>(code values may not be the same as the diagrams value  depending on the version of PyTorch) </b>:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter3/3.1.1_logistic_functio_example%20.png\" width=\"400\" alt=\"Logistic Example\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a prediction with multiple samples:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.4979],\n",
       "        [1.0000]], grad_fn=<SigmoidBackward>)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The prediction for X\n",
    "\n",
    "yhat = model(X)\n",
    "yhat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling the object performed the following operation: \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a 1x2 tensor where x represents one data sample with one dimension, and 2x3 tensor X represents one data sample of two dimensions:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =  tensor([[1., 1.]])\n",
      "X =  tensor([[1., 1.],\n",
      "        [1., 2.],\n",
      "        [1., 3.]])\n"
     ]
    }
   ],
   "source": [
    "# Create and print samples\n",
    "\n",
    "x = torch.tensor([[1.0, 1.0]])\n",
    "X = torch.tensor([[1.0, 1.0], [1.0, 2.0], [1.0, 3.0]])\n",
    "print('x = ', x)\n",
    "print('X = ', X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a logistic regression object with the <code>nn.Sequential</code> model with a two-dimensional input: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create new model using nn.sequential()\n",
    "\n",
    "model = nn.Sequential(nn.Linear(2, 1), nn.Sigmoid())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The object will apply the Sigmoid function to the output of the linear function as shown in the following diagram:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter3/3.1.1logistic_output.png\" width=\"800\" alt=\"The structure of nn.sequential\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, the parameters are randomly initialized. You can view them the following ways:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list(model.parameters()):\n",
      "  [Parameter containing:\n",
      "tensor([[ 0.1939, -0.0361]], requires_grad=True), Parameter containing:\n",
      "tensor([0.3021], requires_grad=True)]\n",
      "\n",
      "model.state_dict():\n",
      "  OrderedDict([('0.weight', tensor([[ 0.1939, -0.0361]])), ('0.bias', tensor([0.3021]))])\n"
     ]
    }
   ],
   "source": [
    "# Print the parameters\n",
    "\n",
    "print(\"list(model.parameters()):\\n \", list(model.parameters()))\n",
    "print(\"\\nmodel.state_dict():\\n \", model.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a prediction with one sample:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction:  tensor([[0.6130]], grad_fn=<SigmoidBackward>)\n"
     ]
    }
   ],
   "source": [
    "# Make the prediction of x\n",
    "\n",
    "yhat = model(x)\n",
    "print(\"The prediction: \", yhat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The operation is represented in the following diagram:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter3/3.3.1.logisticwithouptut.png\" width=\"500\" alt=\"Sequential Example\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a prediction with multiple samples:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction:  tensor([[0.6130],\n",
      "        [0.6044],\n",
      "        [0.5957]], grad_fn=<SigmoidBackward>)\n"
     ]
    }
   ],
   "source": [
    "# The prediction of X\n",
    "\n",
    "yhat = model(X)\n",
    "print(\"The prediction: \", yhat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The operation is represented in the following diagram: \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter3/3.1.1_logistic_with_outputs2.png\" width=\"800\" alt=\"Sequential Example\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Model\">Build Custom Modules</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, you will build a custom Module or class. The model or object function is identical to using <code>nn.Sequential</code>.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a logistic regression custom module:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create logistic_regression custom class\n",
    "\n",
    "class logistic_regression(nn.Module):\n",
    "    \n",
    "    # Constructor\n",
    "    def __init__(self, n_inputs):\n",
    "        super(logistic_regression, self).__init__()\n",
    "        self.linear = nn.Linear(n_inputs, 1)\n",
    "    \n",
    "    # Prediction\n",
    "    def forward(self, x):\n",
    "        yhat = torch.sigmoid(self.linear(x))\n",
    "        return yhat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a 1x1 tensor where x represents one data sample with one dimension, and 3x1 tensor where $X$ represents one data sample of one dimension:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =  tensor([[1.]])\n",
      "X =  tensor([[-100.],\n",
      "        [   0.],\n",
      "        [ 100.]])\n"
     ]
    }
   ],
   "source": [
    "# Create x and X tensor\n",
    "\n",
    "x = torch.tensor([[1.0]])\n",
    "X = torch.tensor([[-100], [0], [100.0]])\n",
    "print('x = ', x)\n",
    "print('X = ', X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a model to predict one dimension: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create logistic regression model\n",
    "\n",
    "model = logistic_regression(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, the parameters are randomly initialized. You can view them the following ways:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list(model.parameters()):\n",
      "  [Parameter containing:\n",
      "tensor([[0.2381]], requires_grad=True), Parameter containing:\n",
      "tensor([-0.1149], requires_grad=True)]\n",
      "\n",
      "model.state_dict():\n",
      "  OrderedDict([('linear.weight', tensor([[0.2381]])), ('linear.bias', tensor([-0.1149]))])\n"
     ]
    }
   ],
   "source": [
    "# Print parameters \n",
    "\n",
    "print(\"list(model.parameters()):\\n \", list(model.parameters()))\n",
    "print(\"\\nmodel.state_dict():\\n \", model.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a prediction with one sample:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction result: \n",
      " tensor([[0.5307]], grad_fn=<SigmoidBackward>)\n"
     ]
    }
   ],
   "source": [
    "# Make the prediction of x\n",
    "\n",
    "yhat = model(x)\n",
    "print(\"The prediction result: \\n\", yhat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a prediction with multiple samples:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction result: \n",
      " tensor([[4.0805e-11],\n",
      "        [4.7130e-01],\n",
      "        [1.0000e+00]], grad_fn=<SigmoidBackward>)\n"
     ]
    }
   ],
   "source": [
    "# Make the prediction of X\n",
    "\n",
    "yhat = model(X)\n",
    "print(\"The prediction result: \\n\", yhat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a logistic regression object with a function with two inputs: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create logistic regression model\n",
    "\n",
    "model = logistic_regression(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a 1x2 tensor where x represents one data sample with one dimension, and 3x2 tensor X represents one data sample of one dimension:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =  tensor([[1., 2.]])\n",
      "X =  tensor([[ 100., -100.],\n",
      "        [   0.,    0.],\n",
      "        [-100.,  100.]])\n"
     ]
    }
   ],
   "source": [
    "# Create x and X tensor\n",
    "\n",
    "x = torch.tensor([[1.0, 2.0]])\n",
    "X = torch.tensor([[100, -100], [0.0, 0.0], [-100, 100]])\n",
    "print('x = ', x)\n",
    "print('X = ', X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a prediction with one sample:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction result: \n",
      " tensor([[0.2943]], grad_fn=<SigmoidBackward>)\n"
     ]
    }
   ],
   "source": [
    "# Make the prediction of x\n",
    "\n",
    "yhat = model(x)\n",
    "print(\"The prediction result: \\n\", yhat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a prediction with multiple samples: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction result: \n",
      " tensor([[7.7529e-33],\n",
      "        [3.4841e-01],\n",
      "        [1.0000e+00]], grad_fn=<SigmoidBackward>)\n"
     ]
    }
   ],
   "source": [
    "# Make the prediction of X\n",
    "\n",
    "yhat = model(X)\n",
    "print(\"The prediction result: \\n\", 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 your own model <code>my_model</code> as applying linear regression first and then logistic regression using <code>nn.Sequential()</code>. Print out your prediction.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction:  tensor([0.2231], grad_fn=<SigmoidBackward>)\n"
     ]
    }
   ],
   "source": [
    "# Practice: Make your model and make the prediction\n",
    "\n",
    "X = torch.tensor([-10.0])\n",
    "\n",
    "my_model = nn.Sequential(nn.Linear(1, 1),nn.Sigmoid())\n",
    "yhat = my_model(X)\n",
    "print(\"The prediction: \", yhat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click <b>here</b> for the solution.\n",
    "\n",
    "<!-- \n",
    "my_model = nn.Sequential(nn.Linear(1, 1),nn.Sigmoid())\n",
    "yhat = my_model(X)\n",
    "print(\"The prediction: \", yhat)\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "<a href=\"https://dataplatform.cloud.ibm.com/registration/stepone?utm_source=skills_network&utm_content=in_lab_content_link&utm_id=Lab-IBMDeveloperSkillsNetwork-DL0110EN-SkillsNetwork&context=cpdaas&apps=data_science_experience%2Cwatson_machine_learning\"><img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-DL0110EN-SkillsNetwork/Template/module%201/images/Watson_Studio.png\"></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\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": [
    "<!--\n",
    "## Change Log\n",
    "\n",
    "|  Date (YYYY-MM-DD) |  Version | Changed By  |  Change Description |\n",
    "|---|---|---|---|\n",
    "| 2020-09-23  | 2.0  | Shubham  |  Migrated Lab to Markdown and added to course repo in GitLab |\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## <h3 align=\"center\"> &#169; IBM Corporation. All rights reserved. <h3/>\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python",
   "language": "python",
   "name": "conda-env-python-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}