{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "$$\\newcommand{\\mat}[1]{\\boldsymbol {#1}}\n", "\\newcommand{\\mattr}[1]{\\boldsymbol {#1}^\\top}\n", "\\newcommand{\\matinv}[1]{\\boldsymbol {#1}^{-1}}\n", "\\newcommand{\\vec}[1]{\\boldsymbol {#1}}\n", "\\newcommand{\\vectr}[1]{\\boldsymbol {#1}^\\top}\n", "\\newcommand{\\rvar}[1]{\\mathrm {#1}}\n", "\\newcommand{\\rvec}[1]{\\boldsymbol{\\mathrm{#1}}}\n", "\\newcommand{\\diag}{\\mathop{\\mathrm {diag}}}\n", "\\newcommand{\\set}[1]{\\mathbb {#1}}\n", "\\newcommand{\\norm}[1]{\\left\\lVert#1\\right\\rVert}\n", "\\newcommand{\\pderiv}[2]{\\frac{\\partial #1}{\\partial #2}}\n", "\\newcommand{\\bb}[1]{\\boldsymbol{#1}}$$\n", "\n", "# CS236781: Deep Learning\n", "# Tutorial 2: Multilayer Perceptron" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Introduction\n", "\n", "In this tutorial, we will cover:\n", "\n", "* Linear (fully connected) layers\n", "* Activation functions\n", "* 2-Layer MLP implementation from scratch (self study)\n", "* N-layer MLP with PyTorch's `autograd` and `optim` modules" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:49.016538Z", "iopub.status.busy": "2021-05-06T06:05:49.016034Z", "iopub.status.idle": "2021-05-06T06:05:50.095393Z", "shell.execute_reply": "2021-05-06T06:05:50.095954Z" }, "slideshow": { "slide_type": "skip" } }, "outputs": [], "source": [ "# Setup\n", "%matplotlib inline\n", "import os\n", "import numpy as np\n", "import sklearn\n", "import torch\n", "import matplotlib.pyplot as plt\n", "from typing import Sequence" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:50.099377Z", "iopub.status.busy": "2021-05-06T06:05:50.098809Z", "iopub.status.idle": "2021-05-06T06:05:50.126349Z", "shell.execute_reply": "2021-05-06T06:05:50.126947Z" }, "slideshow": { "slide_type": "skip" } }, "outputs": [], "source": [ "plt.rcParams['font.size'] = 20" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Reminder: Perceptrons and linear models" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "The following hypothesis class\n", "$$\n", "\\mathcal{H} =\n", "\\left\\{ h: \\mathcal{X}\\rightarrow\\mathcal{Y}\n", "~\\vert~\n", "h(\\vec{x}) = \\varphi(\\vectr{w}\\vec{x}+b); \\vec{w}\\in\\set{R}^D,~b\\in\\set{R}\\right\\}\n", "$$\n", "where $\\varphi(\\cdot)$ is some nonlinear function, is composed of functions representing the **perceptron** model.\n", "\n", "\n", " " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Last tutorial: we trained a **logistic regression** model by using\n", "$$\\varphi(\\vec{z})=\\sigma(\\vec{z})=\\frac{1}{1+\\exp(-\\vec{z})}\\in[0,1].$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "**Limitation**: logistic regression is still a linear classifier. In what sense is it linear though?\n", "\n", "$$\\hat{y} = \\sigma(\\vectr{w}\\vec{x}+b)$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "**Linear** in the sense that output depends only on a linear combination of weights and inputs.\n", "\n", "Decision boundaries are therefore straight lines:\n", "\n", "
" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "skip" } }, "source": [ "If we define $y(\\vec{x})=\\vectr{w}\\vec{x}+b$, then the **decision surface** of the classifier is $y(\\vec{x})=\\text{const}$ (usually zero). Note that $b=w_0$ in the diagram below." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "skip" } }, "source": [ "
" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "skip" } }, "source": [ "1. For any $\\vec{x_1}, \\vec{x_2}$ on the decision boundary, $\\vectr{w}(\\vec{x_1}-\\vec{x_2})=0$ $\\Rightarrow \\vec{w}$ orthogonal to every vector in the surface.\n", "1. For any $\\vec{x_1}$ on the decision boundary, $\\vectr{w}\\vec{x_1}=-b$. \n", "Since $\\frac{\\vectr{w}}{\\norm{\\vec{w}}}\\vec{x_1}$ is the length of the projection of $\\vec{x_1}$ onto $\\vec{w}$, then the distance of the boundary from origin is given by\n", "$\\frac{-b}{\\norm{\\vec{w}}}$.\n", "1. For any point $\\vec{x}$, $\\frac{y(\\vec{x})}{\\norm{\\vec{w}}}$ is the **signed perpendicular distance** from the decision boundary." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "What if our data is not linearly separable? Can we still use e.g. logistic regression?" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "
" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "What if we first apply a **fixed** non-linear transformation to the data?\n", "\n", "For some $\\psi: \\set{R}^d \\rightarrow \\set{R}^D$, what does the following classifier do?\n", "\n", "$$\\hat{y} = \\varphi(\\vectr{w}\\psi(\\vec{x})+b).$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "We still get a linear decision boundary, but relative to the new features $\\psi(\\vec{x})\\in\\set{R}^D$.\n", "Projecting this boundary back to $\\set{R}^d$, we can get nonlinear decision boundaries with respect to $\\vec{x}\\in\\set{R}^d$." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "But how can we choose a nonlinear transformation? \n", "Traditional ML: Craft it painstakingly based on domain-knowledge.\n", "\n", "But what if we want to **learn** it?" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Multilayer Perceptron (MLP)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "### Model\n", "\n", "
\n", "\n", "Composed of $L$ **layers**, each layer $l$ with $n_l$ **perceptron** (\"neuron\") units." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Each layer $l$ operates on the output of the previous layer ($\\vec{y}_{l-1}$) and calculates:\n", "\n", "$$\n", "\\vec{y}_l = \\varphi\\left( \\mat{W}_l \\vec{y}_{l-1} + \\vec{b}_l \\right),~\n", "\\mat{W}_l\\in\\set{R}^{n_{l}\\times n_{l-1}},~ \\vec{b}_l\\in\\set{R}^{n_l},~ l \\in \\{1,2,\\dots,L\\}.\n", "$$\n", "\n", "- We'll refer to such layers as **fully-connected** or FC layers.\n", "- First layer accepts the input, i.e. $\\vec{y}_0=\\vec{x}\\in\\set{R}^d$.\n", "- Last layer $y_L$ is the output of the model.\n", "- The layers $1, 2, \\dots, L-1$ reffered to as hidden layers." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "How powerful is an MLP model? I.e. which functions can it approximate?" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "**Universal approximator theorem**\n", "\n", "Given enough parameters, an MLP with $L>1$ and any non-linear activation function, can approximate any continuous function up to any specified precision (Cybenko, 1989).\n", "\n", "The MLP is therefore a **potent hypothesis class** (recall approximation error).\n", "\n", "See [here](http://neuralnetworksanddeeplearning.com/chap4.html) for an intuitive explanation of the UAT." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Given an input sample $\\vec{x}^i$, the computed function of an $L$-layer MLP is:\n", "$$\n", "\\vec{y}_L^i= \\varphi \\left(\n", "\\mat{W}_L \\varphi \\left( \\cdots\n", "\\varphi \\left( \\mat{W}_1 \\vec{x}^i + \\vec{b}_1 \\right)\n", "\\cdots \\right)\n", "+ \\vec{b}_L \\right)\n", "$$\n", "\n", "This expression is fully differentiable w.r.t. parameters using the Chain Rule.\n", "\n", "And notice that $\\vec{y}_L^i = \\varphi(\\mat{W}_L \\vec{y}_{L-1}^i + \\vec{b}_L)$ is just the linear model we started with.\n", "\n", "So, intuitively, we can think of $\\vec{y}_{L-1}$ as **learned** non-linear features of the input! In other words, $\\vec{y}_{L-1} = \\psi_{\\vec{\\Theta}}(\\vec{x})$." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Since an MLP it has a non-linear dependency on it's inputs, through a learned transformation, non-linear decision boundaries are possible.\n", "\n", "For example, an MLP with 1, 2 and 4 hidden layers, 3 neurons each:\n", " \n", "
\"overfit1\"
" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Activation functions " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "An **activation function** is the non-linear elementwise function $\\varphi(\\cdot)$ which operates on the affine part of the perceptron model.\n", "\n", "Why do we even need non-linearities in the first place? Isn't the depth enough?" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Without them, the MLP model would be equivalent to a single affine transform." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Common choices for the activation functions are:\n", "\n", "- The logistic function (sigmoid)\n", " $$ \\varphi(t) = \\sigma(t) = \\frac{1}{1+e^{-t}} \\in [0,1] $$\n", "- The hyperbolic tangent (a shifted and scaled sigmoid)\n", " $$ \\varphi(t) = \\mathrm{tanh}(t) = \\frac{e^t - e^{-t}}{e^t +e^{-t}} \\in [-1,1]$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "- ReLU, rectified linear unit\n", " $$ \\varphi(t) = \\max\\{t,0\\} $$\n", "Note that ReLU is not strictly differentiable. However, sub-gradients exist. We will define its gradient as:\n", " $$ \\pderiv{\\varphi}{t} = \\begin{cases} 1, & t\\geq0 \\\\ 0, & t<0 \\end{cases} $$" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:50.133600Z", "iopub.status.busy": "2021-05-06T06:05:50.133072Z", "iopub.status.idle": "2021-05-06T06:05:50.160650Z", "shell.execute_reply": "2021-05-06T06:05:50.161177Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "# Plot some activation functions and their gradients\n", "\n", "# Activation functions\n", "relu = lambda x: np.maximum(0, x)\n", "sigmoid = lambda x: 1 / (1 + np.exp(-x))\n", "tanh = lambda x: (np.exp(x)-np.exp(-x)) / (np.exp(x)+np.exp(-x))\n", "\n", "# Their gradients\n", "g_relu = lambda x: np.array(relu(x) > 0, float)\n", "g_sigmoid = lambda x: sigmoid(x) * (1-sigmoid(x))\n", "g_tanh = lambda x: (1 - tanh(x) ** 2)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:50.165974Z", "iopub.status.busy": "2021-05-06T06:05:50.165449Z", "iopub.status.idle": "2021-05-06T06:05:50.760248Z", "shell.execute_reply": "2021-05-06T06:05:50.760759Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "x = np.linspace(-4, 4, num=1024)\n", "_, axes = plt.subplots(nrows=1, ncols=2, figsize=(16,5))\n", "axes[0].plot(x, relu(x), x, sigmoid(x), x, tanh(x))\n", "axes[1].plot(x, g_relu(x), x, g_sigmoid(x), x, g_tanh(x))\n", "legend_entries = (r'\\mathrm{ReLU}(x)', r'\\sigma(x)', r'\\mathrm{tanh}(x)')\n", "for ax, legend_prefix in zip(axes, ('', r'\\frac{\\partial}{\\partial x}')):\n", " ax.grid(True)\n", " ax.legend(tuple(f'${legend_prefix}{legend_entry}$' for legend_entry in legend_entries))\n", " ax.set_ylim((-1.1,1.1))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Some reasons people cite for using ReLU are:\n", "\n", "- Does not suffer from vanishing gradient when $x$ is far from zero (though gradient can still be zero).\n", "\n", "- Much faster to compute than sigmoid and tanh.\n", "\n", "- Promotes sparse weight vectors: \"dead neurons\" arguably cause sparsity in the next layer." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Visualization of hand-crafted features vs. MLP" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Visualization of the effect of features and MLP layers: http://playground.tensorflow.org/\n", "\n", "Try to explain what you see for the circles dataset with:\n", "- No hidden layers\n", "- One hidden layer, two neurons\n", "- One hiddlen layer, three neurons" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Part 1: Two-layer MLP from scratch" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Let's solve a simple **regression** problem with a 2-layer MLP (one hidden layer, one output layer)." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "We're trying to learn a continuous and perhaps non-deterministic function $y=f(\\vec{x})$.\n", "\n", "- Domain: $\\vec{x}^i \\in \\set{R}^{D_{\\text{in}}}$\n", "\n", "- Target: $y^i \\in \\set{R}^{D_{\\text{out}}}$\n", "\n", "- Model: $\\hat{y} =\\mat{W}_2~ \\varphi(\\mat{W}_1 \\vec{x}+ \\vec{b}_1) + \\vec{b}_2$
\n", " i.e. a 2-layer MLP, where:\n", " - $\\vec{x}\\in\\set{R}^{D_{\\text{in}}}$ sample (feature vector)\n", " - $\\mat{W}_1\\in\\set{R}^{H\\times D_{\\text{in}}},\\ \\vec{b}_1\\in\\set{R}^{H}$\n", " - $\\mat{W}_2\\in\\set{R}^{D_{\\text{out}}\\times H},\\ \\vec{b}_2\\in\\set{R}^{D_{\\text{out}}}$\n", " - $\\varphi(\\cdot) = \\mathrm{ReLU}(\\cdot) = \\max\\{\\cdot,0\\}$\n", " - $H$ is the hidden dimension\n", " - We'll set $D_{\\text{out}}=1$ so output is a scalar\n", " " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ " \n", "- MSE loss with L2 regularization:\n", " $$\n", " \\begin{align}\n", " \\ell(\\vec{y},\\vec{\\hat y}) &= \\frac{1}{2}\\norm{\\vec{\\hat y} - \\vec{y}}^2 \\\\\n", " L_{\\mathcal{S}} &= \\frac{1}{N}\\sum_{i=1}^{N}\\ell(\\vec{y},\\vec{\\hat y}) + \\frac{\\lambda}{2}\\left(\\norm{\\mat{W}_1}_F^2 + \\norm{\\mat{W}_2}_F^2 \\right)\n", " \\end{align}\n", " $$\n", "- Optimization scheme: Vanilla SGD" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Computing the loss gradients with backpropagation" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Let's write our model as \n", "$$\n", "\\hat{y} =\\mat{W}_2~ \\underbrace{\\mathrm{relu}(\\overbrace{\\mat{W}_1 \\vec{x}+ \\vec{b}_1}^{\\vec{z}})}_{\\vec{a}} + \\vec{b}_2,\n", "$$\n", "\n", "and manually derive the gradient of the point-wise loss $\\ell(\\vec{y},\\vec{\\hat y})$ using the **chain rule**.\n", "Remember that to use SGD, we need the gradient of the loss w.r.t. our parameter tensors." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "$$\n", "\\begin{align}\n", "&\\pderiv{\\ell}{\\vec{\\hat y}}=2\\cdot\\frac{1}{2}(\\vec{\\hat y}-\\vec{y}) = (\\vec{\\hat y}-\\vec{y})\\\\\n", "(\\ast)~~&\\pderiv{\\ell}{\\mat{W}_2}= \\pderiv{\\ell}{\\vec{\\hat y}}\\pderiv{\\vec{\\hat y}}{\\mat{W}_2}\n", "=(\\vec{\\hat y}-\\vec{y})\\vectr{a}\n", "\\end{align}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "How do we continue into the nonlinearity? Recall that we defined\n", "\n", "$$ \\pderiv{\\mathrm{relu}(x)}{x} = \\begin{cases} 1, & x\\geq0 \\\\ 0, & x<0 \\end{cases} $$\n", "\n", "and that we apply the non-linearity elementwise on input tensors.\n", "\n", "Also remember that the gradient of a vector w.r.t. another vector is the Jacobian, a matrix of mixed derivatives:\n", "$\\pderiv{a_i}{z_j}$.\n", "\n", "We have $\\vec{a}=\\mathrm{relu}(\\vec{z})$. Thus,\n", "\n", "$$\n", "\\pderiv{\\vec{a}}{\\vec{z}}=\\mathrm{diag}(\\mathbb{1}[\\vec{z}>0]).\n", "$$\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "And so,\n", "$$\n", "\\begin{align}\n", "&\\pderiv{\\ell}{\\vec{a}}=\\pderiv{\\vec{\\hat y}}{\\vec{a}}\\pderiv{\\ell}{\\vec{\\hat y}}\n", "=\\mattr{W}_2(\\vec{\\hat y}-\\vec{y})\\\\\n", "&\\pderiv{\\ell}{\\vec{z}}=\\pderiv{\\vec{a}}{\\vec{z}}\\pderiv{\\ell}{\\vec{a}}\n", "=\\mathrm{diag}(\\mathbb{1}[\\vec{z}>0])\\mattr{W}_2(\\vec{\\hat y}-\\vec{y})\\\\\n", "(\\ast)~~&\\pderiv{\\ell}{\\mat{W}_1}=\\pderiv{\\ell}{\\vec{z}}\\pderiv{\\vec{z}}{\\mat{W}_1}\n", "=\\mathrm{diag}(\\mathbb{1}[\\vec{z}>0])\\mattr{W}_2(\\vec{\\hat y}-\\vec{y})\\vectr{x}\\\\\n", "\\end{align}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "For the biases, we can easily see that:\n", "$$\n", "\\begin{align}\n", "(\\ast)~~&\\pderiv{\\ell}{\\vec{b}_2}=\\pderiv{\\vec{\\hat y}}{\\vec{b}_2}\\pderiv{\\ell}{\\vec{\\hat y}}\n", "=I_{D_{\\text{out}}} \\pderiv{\\ell}{\\vec{\\hat y}} \\\\\n", "(\\ast)~~&\\pderiv{\\ell}{\\vec{b}_1}=\\pderiv{\\vec{z}}{\\vec{b}_1}\\pderiv{\\ell}{\\vec{z}}\n", "=I_{H}\\pderiv{\\ell}{\\vec{z}}\\\\\n", "\\end{align}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "The final gradients for weight update, including regularization will be\n", "\n", "$$\n", "\\nabla_{\\mat{W}_j}L_{\\mathcal{S}}=\\frac{1}{N}\\sum_{i=1}^{N} \\pderiv{\\ell_i}{\\mat{W}_j} + \\lambda\\mat{W}_j, \\ j=1,2.\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Let's implement it from scratch using just `numpy`." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:50.765583Z", "iopub.status.busy": "2021-05-06T06:05:50.765098Z", "iopub.status.idle": "2021-05-06T06:05:50.793785Z", "shell.execute_reply": "2021-05-06T06:05:50.794381Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "# A simple MLP with one hidden layer\n", "\n", "# N: batch size\n", "# D_in: number of features\n", "N, D_in = 64, 10\n", "# H: hidden-layer\n", "# D_out: output dimension\n", "H, D_out = 100, 1\n", "\n", "# Random input data\n", "X = np.random.randn(N, D_in)\n", "y = np.random.randn(N, D_out)\n", "\n", "# Model weights and biases\n", "wstd = 0.01\n", "W1 = np.random.randn(H, D_in)*wstd\n", "b1 = np.random.randn(H,)*wstd + 0.1\n", "W2 = np.random.randn(D_out, H)*wstd\n", "b2 = np.random.randn(D_out,)*wstd + 0.1\n", "\n", "reg_lambda = 0.5\n", "learning_rate = 1e-3" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:50.799749Z", "iopub.status.busy": "2021-05-06T06:05:50.799193Z", "iopub.status.idle": "2021-05-06T06:05:50.925423Z", "shell.execute_reply": "2021-05-06T06:05:50.925994Z" }, "scrolled": true, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ".........................................................................................................................................................................................................................................................." ] } ], "source": [ "losses = []\n", "for epoch in range(250):\n", " # Forward pass, hidden layer: A = relu(X W1 + b1), Shape: (N, H)\n", " Z = X.dot(W1.T) + b1\n", " A = np.maximum(Z, 0)\n", " \n", " # Forward pass, output layer: Y_hat = A W2 + b2, Shape: (N, D_out)\n", " Y_hat = A.dot(W2.T) + b2\n", " \n", " # Loss calculation (MSE)\n", " loss = np.mean((Y_hat - y) ** 2); losses.append(loss) # (N, D_out)\n", " \n", " # Backward pass: Output layer\n", " d_Y_hat = (1./N) * (Y_hat - y) # (N, D_out)\n", " d_W2 = d_Y_hat.T.dot(A) # (D_out, H)\n", " d_A = d_Y_hat.dot(W2) # (N, H)\n", " d_b2 = np.sum(d_Y_hat, axis=0) # (D_out,)\n", " \n", " # Backward pass: Hidden layer\n", " d_Z = d_A * np.array(Z > 0, dtype=float) # (N, H)\n", " d_W1 = d_Z.T.dot(X) # (H, D_in)\n", " d_b1 = np.sum(d_Z, axis=0) # (H,)\n", " \n", " # Backward pass: Regularization term\n", " d_W2 += reg_lambda * W2\n", " d_W1 += reg_lambda * W1\n", " \n", " # Gradient descent step\n", " W2 -= d_W2 * learning_rate; b2 -= d_b2 * learning_rate\n", " W1 -= d_W1 * learning_rate; b1 -= d_b1 * learning_rate\n", " print('.', end='')" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:50.929259Z", "iopub.status.busy": "2021-05-06T06:05:50.928652Z", "iopub.status.idle": "2021-05-06T06:05:51.053249Z", "shell.execute_reply": "2021-05-06T06:05:51.053843Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot losses\n", "_, ax = plt.subplots(figsize=(10,5))\n", "ax.plot(losses)\n", "ax.set_ylabel('MSE loss'); ax.set_xlabel('Epoch');" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Note that this implementation is not ideal, as it's:" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "- Non modular (hard to switch components)\n", "- Hard to extend (e.g. to add layers)\n", "- Error prone (hard-coded manual calculations)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "But it works!\n", "- In HW2, you'll implement a from scratch MLP that addresses these concerns.\n", "- And now, we'll see how to address these issues using PyTorch's API." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Part 2: N-Layer MLP using PyTorch" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Let's create all our usual components:\n", "- Dataset\n", "- Model\n", "- Loss function\n", "- Optimizer\n", "\n", "But this time we'll create a modular implementation where each of these components is separate and can be changed independently of the others." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Dataset" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "As in the previous tutorial we'll tackle an image classification task, the MNIST database of handwritten digits." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.057759Z", "iopub.status.busy": "2021-05-06T06:05:51.057036Z", "iopub.status.idle": "2021-05-06T06:05:51.122188Z", "shell.execute_reply": "2021-05-06T06:05:51.122511Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "import torch\n", "import torch.utils.data\n", "import torchvision\n", "import torchvision.transforms\n", "\n", "root_dir = os.path.expanduser('~/.pytorch-datasets/')" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.128526Z", "iopub.status.busy": "2021-05-06T06:05:51.128053Z", "iopub.status.idle": "2021-05-06T06:05:51.184958Z", "shell.execute_reply": "2021-05-06T06:05:51.185529Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x0: torch.Size([1, 28, 28]), y0: 5\n" ] } ], "source": [ "tf_ds = torchvision.transforms.ToTensor()\n", "\n", "batch_size = 512\n", "train_size = batch_size * 10\n", "test_size = batch_size * 2\n", "\n", "# Datasets and loaders\n", "ds_train = torchvision.datasets.MNIST(root=root_dir, download=True, train=True, transform=tf_ds)\n", "dl_train = torch.utils.data.DataLoader(ds_train, batch_size,\n", " sampler=torch.utils.data.SubsetRandomSampler(range(0,train_size)))\n", "ds_test = torchvision.datasets.MNIST(root=root_dir, download=True, train=False, transform=tf_ds)\n", "dl_test = torch.utils.data.DataLoader(ds_test, batch_size,\n", " sampler=torch.utils.data.SubsetRandomSampler(range(0,test_size)))\n", "\n", "x0, y0 = ds_train[0]\n", "n_features = torch.numel(x0)\n", "n_classes = 10\n", "\n", "print(f'x0: {x0.shape}, y0: {y0}')" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.188929Z", "iopub.status.busy": "2021-05-06T06:05:51.188421Z", "iopub.status.idle": "2021-05-06T06:05:51.488462Z", "shell.execute_reply": "2021-05-06T06:05:51.488953Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x0: torch.Size([1, 28, 28]), y0: 5\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import sys\n", "sys.path.append('.')\n", "import plot_utils as plot_utils\n", "# Show first few samples\n", "print(f'x0: {x0.shape}, y0: {y0}')\n", "plot_utils.dataset_first_n(ds_train, 10, cmap='gray', show_classes=True);" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Model Implementation" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "- The `torch.nn` module contains building blocks such as neural network layers,\n", " loss functions, activations and more.\n", "- In this section, we'll see various parts of the `torch.nn` API.\n", "- We'll use `nn.Linear` which implements a single MLP layer.\n", "- We'll implement our model as a subclass of `nn.Module`, which means:\n", " - Any tensors we set as properties will be registered as model parameters.\n", " - We can nest `nn.Modules` and get all model parameters from the top-level `nn.Module`.\n", " - Can be used as a function if we implement the `forward()` method." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "To understand `nn.Module`, lets look at a very basic one: the **fully-connected** layer." ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.492641Z", "iopub.status.busy": "2021-05-06T06:05:51.492155Z", "iopub.status.idle": "2021-05-06T06:05:51.520279Z", "shell.execute_reply": "2021-05-06T06:05:51.520839Z" }, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "tensor([[-0.5117, 1.4815, -0.3080, 0.2384, 0.6938]],\n", " grad_fn=)" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import torch.nn as nn\n", "\n", "fc = nn.Linear(in_features=3, out_features=5, bias=True)\n", "\n", "# Input tensor with 10 samples of 3 features\n", "t = torch.randn(1, 3)\n", "\n", "# Forward pass, notice that grad_fn exists\n", "fc(t)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "`nn.Modules` have registered **parameters**, which are tensors which `require_grad`." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.523614Z", "iopub.status.busy": "2021-05-06T06:05:51.523140Z", "iopub.status.idle": "2021-05-06T06:05:51.550562Z", "shell.execute_reply": "2021-05-06T06:05:51.551115Z" }, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Parameter #0 of shape torch.Size([5, 3]):\n", "tensor([[-0.0539, 0.0425, 0.3778],\n", " [-0.4717, 0.1436, -0.4493],\n", " [ 0.2278, -0.2985, -0.2353],\n", " [ 0.0305, -0.1864, -0.5171],\n", " [-0.1947, -0.1781, -0.3550]])\n", "\n", "Parameter #1 of shape torch.Size([5]):\n", "tensor([-0.2540, 0.5406, -0.1456, -0.0992, 0.2658])\n", "\n" ] } ], "source": [ "# Note parameter shapes\n", "for i, param in enumerate(fc.parameters()):\n", " print(f\"Parameter #{i} of shape {param.shape}:\\n{param.data}\\n\")" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "We can create custom `nn.Module`s with arbitrary logic. \n", "\n", "Let's recreate a fully-connected layer ourselves:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.555214Z", "iopub.status.busy": "2021-05-06T06:05:51.554725Z", "iopub.status.idle": "2021-05-06T06:05:51.581317Z", "shell.execute_reply": "2021-05-06T06:05:51.581882Z" }, "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "class MyFullyConnectedLayer(nn.Module):\n", " \n", " def __init__(self, in_features, out_features):\n", " super().__init__() # don't forget this!\n", " \n", " # nn.Parameter just marks W,b for inclusion in list of parameters\n", " self.W = nn.Parameter(torch.randn(out_features, in_features, requires_grad=False))\n", " self.b = nn.Parameter(torch.randn(out_features, requires_grad=True))\n", " \n", " def forward(self, x):\n", " # x assumed to be (N, in_features)\n", " z = torch.matmul(x, self.W.transpose(0, 1)) + self.b\n", " \n", " # Our custom FC layer multiplies all outputs by 3 for no good reason\n", " return 3 * z\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.584813Z", "iopub.status.busy": "2021-05-06T06:05:51.584336Z", "iopub.status.idle": "2021-05-06T06:05:51.610648Z", "shell.execute_reply": "2021-05-06T06:05:51.611204Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "myfc = MyFullyConnectedLayer(in_features=3, out_features=5)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.614053Z", "iopub.status.busy": "2021-05-06T06:05:51.613580Z", "iopub.status.idle": "2021-05-06T06:05:51.641014Z", "shell.execute_reply": "2021-05-06T06:05:51.641566Z" }, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "tensor([[-3.8027, 0.4861, 1.4844, 2.2856, 5.4585]], grad_fn=)" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "myfc(t)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.644410Z", "iopub.status.busy": "2021-05-06T06:05:51.643920Z", "iopub.status.idle": "2021-05-06T06:05:51.671299Z", "shell.execute_reply": "2021-05-06T06:05:51.671807Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "data": { "text/plain": [ "[Parameter containing:\n", " tensor([[ 0.6184, -1.3998, -0.3757],\n", " [ 0.8692, 0.6723, 0.7671],\n", " [-0.5638, -1.0807, -0.6356],\n", " [-0.7414, -0.9982, 0.6884],\n", " [-0.1062, 1.3147, -0.4994]], requires_grad=True),\n", " Parameter containing:\n", " tensor([-0.3234, 1.4104, -0.1391, 1.0728, 0.6665], requires_grad=True)]" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(myfc.parameters())" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Quick visualization of our custom module's **computation graph**:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.674956Z", "iopub.status.busy": "2021-05-06T06:05:51.674474Z", "iopub.status.idle": "2021-05-06T06:05:51.793273Z", "shell.execute_reply": "2021-05-06T06:05:51.793925Z" }, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "11249740992\n", "\n", " (1, 5)\n", "\n", "\n", "\n", "11377792528\n", "\n", "MulBackward0\n", "\n", "\n", "\n", "11377792528->11249740992\n", "\n", "\n", "\n", "\n", "\n", "11377792624\n", "\n", "AddBackward0\n", "\n", "\n", "\n", "11377792624->11377792528\n", "\n", "\n", "\n", "\n", "\n", "11377792336\n", "\n", "MmBackward0\n", "\n", "\n", "\n", "11377792336->11377792624\n", "\n", "\n", "\n", "\n", "\n", "11377792720\n", "\n", "TransposeBackward0\n", "\n", "\n", "\n", "11377792720->11377792336\n", "\n", "\n", "\n", "\n", "\n", "11377792816\n", "\n", "AccumulateGrad\n", "\n", "\n", "\n", "11377792816->11377792720\n", "\n", "\n", "\n", "\n", "\n", "11373582112\n", "\n", "W\n", " (5, 3)\n", "\n", "\n", "\n", "11373582112->11377792816\n", "\n", "\n", "\n", "\n", "\n", "11377792384\n", "\n", "AccumulateGrad\n", "\n", "\n", "\n", "11377792384->11377792624\n", "\n", "\n", "\n", "\n", "\n", "11373582672\n", "\n", "b\n", " (5)\n", "\n", "\n", "\n", "11373582672->11377792384\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import torchviz\n", "torchviz.make_dot(myfc(t), params=dict(W=myfc.W, b=myfc.b))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Now that we know about `nn.Module`s, lets create an fairly-general MLP for multiclass classification." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.801400Z", "iopub.status.busy": "2021-05-06T06:05:51.800819Z", "iopub.status.idle": "2021-05-06T06:05:51.833955Z", "shell.execute_reply": "2021-05-06T06:05:51.834336Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "class MLP(torch.nn.Module):\n", " NLS = {'relu': torch.nn.ReLU, 'tanh': nn.Tanh, 'sigmoid': nn.Sigmoid, 'softmax': nn.Softmax, 'logsoftmax': nn.LogSoftmax}\n", "\n", " def __init__(self, D_in: int, hidden_dims: Sequence[int], D_out: int, nonlin='relu'):\n", " super().__init__()\n", " \n", " all_dims = [D_in, *hidden_dims, D_out]\n", " non_linearity = MLP.NLS[nonlin]\n", " layers = []\n", " \n", " for in_dim, out_dim in zip(all_dims[:-1], all_dims[1:]):\n", " layers += [\n", " nn.Linear(in_dim, out_dim, bias=True),\n", " non_linearity()\n", " ]\n", " \n", " # Sequential is a container for layers\n", " self.fc_layers = nn.Sequential(*layers[:-1])\n", " \n", " # Output non-linearity\n", " self.log_softmax = nn.LogSoftmax(dim=1)\n", "\n", " def forward(self, x):\n", " x = torch.reshape(x, (x.shape[0], -1))\n", " z = self.fc_layers(x)\n", " y_pred = self.log_softmax(z)\n", " # Output is always log-probability\n", " return y_pred" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.837660Z", "iopub.status.busy": "2021-05-06T06:05:51.837141Z", "iopub.status.idle": "2021-05-06T06:05:51.864715Z", "shell.execute_reply": "2021-05-06T06:05:51.865228Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MLP(\n", " (fc_layers): Sequential(\n", " (0): Linear(in_features=784, out_features=32, bias=True)\n", " (1): Tanh()\n", " (2): Linear(in_features=32, out_features=64, bias=True)\n", " (3): Tanh()\n", " (4): Linear(in_features=64, out_features=128, bias=True)\n", " (5): Tanh()\n", " (6): Linear(in_features=128, out_features=64, bias=True)\n", " (7): Tanh()\n", " (8): Linear(in_features=64, out_features=10, bias=True)\n", " )\n", " (log_softmax): LogSoftmax(dim=1)\n", ")\n" ] } ], "source": [ "# Create an instance of the model: 5-layer MLP\n", "mlp5 = MLP(D_in=n_features, hidden_dims=[32, 64, 128, 64], D_out=n_classes, nonlin='tanh')\n", "\n", "print(mlp5)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.868232Z", "iopub.status.busy": "2021-05-06T06:05:51.867753Z", "iopub.status.idle": "2021-05-06T06:05:51.895960Z", "shell.execute_reply": "2021-05-06T06:05:51.896670Z" }, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "number of parameter tensors: 10\n" ] } ], "source": [ "# Parameter tensors in nested nn.Modules are automatically discovered.\n", "print(f'number of parameter tensors: {len(list(mlp5.parameters()))}')" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.900699Z", "iopub.status.busy": "2021-05-06T06:05:51.900139Z", "iopub.status.idle": "2021-05-06T06:05:51.928199Z", "shell.execute_reply": "2021-05-06T06:05:51.928711Z" }, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "number of parameters: 44458\n" ] } ], "source": [ "print(f'number of parameters: {np.sum([torch.numel(p) for p in mlp5.parameters()])}')" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.932129Z", "iopub.status.busy": "2021-05-06T06:05:51.931582Z", "iopub.status.idle": "2021-05-06T06:05:51.961558Z", "shell.execute_reply": "2021-05-06T06:05:51.962101Z" }, "scrolled": false, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x0.shape=torch.Size([1, 28, 28])\n", "\n", "y_hat0.shape=torch.Size([1, 10])\n", "\n", "y_hat0=tensor([[-2.2258, -2.3713, -2.4023, -2.2198, -2.3206, -2.2607, -2.3160, -2.3575,\n", " -2.3782, -2.1983]], grad_fn=)\n" ] } ], "source": [ "# Test a forward pass\n", "y_hat0 = mlp5(x0)\n", "\n", "print(f'{x0.shape=}\\n')\n", "print(f'{y_hat0.shape=}\\n')\n", "print(f'{y_hat0=}')" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Quick visualization of our full MLP's **computation graph**:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:51.965171Z", "iopub.status.busy": "2021-05-06T06:05:51.964693Z", "iopub.status.idle": "2021-05-06T06:05:52.025504Z", "shell.execute_reply": "2021-05-06T06:05:52.026023Z" }, "scrolled": false, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "11377955600\n", "\n", " (1, 10)\n", "\n", "\n", "\n", "11377793536\n", "\n", "LogSoftmaxBackward0\n", "\n", "\n", "\n", "11377793536->11377955600\n", "\n", "\n", "\n", "\n", "\n", "11377792384\n", "\n", "AddmmBackward0\n", "\n", "\n", "\n", "11377792384->11377793536\n", "\n", "\n", "\n", "\n", "\n", "11377794256\n", "\n", "AccumulateGrad\n", "\n", "\n", "\n", "11377794256->11377792384\n", "\n", "\n", "\n", "\n", "\n", "11377957520\n", "\n", "fc_layers.8.bias\n", " (10)\n", "\n", "\n", "\n", "11377957520->11377794256\n", "\n", "\n", "\n", "\n", "\n", "11373551040\n", "\n", "TanhBackward0\n", "\n", "\n", "\n", "11373551040->11377792384\n", "\n", "\n", "\n", "\n", "\n", "11373551088\n", "\n", "AddmmBackward0\n", "\n", "\n", "\n", "11373551088->11373551040\n", "\n", "\n", "\n", "\n", "\n", "11373550416\n", "\n", "AccumulateGrad\n", "\n", "\n", "\n", "11373550416->11373551088\n", "\n", "\n", "\n", "\n", "\n", "11377956880\n", "\n", "fc_layers.6.bias\n", " (64)\n", "\n", "\n", "\n", "11377956880->11373550416\n", "\n", "\n", "\n", "\n", "\n", "11377948656\n", "\n", "TanhBackward0\n", "\n", "\n", "\n", "11377948656->11373551088\n", "\n", "\n", "\n", "\n", "\n", "11377946736\n", "\n", "AddmmBackward0\n", "\n", "\n", "\n", "11377946736->11377948656\n", "\n", "\n", "\n", "\n", "\n", "11377948176\n", "\n", "AccumulateGrad\n", "\n", "\n", "\n", "11377948176->11377946736\n", "\n", "\n", "\n", "\n", "\n", "11377955680\n", "\n", "fc_layers.4.bias\n", " (128)\n", "\n", "\n", "\n", "11377955680->11377948176\n", "\n", "\n", "\n", "\n", "\n", "11377947024\n", "\n", "TanhBackward0\n", "\n", "\n", "\n", "11377947024->11377946736\n", "\n", "\n", "\n", "\n", "\n", "11377949376\n", "\n", "AddmmBackward0\n", "\n", "\n", "\n", "11377949376->11377947024\n", "\n", "\n", "\n", "\n", "\n", "11377949280\n", "\n", "AccumulateGrad\n", "\n", "\n", "\n", "11377949280->11377949376\n", "\n", "\n", "\n", "\n", "\n", "11377955920\n", "\n", "fc_layers.2.bias\n", " (64)\n", "\n", "\n", "\n", "11377955920->11377949280\n", "\n", "\n", "\n", "\n", "\n", "11377949424\n", "\n", "TanhBackward0\n", "\n", "\n", "\n", "11377949424->11377949376\n", "\n", "\n", "\n", "\n", "\n", "11377948416\n", "\n", "AddmmBackward0\n", "\n", "\n", "\n", "11377948416->11377949424\n", "\n", "\n", "\n", "\n", "\n", "11377947408\n", "\n", "AccumulateGrad\n", "\n", "\n", "\n", "11377947408->11377948416\n", "\n", "\n", "\n", "\n", "\n", "11377473712\n", "\n", "fc_layers.0.bias\n", " (32)\n", "\n", "\n", "\n", "11377473712->11377947408\n", "\n", "\n", "\n", "\n", "\n", "11377948944\n", "\n", "TBackward0\n", "\n", "\n", "\n", "11377948944->11377948416\n", "\n", "\n", "\n", "\n", "\n", "11377948128\n", "\n", "AccumulateGrad\n", "\n", "\n", "\n", "11377948128->11377948944\n", "\n", "\n", "\n", "\n", "\n", "11377954880\n", "\n", "fc_layers.0.weight\n", " (32, 784)\n", "\n", "\n", "\n", "11377954880->11377948128\n", "\n", "\n", "\n", "\n", "\n", "11377949472\n", "\n", "TBackward0\n", "\n", "\n", "\n", "11377949472->11377949376\n", "\n", "\n", "\n", "\n", "\n", "11377947264\n", "\n", "AccumulateGrad\n", "\n", "\n", "\n", "11377947264->11377949472\n", "\n", "\n", "\n", "\n", "\n", "11377956000\n", "\n", "fc_layers.2.weight\n", " (64, 32)\n", "\n", "\n", "\n", "11377956000->11377947264\n", "\n", "\n", "\n", "\n", "\n", "11377949136\n", "\n", "TBackward0\n", "\n", "\n", "\n", "11377949136->11377946736\n", "\n", "\n", "\n", "\n", "\n", "11377949712\n", "\n", "AccumulateGrad\n", "\n", "\n", "\n", "11377949712->11377949136\n", "\n", "\n", "\n", "\n", "\n", "11377955760\n", "\n", "fc_layers.4.weight\n", " (128, 64)\n", "\n", "\n", "\n", "11377955760->11377949712\n", "\n", "\n", "\n", "\n", "\n", "11377949088\n", "\n", "TBackward0\n", "\n", "\n", "\n", "11377949088->11373551088\n", "\n", "\n", "\n", "\n", "\n", "11377949520\n", "\n", "AccumulateGrad\n", "\n", "\n", "\n", "11377949520->11377949088\n", "\n", "\n", "\n", "\n", "\n", "11377956640\n", "\n", "fc_layers.6.weight\n", " (64, 128)\n", "\n", "\n", "\n", "11377956640->11377949520\n", "\n", "\n", "\n", "\n", "\n", "11373548880\n", "\n", "TBackward0\n", "\n", "\n", "\n", "11373548880->11377792384\n", "\n", "\n", "\n", "\n", "\n", "11373550512\n", "\n", "AccumulateGrad\n", "\n", "\n", "\n", "11373550512->11373548880\n", "\n", "\n", "\n", "\n", "\n", "11377956960\n", "\n", "fc_layers.8.weight\n", " (10, 64)\n", "\n", "\n", "\n", "11377956960->11373550512\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "torchviz.make_dot(mlp5(x0), params=dict(mlp5.named_parameters()))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Loss and Optimizer" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "For the loss function, we'll use PyTorch's built in negative log-likelihood loss since our model outputs probabilities." ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:52.029870Z", "iopub.status.busy": "2021-05-06T06:05:52.029381Z", "iopub.status.idle": "2021-05-06T06:05:52.059506Z", "shell.execute_reply": "2021-05-06T06:05:52.060056Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "data": { "text/plain": [ "tensor(2.3782, grad_fn=)" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import torch.optim\n", "\n", "# Loss:\n", "# Note: NLLLoss assumes *log*-probabilities (given by our LogSoftmax layer)\n", "loss_fn = nn.NLLLoss()\n", "\n", "# Fake ground-truth labels\n", "# Notice that we don't need to 1-hot encode them!\n", "yt = torch.randint(low=0, high=n_classes, size=(y_hat0.shape[0],))\n", "\n", "# Try out the loss\n", "loss_fn(y_hat0, yt) " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Note that `nn.NLLLoss(y_hat, y)` assumes that $\\hat{\\vec{y}}^{(i)}=\\log\\left(\\mathrm{softmax}\\left(\\vec{z}^{(i)}\\right)\\right)$, where $\\vec{z}^{(i)}\\in\\set{R}^C$ contains the raw scores for input $\\vec{x}^{(i)}$, and therefore it simply computes:\n", "\n", "$$\n", "L_{\\mathrm{NLL}}\n", "= \\sum_{i=1}^{N} -\\left[\\hat{\\vec{y}}^{(i)}\\right]_{y^{(i)}}\n", "= \\sum_{i=1}^{N} -\\left[ \\log\\left(\\mathrm{softmax}\\left(\\vec{z}^{(i)}\\right)\\right) \\right]_{y^{(i)}}\n", "$$\n", "\n", "where $y^{(i)}\\in\\left\\{0,1,\\dots,C-1\\right\\}$ is the ground-truth class label of for sample $i$." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "As for the optimization scheme, we'll use a built in SGD optimizer from the `torch.optim` module.\n", "We will see that the semantics of using it are similar to the simple optimizer we implemented last tutorial.\n", "\n", "We won't need to calculate the loss gradient this time, as we'll use `autograd` for automatic differentiation." ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:52.063675Z", "iopub.status.busy": "2021-05-06T06:05:52.063193Z", "iopub.status.idle": "2021-05-06T06:05:52.097596Z", "shell.execute_reply": "2021-05-06T06:05:52.096943Z" }, "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "torch.manual_seed(42)\n", "\n", "# Model for training\n", "model = MLP(D_in=n_features, hidden_dims=[32, 32, 32], D_out=n_classes, nonlin='relu')\n", "\n", "# Optimizer over our model's parameters\n", "optimizer = torch.optim.SGD(params=model.parameters(), lr=5e-2, weight_decay=0.01, momentum=0.9)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Training loop" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "This time we'll train over lazy-loaded batches from our data loader.\n", "\n", "Notice that except from our model's `__init__()` and `__forward()__`, we're using PyTorch facilities for the entire training implementation." ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "execution": { "iopub.execute_input": "2021-05-06T06:05:52.102057Z", "iopub.status.busy": "2021-05-06T06:05:52.101567Z", "iopub.status.idle": "2021-05-06T06:05:56.017546Z", "shell.execute_reply": "2021-05-06T06:05:56.018062Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch #1: Avg. loss=2.305134725570679\n", "Epoch #2: Avg. loss=2.286450743675232\n", "Epoch #3: Avg. loss=2.256749749183655\n", "Epoch #4: Avg. loss=2.176987957954407\n", "Epoch #5: Avg. loss=1.9311090946197509\n", "Epoch #6: Avg. loss=1.4161057472229004\n", "Epoch #7: Avg. loss=0.9191414415836334\n", "Epoch #8: Avg. loss=0.6763368904590606\n", "Epoch #9: Avg. loss=0.5613920748233795\n", "Epoch #10: Avg. loss=0.5014606505632401\n" ] } ], "source": [ "num_epochs = 10\n", "for epoch_idx in range(num_epochs):\n", " total_loss = 0\n", " \n", " for batch_idx, (X, y) in enumerate(dl_train):\n", " # Forward pass\n", " y_pred = model(X)\n", "\n", " # Compute loss\n", " loss = loss_fn(y_pred, y)\n", " total_loss += loss.item()\n", "\n", " # Backward pass\n", " optimizer.zero_grad() # Zero gradients of all parameters\n", " loss.backward() # Run backprop algorithms to calculate gradients\n", " \n", " # Optimization step\n", " optimizer.step() # Use gradients to update model parameters\n", " \n", " print(f'Epoch #{epoch_idx+1}: Avg. loss={total_loss/len(dl_train)}')" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Using the basic PyTorch building blocks we have arrived at a much more robust implementation:\n", "- Easy to change architecture: layers and activation functions\n", "- Easy to change loss\n", "- Easy to change optimization method\n", "- No need for manual gradient derivations" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "#### Thanks!" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "skip" } }, "source": [ "**Credits**\n", "\n", "This tutorial was written by [Aviv A. Rosenberg](https://avivr.net), modified by [Moshe Kimhi](https://mkimhi.github.io/).
\n", "To re-use, please provide attribution and link to the original.\n", "\n", "Some images in this tutorial were taken and/or adapted from the following sources:\n", "\n", "- MartinThoma [CC0], via Wikimedia Commons https://commons.wikimedia.org/wiki/File:Perceptron-unit.svg\n", "- Pattern Recognition and Machine Learning, C. M. Bishop, Springer, 2006\n", "- Sebastian Raschka https://sebastianraschka.com/Articles/2015_singlelayer_neurons.html\n", "- Favio Vázquez https://towardsdatascience.com/a-conversation-about-deep-learning-9a915983107\n", "- Fundamentals of Deep Learning, Nikhil Buduma, Oreilly 2017" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "celltoolbar": "Slideshow", "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.12" } }, "nbformat": 4, "nbformat_minor": 4 }