Skip to content

Instantly share code, notes, and snippets.

@mohayl

mohayl/2.1Prediction1Dregression_v3.ipynb

Forked from zhaleh-rahimi/2.1Prediction1Dregression_v3.ipynb
Created August 17, 2022 16:02
Show Gist options
  • Save mohayl/3e94dc9f0dcf0109eeedeecdf2c8d9fc to your computer and use it in GitHub Desktop.
Save mohayl/3e94dc9f0dcf0109eeedeecdf2c8d9fc to your computer and use it in GitHub Desktop.
Download ZIP
Display the source blob
Display the rendered blob
Raw
2.1Prediction1Dregression_v3.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Display the source blob
Display the rendered blob
Raw
2.2_linear_regression_one_parameter_v3.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Display the source blob
Display the rendered blob
Raw
2.3_training_slope_and_bias_v3.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Display the source blob
Display the rendered blob
Raw
3.1_stochastic_gradient_descent_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: Training Two Parameter Stochastic Gradient Descent (SGD)</h1>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2>Objective</h2><ul><li> How to use SGD(Stochastic Gradient Descent) to train the model.</li></ul> \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2>Table of Contents</h2>\n",
"<p>In this Lab, you will practice training a model by using Stochastic Gradient descent.</p>\n",
"\n",
"<ul>\n",
" <li><a href=\"#Makeup_Data\">Make Some Data</a></li>\n",
" <li><a href=\"#Model_Cost\">Create the Model and Cost Function (Total Loss)</a></li>\n",
" <li><a href=\"#BGD\">Train the Model:Batch Gradient Descent</a></li>\n",
" <li><a href=\"#SGD\">Train the Model:Stochastic gradient descent</a></li>\n",
" <li><a href=\"#SGD_Loader\">Train the Model:Stochastic gradient descent with Data Loader</a></li>\n",
"</ul>\n",
"<p>Estimated Time Needed: <strong>30 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": null,
"metadata": {},
"outputs": [],
"source": [
"# These are the libraries we are going to use in the lab.\n",
"\n",
"import torch\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"from mpl_toolkits import mplot3d"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The class <code>plot_error_surfaces</code> is just to help you visualize the data space and the parameter space during training and has nothing to do with PyTorch.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# The class for plot the diagram\n",
"\n",
"class plot_error_surfaces(object):\n",
" \n",
" # Constructor\n",
" def __init__(self, w_range, b_range, X, Y, n_samples = 30, go = True):\n",
" W = np.linspace(-w_range, w_range, n_samples)\n",
" B = np.linspace(-b_range, b_range, n_samples)\n",
" w, b = np.meshgrid(W, B) \n",
" Z = np.zeros((30, 30))\n",
" count1 = 0\n",
" self.y = Y.numpy()\n",
" self.x = X.numpy()\n",
" for w1, b1 in zip(w, b):\n",
" count2 = 0\n",
" for w2, b2 in zip(w1, b1):\n",
" Z[count1, count2] = np.mean((self.y - w2 * self.x + b2) ** 2)\n",
" count2 += 1\n",
" count1 += 1\n",
" self.Z = Z\n",
" self.w = w\n",
" self.b = b\n",
" self.W = []\n",
" self.B = []\n",
" self.LOSS = []\n",
" self.n = 0\n",
" if go == True:\n",
" plt.figure()\n",
" plt.figure(figsize = (7.5, 5))\n",
" plt.axes(projection = '3d').plot_surface(self.w, self.b, self.Z, rstride = 1, cstride = 1,cmap = 'viridis', edgecolor = 'none')\n",
" plt.title('Loss Surface')\n",
" plt.xlabel('w')\n",
" plt.ylabel('b')\n",
" plt.show()\n",
" plt.figure()\n",
" plt.title('Loss Surface Contour')\n",
" plt.xlabel('w')\n",
" plt.ylabel('b')\n",
" plt.contour(self.w, self.b, self.Z)\n",
" plt.show()\n",
" \n",
" # Setter\n",
" def set_para_loss(self, W, B, loss):\n",
" self.n = self.n + 1\n",
" self.W.append(W)\n",
" self.B.append(B)\n",
" self.LOSS.append(loss)\n",
" \n",
" # Plot diagram\n",
" def final_plot(self): \n",
" ax = plt.axes(projection = '3d')\n",
" ax.plot_wireframe(self.w, self.b, self.Z)\n",
" ax.scatter(self.W, self.B, self.LOSS, c = 'r', marker = 'x', s = 200, alpha = 1)\n",
" plt.figure()\n",
" plt.contour(self.w, self.b, self.Z)\n",
" plt.scatter(self.W, self.B, c = 'r', marker = 'x')\n",
" plt.xlabel('w')\n",
" plt.ylabel('b')\n",
" plt.show()\n",
" \n",
" # Plot diagram\n",
" def plot_ps(self):\n",
" plt.subplot(121)\n",
" plt.ylim\n",
" plt.plot(self.x, self.y, 'ro', label = \"training points\")\n",
" plt.plot(self.x, self.W[-1] * self.x + self.B[-1], label = \"estimated line\")\n",
" plt.xlabel('x')\n",
" plt.ylabel('y')\n",
" plt.ylim((-10, 15))\n",
" plt.title('Data Space Iteration: ' + str(self.n))\n",
" plt.subplot(122)\n",
" plt.contour(self.w, self.b, self.Z)\n",
" plt.scatter(self.W, self.B, c = 'r', marker = 'x')\n",
" plt.title('Loss Surface Contour Iteration' + str(self.n))\n",
" plt.xlabel('w')\n",
" plt.ylabel('b')\n",
" plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"Makeup_Data\">Make Some Data</h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Set random seed: \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Set random seed\n",
"\n",
"torch.manual_seed(1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Generate values from <i>-3</i> to <i>3</i> that create a line with a slope of <i>1</i> and a bias of <i>-1</i>. This is the line that you need to estimate. Add some noise to the data:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Setup the actual data and simulated data\n",
"\n",
"X = torch.arange(-3, 3, 0.1).view(-1, 1)\n",
"f = 1 * X - 1\n",
"Y = f + 0.1 * torch.randn(X.size())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Plot the results:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Plot out the data dots and line\n",
"\n",
"plt.plot(X.numpy(), Y.numpy(), 'rx', label = 'y')\n",
"plt.plot(X.numpy(), f.numpy(), label = 'f')\n",
"plt.xlabel('x')\n",
"plt.ylabel('y')\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"Model_Cost\">Create the Model and Cost Function (Total Loss)</h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Define the <code>forward</code> function:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Define the forward function\n",
"\n",
"def forward(x):\n",
" return w * x + b"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Define the cost or criterion function (MSE): \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Define the MSE Loss function\n",
"\n",
"def criterion(yhat, y):\n",
" return torch.mean((yhat - y) ** 2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create a <code> plot_error_surfaces</code> object to visualize the data space and the parameter space during training:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create plot_error_surfaces for viewing the data\n",
"\n",
"get_surface = plot_error_surfaces(15, 13, X, Y, 30)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"BGD\">Train the Model: Batch Gradient Descent</h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create model parameters <code>w</code>, <code>b</code> by setting the argument <code>requires_grad</code> to True because the system must learn it.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Define the parameters w, b for y = wx + b\n",
"\n",
"w = torch.tensor(-15.0, requires_grad = True)\n",
"b = torch.tensor(-10.0, requires_grad = True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Set the learning rate to 0.1 and create an empty list <code>LOSS</code> for storing the loss for each iteration.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Define learning rate and create an empty list for containing the loss for each iteration.\n",
"\n",
"lr = 0.1\n",
"LOSS_BGD = []"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Define <code>train_model</code> function for train the model.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# The function for training the model\n",
"\n",
"def train_model(iter):\n",
" \n",
" # Loop\n",
" for epoch in range(iter):\n",
" \n",
" # make a prediction\n",
" Yhat = forward(X)\n",
" \n",
" # calculate the loss \n",
" loss = criterion(Yhat, Y)\n",
"\n",
" # Section for plotting\n",
" get_surface.set_para_loss(w.data.tolist(), b.data.tolist(), loss.tolist())\n",
" get_surface.plot_ps()\n",
" \n",
" # store the loss in the list LOSS_BGD\n",
" LOSS_BGD.append(loss)\n",
" \n",
" # backward pass: compute gradient of the loss with respect to all the learnable parameters\n",
" loss.backward()\n",
" \n",
" # update parameters slope and bias\n",
" w.data = w.data - lr * w.grad.data\n",
" b.data = b.data - lr * b.grad.data\n",
" \n",
" # zero the gradients before running the backward pass\n",
" w.grad.data.zero_()\n",
" b.grad.data.zero_()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Run 10 epochs of batch gradient descent: <b>bug</b> data space is 1 iteration ahead of parameter space. \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Train the model with 10 iterations\n",
"\n",
"train_model(10)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"SGD\">Train the Model: Stochastic Gradient Descent</h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create a <code>plot_error_surfaces</code> object to visualize the data space and the parameter space during training:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create plot_error_surfaces for viewing the data\n",
"\n",
"get_surface = plot_error_surfaces(15, 13, X, Y, 30, go = False)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Define <code>train_model_SGD</code> function for training the model.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# The function for training the model\n",
"\n",
"LOSS_SGD = []\n",
"w = torch.tensor(-15.0, requires_grad = True)\n",
"b = torch.tensor(-10.0, requires_grad = True)\n",
"\n",
"def train_model_SGD(iter):\n",
" \n",
" # Loop\n",
" for epoch in range(iter):\n",
" \n",
" # SGD is an approximation of out true total loss/cost, in this line of code we calculate our true loss/cost and store it\n",
" Yhat = forward(X)\n",
"\n",
" # store the loss \n",
" LOSS_SGD.append(criterion(Yhat, Y).tolist())\n",
" \n",
" for x, y in zip(X, Y):\n",
" \n",
" # make a pridiction\n",
" yhat = forward(x)\n",
" \n",
" # calculate the loss \n",
" loss = criterion(yhat, y)\n",
"\n",
" # Section for plotting\n",
" get_surface.set_para_loss(w.data.tolist(), b.data.tolist(), loss.tolist())\n",
" \n",
" # backward pass: compute gradient of the loss with respect to all the learnable parameters\n",
" loss.backward()\n",
" \n",
" # update parameters slope and bias\n",
" w.data = w.data - lr * w.grad.data\n",
" b.data = b.data - lr * b.grad.data\n",
"\n",
" # zero the gradients before running the backward pass\n",
" w.grad.data.zero_()\n",
" b.grad.data.zero_()\n",
" \n",
" #plot surface and data space after each epoch \n",
" get_surface.plot_ps()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Run 10 epochs of stochastic gradient descent: <b>bug</b> data space is 1 iteration ahead of parameter space. \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Train the model with 10 iterations\n",
"\n",
"train_model_SGD(10)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Compare the loss of both batch gradient descent as SGD.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Plot out the LOSS_BGD and LOSS_SGD\n",
"\n",
"plt.plot(LOSS_BGD,label = \"Batch Gradient Descent\")\n",
"plt.plot(LOSS_SGD,label = \"Stochastic Gradient Descent\")\n",
"plt.xlabel('epoch')\n",
"plt.ylabel('Cost/ total loss')\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!--Empty Space for separating topics-->\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"SGD_Loader\">SGD with Dataset DataLoader</h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Import the module for building a dataset class: \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Import the library for DataLoader\n",
"\n",
"from torch.utils.data import Dataset, DataLoader"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create a dataset class:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Dataset Class\n",
"\n",
"class Data(Dataset):\n",
" \n",
" # Constructor\n",
" def __init__(self):\n",
" self.x = torch.arange(-3, 3, 0.1).view(-1, 1)\n",
" self.y = 1 * self.x - 1\n",
" self.len = self.x.shape[0]\n",
" \n",
" # Getter\n",
" def __getitem__(self,index): \n",
" return self.x[index], self.y[index]\n",
" \n",
" # Return the length\n",
" def __len__(self):\n",
" return self.len"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create a dataset object and check the length of the dataset.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create the dataset and check the length\n",
"\n",
"dataset = Data()\n",
"print(\"The length of dataset: \", len(dataset))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Obtain the first training point: \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Print the first point\n",
"\n",
"x, y = dataset[0]\n",
"print(\"(\", x, \", \", y, \")\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Similarly, obtain the first three training points: \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Print the first 3 point\n",
"\n",
"x, y = dataset[0:3]\n",
"print(\"The first 3 x: \", x)\n",
"print(\"The first 3 y: \", y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create a <code>plot_error_surfaces</code> object to visualize the data space and the parameter space during training:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create plot_error_surfaces for viewing the data\n",
"\n",
"get_surface = plot_error_surfaces(15, 13, X, Y, 30, go = False)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create a <code>DataLoader</code> object by using the constructor: \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create DataLoader\n",
"\n",
"trainloader = DataLoader(dataset = dataset, batch_size = 1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Define <code>train_model_DataLoader</code> function for training the model.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# The function for training the model\n",
"\n",
"w = torch.tensor(-15.0,requires_grad=True)\n",
"b = torch.tensor(-10.0,requires_grad=True)\n",
"LOSS_Loader = []\n",
"\n",
"def train_model_DataLoader(epochs):\n",
" \n",
" # Loop\n",
" for epoch in range(epochs):\n",
" \n",
" # SGD is an approximation of out true total loss/cost, in this line of code we calculate our true loss/cost and store it\n",
" Yhat = forward(X)\n",
" \n",
" # store the loss \n",
" LOSS_Loader.append(criterion(Yhat, Y).tolist())\n",
" \n",
" for x, y in trainloader:\n",
" \n",
" # make a prediction\n",
" yhat = forward(x)\n",
" \n",
" # calculate the loss\n",
" loss = criterion(yhat, y)\n",
" \n",
" # Section for plotting\n",
" get_surface.set_para_loss(w.data.tolist(), b.data.tolist(), loss.tolist())\n",
" \n",
" # Backward pass: compute gradient of the loss with respect to all the learnable parameters\n",
" loss.backward()\n",
" \n",
" # Updata parameters slope\n",
" w.data = w.data - lr * w.grad.data\n",
" b.data = b.data - lr* b.grad.data\n",
" \n",
" # Clear gradients \n",
" w.grad.data.zero_()\n",
" b.grad.data.zero_()\n",
" \n",
" #plot surface and data space after each epoch \n",
" get_surface.plot_ps()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Run 10 epochs of stochastic gradient descent: <b>bug</b> data space is 1 iteration ahead of parameter space. \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Run 10 iterations\n",
"\n",
"train_model_DataLoader(10)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Compare the loss of both batch gradient decent as SGD. Note that SGD converges to a minimum faster, that is, it decreases faster. \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Plot the LOSS_BGD and LOSS_Loader\n",
"\n",
"plt.plot(LOSS_BGD,label=\"Batch Gradient Descent\")\n",
"plt.plot(LOSS_Loader,label=\"Stochastic Gradient Descent with DataLoader\")\n",
"plt.xlabel('epoch')\n",
"plt.ylabel('Cost/ total loss')\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3>Practice</h3>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For practice, try to use SGD with DataLoader to train model with 10 iterations. Store the total loss in <code>LOSS</code>. We are going to use it in the next question.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Practice: Use SGD with trainloader to train model and store the total loss in LOSS\n",
"\n",
"LOSS = []\n",
"w = torch.tensor(-12.0, requires_grad = True)\n",
"b = torch.tensor(-10.0, requires_grad = True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Double-click <b>here</b> for the solution.\n",
"\n",
"<!-- \n",
"def my_train_model(epochs):\n",
" for epoch in range(epochs):\n",
" Yhat = forward(X)\n",
" LOSS.append(criterion(Yhat, X))\n",
" for x, y in trainloader:\n",
" yhat = forward(x)\n",
" loss = criterion(yhat, y)\n",
" get_surface.set_para_loss(w.data.tolist(), b.data.tolist(), loss.tolist())\n",
" loss.backward()\n",
" w.data = w.data - lr * w.grad.data\n",
" b.data = b.data - lr * b.grad.data\n",
" w.grad.data.zero_()\n",
" b.grad.data.zero_()\n",
" get_surface.plot_ps()\n",
"my_train_model(10)\n",
"-->\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Plot the total loss\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Practice: Plot the total loss using LOSS\n",
"\n",
"plt.plot(LOSS,label = \"Stochastic Gradient Descent\")\n",
"plt.xlabel('iteration')\n",
"plt.ylabel('Cost/ total loss')\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Double-click **here** for the solution.\n",
"\n",
"<!-- \n",
"plt.plot(LOSS,label = \"Stochastic Gradient Descent\")\n",
"plt.xlabel('iteration')\n",
"plt.ylabel('Cost/ total loss')\n",
"plt.legend()\n",
"plt.show()\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": [
"<!--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",
"\n",
"Thanks to: Andrew Kin ,Alessandro Barboza\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 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"
]
},
{
"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"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Display the source blob
Display the rendered blob
Raw
3.2_mini-batch_gradient_descent_v3.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Display the source blob
Display the rendered blob
Raw
3.3_PyTorchway_v3.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Display the source blob
Display the rendered blob
Raw
3.6_training_and_validation_v3.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment