tutorial/50.cnn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Convolutional Neural Networks\n",
    "(c) Deniz Yuret, 2019\n",
    "* Objectives: See the effect of sparse and shared weights implemented by convolutional networks.\n",
    "* Prerequisites: [MLP models](40.mlp.ipynb), [MNIST](20.mnist.ipynb)\n",
    "* New functions:\n",
    "[conv4](http://denizyuret.github.io/Knet.jl/latest/reference/#Knet.conv4),\n",
    "[pool](http://denizyuret.github.io/Knet.jl/latest/reference/#Knet.pool),\n",
    "[mat](http://denizyuret.github.io/Knet.jl/latest/reference/#Knet.mat)\n",
    "\n",
    "![image](https://github.com/denizyuret/Knet.jl/blob/master/docs/src/images/le_net.png?raw=true)\n",
    "([image source](http://www.dataiku.com/blog/2015/08/18/Deep_Learning.html))\n",
    "\n",
    "To improve the performance further, we can use a convolutional neural networks (CNN). See the [course notes](http://cs231n.github.io/convolutional-networks/) by Andrej Karpathy for a good introduction to CNNs. We will implement the [LeNet](http://yann.lecun.com/exdb/lenet) model which consists of two convolutional layers followed by two fully connected layers. We will describe and use the [conv4](http://denizyuret.github.io/Knet.jl/latest/reference/#Knet.conv4) and [pool](http://denizyuret.github.io/Knet.jl/latest/reference/#Knet.pool) functions provided by Knet for the implementation of convolutional nets.\n",
    "\n",
    "Even though MLPs and CNNs are both universal function approximators and both achieve 0 error on the training set, we will see that a CNN converges a lot faster and generalizes a lot better with less overfitting achieving a 99.5% test accuracy on MNIST. The sparse connectivity and shared weights of a CNN give it an inductive bias appropriate for image features allowing it to learn better with less data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Setup display width, load packages, import symbols\n",
    "ENV[\"COLUMNS\"]=72\n",
    "using Base.Iterators: flatten\n",
    "using IterTools: ncycle, takenth\n",
    "using Statistics: mean\n",
    "using MLDatasets: MNIST\n",
    "import CUDA # functional\n",
    "import Knet # load, save\n",
    "using Knet: conv4, pool, mat, KnetArray, nll, zeroone, progress, sgd, param, param0, dropout, relu, minibatch, Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Introduction to convolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "conv4(w, x; kwargs...)\n",
       "\\end{verbatim}\n",
       "Execute convolutions or cross-correlations using filters specified with \\texttt{w} over tensor \\texttt{x}.\n",
       "\n",
       "If \\texttt{w} has dimensions \\texttt{(W1,W2,...,Cx,Cy)} and \\texttt{x} has dimensions \\texttt{(X1,X2,...,Cx,N)}, the result \\texttt{y} will have dimensions \\texttt{(Y1,Y2,...,Cy,N)} where \\texttt{Cx} is the number of input channels, \\texttt{Cy} is the number of output channels, \\texttt{N} is the number of instances, and \\texttt{Wi,Xi,Yi} are spatial dimensions with \\texttt{Yi} determined by:\n",
       "\n",
       "\\begin{verbatim}\n",
       "Yi = 1 + floor((Xi + 2*padding[i] - ((Wi-1)*dilation[i] + 1)) / stride[i])\n",
       "\\end{verbatim}\n",
       "\\texttt{padding}, \\texttt{stride} and \\texttt{dilation} are keyword arguments that can be specified as a single number (in which case they apply to all dimensions), or an array/tuple with entries for each spatial dimension.\n",
       "\n",
       "\\section{Keywords}\n",
       "\\begin{itemize}\n",
       "\\item \\texttt{padding=0}: the number of extra zeros implicitly concatenated at the start and end of each dimension.\n",
       "\n",
       "\n",
       "\\item \\texttt{stride=1}: the number of elements to slide to reach the next filtering window.\n",
       "\n",
       "\n",
       "\\item \\texttt{dilation=1}: dilation factor for each dimension.\n",
       "\n",
       "\n",
       "\\item \\texttt{mode=0}: 0 for convolution and 1 for cross-correlation (which flips the filter).\n",
       "\n",
       "\n",
       "\\item \\texttt{alpha=1}: can be used to scale the result.\n",
       "\n",
       "\n",
       "\\item \\texttt{group=1}: can be used to perform grouped convolutions.\n",
       "\n",
       "\\end{itemize}\n"
      ],
      "text/markdown": [
       "```\n",
       "conv4(w, x; kwargs...)\n",
       "```\n",
       "\n",
       "Execute convolutions or cross-correlations using filters specified with `w` over tensor `x`.\n",
       "\n",
       "If `w` has dimensions `(W1,W2,...,Cx,Cy)` and `x` has dimensions `(X1,X2,...,Cx,N)`, the result `y` will have dimensions `(Y1,Y2,...,Cy,N)` where `Cx` is the number of input channels, `Cy` is the number of output channels, `N` is the number of instances, and `Wi,Xi,Yi` are spatial dimensions with `Yi` determined by:\n",
       "\n",
       "```\n",
       "Yi = 1 + floor((Xi + 2*padding[i] - ((Wi-1)*dilation[i] + 1)) / stride[i])\n",
       "```\n",
       "\n",
       "`padding`, `stride` and `dilation` are keyword arguments that can be specified as a single number (in which case they apply to all dimensions), or an array/tuple with entries for each spatial dimension.\n",
       "\n",
       "# Keywords\n",
       "\n",
       "  * `padding=0`: the number of extra zeros implicitly concatenated at the start and end of each dimension.\n",
       "  * `stride=1`: the number of elements to slide to reach the next filtering window.\n",
       "  * `dilation=1`: dilation factor for each dimension.\n",
       "  * `mode=0`: 0 for convolution and 1 for cross-correlation (which flips the filter).\n",
       "  * `alpha=1`: can be used to scale the result.\n",
       "  * `group=1`: can be used to perform grouped convolutions.\n"
      ],
      "text/plain": [
       "\u001b[36m  conv4(w, x; kwargs...)\u001b[39m\n",
       "\n",
       "  Execute convolutions or cross-correlations using filters specified\n",
       "  with \u001b[36mw\u001b[39m over tensor \u001b[36mx\u001b[39m.\n",
       "\n",
       "  If \u001b[36mw\u001b[39m has dimensions \u001b[36m(W1,W2,...,Cx,Cy)\u001b[39m and \u001b[36mx\u001b[39m has dimensions\n",
       "  \u001b[36m(X1,X2,...,Cx,N)\u001b[39m, the result \u001b[36my\u001b[39m will have dimensions \u001b[36m(Y1,Y2,...,Cy,N)\u001b[39m\n",
       "  where \u001b[36mCx\u001b[39m is the number of input channels, \u001b[36mCy\u001b[39m is the number of output\n",
       "  channels, \u001b[36mN\u001b[39m is the number of instances, and \u001b[36mWi,Xi,Yi\u001b[39m are spatial\n",
       "  dimensions with \u001b[36mYi\u001b[39m determined by:\n",
       "\n",
       "\u001b[36m  Yi = 1 + floor((Xi + 2*padding[i] - ((Wi-1)*dilation[i] + 1)) / stride[i])\u001b[39m\n",
       "\n",
       "  \u001b[36mpadding\u001b[39m, \u001b[36mstride\u001b[39m and \u001b[36mdilation\u001b[39m are keyword arguments that can be\n",
       "  specified as a single number (in which case they apply to all\n",
       "  dimensions), or an array/tuple with entries for each spatial\n",
       "  dimension.\n",
       "\n",
       "\u001b[1m  Keywords\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "    •    \u001b[36mpadding=0\u001b[39m: the number of extra zeros implicitly\n",
       "        concatenated at the start and end of each dimension.\n",
       "\n",
       "    •    \u001b[36mstride=1\u001b[39m: the number of elements to slide to reach the\n",
       "        next filtering window.\n",
       "\n",
       "    •    \u001b[36mdilation=1\u001b[39m: dilation factor for each dimension.\n",
       "\n",
       "    •    \u001b[36mmode=0\u001b[39m: 0 for convolution and 1 for cross-correlation\n",
       "        (which flips the filter).\n",
       "\n",
       "    •    \u001b[36malpha=1\u001b[39m: can be used to scale the result.\n",
       "\n",
       "    •    \u001b[36mgroup=1\u001b[39m: can be used to perform grouped convolutions."
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convolution operator in Knet\n",
    "@doc conv4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [1.0; 2.0; 3.0]\n",
      "x = [1.0; 2.0; 3.0; 4.0; 5.0; 6.0; 7.0]\n",
      "y = conv4(w, x) = [10.0; 16.0; 22.0; 28.0; 34.0]\n"
     ]
    }
   ],
   "source": [
    "# Convolution in 1-D\n",
    "w = reshape([1.0,2.0,3.0], (3,1,1,1)); @show w\n",
    "x = reshape([1.0:7.0...], (7,1,1,1)); @show x\n",
    "@show y = conv4(w, x);  # size Y = X - W + 1 = 5 by default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [1.0; 2.0; 3.0]\n",
      "x = [1.0; 2.0; 3.0; 4.0; 5.0; 6.0; 7.0]\n",
      "y2 = conv4(w, x, padding = (1, 0)) = [4.0; 10.0; 16.0; 22.0; 28.0; 34.0; 32.0]\n"
     ]
    }
   ],
   "source": [
    "# Padding\n",
    "w = reshape([1.0,2.0,3.0], (3,1,1,1)); @show w\n",
    "x = reshape([1.0:7.0...], (7,1,1,1)); @show x\n",
    "@show y2 = conv4(w, x, padding=(1,0));  # size Y = X + 2P - W + 1 = 7 with padding=1\n",
    "# To preserve input size (Y=X) for a given W, what padding P should we use?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [1.0; 2.0; 3.0]\n",
      "x = [1.0; 2.0; 3.0; 4.0; 5.0; 6.0; 7.0]\n",
      "y3 = conv4(w, x; padding = (1, 0), stride = 3) = [4.0; 22.0; 32.0]\n"
     ]
    }
   ],
   "source": [
    "# Stride\n",
    "w = reshape([1.0,2.0,3.0], (3,1,1,1)); @show w\n",
    "x = reshape([1.0:7.0...], (7,1,1,1)); @show x\n",
    "@show y3 = conv4(w, x; padding=(1,0), stride=3);  # size Y = 1 + floor((X+2P-W)/S)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [1.0; 2.0; 3.0]\n",
      "x = [1.0; 2.0; 3.0; 4.0; 5.0; 6.0; 7.0]\n",
      "y4 = conv4(w, x, mode = 0) = [10.0; 16.0; 22.0; 28.0; 34.0]\n",
      "y5 = conv4(w, x, mode = 1) = [14.0; 20.0; 26.0; 32.0; 38.0]\n"
     ]
    }
   ],
   "source": [
    "# Mode\n",
    "w = reshape([1.0,2.0,3.0], (3,1,1,1)); @show w\n",
    "x = reshape([1.0:7.0...], (7,1,1,1)); @show x\n",
    "@show y4 = conv4(w, x, mode=0);  # Default mode (convolution) inverts w\n",
    "@show y5 = conv4(w, x, mode=1);  # mode=1 (cross-correlation) does not invert w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3×1×1 Array{Float64,4}:\n",
       "[:, :, 1, 1] =\n",
       " 1.0  4.0  7.0\n",
       " 2.0  5.0  8.0\n",
       " 3.0  6.0  9.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convolution in more dimensions\n",
    "x = reshape([1.0:9.0...], (3,3,1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2×1×1 Array{Float64,4}:\n",
       "[:, :, 1, 1] =\n",
       " 1.0  3.0\n",
       " 2.0  4.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w = reshape([1.0:4.0...], (2,2,1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2×1×1 Array{Float64,4}:\n",
       "[:, :, 1, 1] =\n",
       " 23.0  53.0\n",
       " 33.0  63.0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = conv4(w, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3×2×1 Array{Float64,4}:\n",
       "[:, :, 1, 1] =\n",
       " 1.0  4.0  7.0\n",
       " 2.0  5.0  8.0\n",
       " 3.0  6.0  9.0\n",
       "\n",
       "[:, :, 2, 1] =\n",
       " 10.0  13.0  16.0\n",
       " 11.0  14.0  17.0\n",
       " 12.0  15.0  18.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convolution with multiple channels, filters, and instances\n",
    "# size X = [X1,X2,...,Xd,Cx,N] where d is the number of dimensions, Cx is channels, N is instances\n",
    "x = reshape([1.0:18.0...], (3,3,2,1)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# size W = [W1,W2,...,Wd,Cx,Cy] where d is the number of dimensions, Cx is input channels, Cy is output channels\n",
    "w = reshape([1.0:24.0...], (2,2,2,3));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2×3×1 Array{Float64,4}:\n",
       "[:, :, 1, 1] =\n",
       " 328.0  436.0\n",
       " 364.0  472.0\n",
       "\n",
       "[:, :, 2, 1] =\n",
       " 808.0  1108.0\n",
       " 908.0  1208.0\n",
       "\n",
       "[:, :, 3, 1] =\n",
       " 1288.0  1780.0\n",
       " 1452.0  1944.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# size Y = [Y1,Y2,...,Yd,Cy,N]  where Yi = 1 + floor((Xi+2Pi-Wi)/Si), Cy is channels, N is instances\n",
    "y = conv4(w,x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "See http://cs231n.github.io/assets/conv-demo/index.html for an animated example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Introduction to Pooling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "pool(x; kwargs...)\n",
       "\\end{verbatim}\n",
       "Compute pooling of input values (i.e., the maximum or average of several adjacent values) to produce an output with smaller height and/or width.\n",
       "\n",
       "If \\texttt{x} has dimensions \\texttt{(X1,X2,...,Cx,N)}, the result \\texttt{y} will have dimensions \\texttt{(Y1,Y2,...,Cx,N)} where\n",
       "\n",
       "\\begin{verbatim}\n",
       "Yi=1+floor((Xi+2*padding[i]-window[i])/stride[i])\n",
       "\\end{verbatim}\n",
       "Here \\texttt{Cx} is the number of input channels, \\texttt{N} is the number of instances, and \\texttt{Xi,Yi} are spatial dimensions.  \\texttt{window}, \\texttt{padding} and \\texttt{stride} are keyword arguments that can be specified as a single number (in which case they apply to all dimensions), or an array/tuple with entries for each spatial dimension.\n",
       "\n",
       "\\section{Keywords:}\n",
       "\\begin{itemize}\n",
       "\\item \\texttt{window=2}: the pooling window size for each dimension.\n",
       "\n",
       "\n",
       "\\item \\texttt{padding=0}: the number of extra zeros implicitly concatenated at the start and at the end of each dimension.\n",
       "\n",
       "\n",
       "\\item \\texttt{stride=window}: the number of elements to slide to reach the next pooling window.\n",
       "\n",
       "\n",
       "\\item \\texttt{mode=0}: 0 for max, 1 for average including padded values, 2 for average excluding padded values, 3 for deterministic max.\n",
       "\n",
       "\n",
       "\\item \\texttt{maxpoolingNanOpt=1}: Nan numbers are not propagated if 0, they are propagated if 1.\n",
       "\n",
       "\n",
       "\\item \\texttt{alpha=1}: can be used to scale the result.\n",
       "\n",
       "\\end{itemize}\n"
      ],
      "text/markdown": [
       "```\n",
       "pool(x; kwargs...)\n",
       "```\n",
       "\n",
       "Compute pooling of input values (i.e., the maximum or average of several adjacent values) to produce an output with smaller height and/or width.\n",
       "\n",
       "If `x` has dimensions `(X1,X2,...,Cx,N)`, the result `y` will have dimensions `(Y1,Y2,...,Cx,N)` where\n",
       "\n",
       "```\n",
       "Yi=1+floor((Xi+2*padding[i]-window[i])/stride[i])\n",
       "```\n",
       "\n",
       "Here `Cx` is the number of input channels, `N` is the number of instances, and `Xi,Yi` are spatial dimensions.  `window`, `padding` and `stride` are keyword arguments that can be specified as a single number (in which case they apply to all dimensions), or an array/tuple with entries for each spatial dimension.\n",
       "\n",
       "# Keywords:\n",
       "\n",
       "  * `window=2`: the pooling window size for each dimension.\n",
       "  * `padding=0`: the number of extra zeros implicitly concatenated at the start and at the end of each dimension.\n",
       "  * `stride=window`: the number of elements to slide to reach the next pooling window.\n",
       "  * `mode=0`: 0 for max, 1 for average including padded values, 2 for average excluding padded values, 3 for deterministic max.\n",
       "  * `maxpoolingNanOpt=1`: Nan numbers are not propagated if 0, they are propagated if 1.\n",
       "  * `alpha=1`: can be used to scale the result.\n"
      ],
      "text/plain": [
       "\u001b[36m  pool(x; kwargs...)\u001b[39m\n",
       "\n",
       "  Compute pooling of input values (i.e., the maximum or average of\n",
       "  several adjacent values) to produce an output with smaller height\n",
       "  and/or width.\n",
       "\n",
       "  If \u001b[36mx\u001b[39m has dimensions \u001b[36m(X1,X2,...,Cx,N)\u001b[39m, the result \u001b[36my\u001b[39m will have\n",
       "  dimensions \u001b[36m(Y1,Y2,...,Cx,N)\u001b[39m where\n",
       "\n",
       "\u001b[36m  Yi=1+floor((Xi+2*padding[i]-window[i])/stride[i])\u001b[39m\n",
       "\n",
       "  Here \u001b[36mCx\u001b[39m is the number of input channels, \u001b[36mN\u001b[39m is the number of\n",
       "  instances, and \u001b[36mXi,Yi\u001b[39m are spatial dimensions. \u001b[36mwindow\u001b[39m, \u001b[36mpadding\u001b[39m and\n",
       "  \u001b[36mstride\u001b[39m are keyword arguments that can be specified as a single\n",
       "  number (in which case they apply to all dimensions), or an\n",
       "  array/tuple with entries for each spatial dimension.\n",
       "\n",
       "\u001b[1m  Keywords:\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "    •    \u001b[36mwindow=2\u001b[39m: the pooling window size for each dimension.\n",
       "\n",
       "    •    \u001b[36mpadding=0\u001b[39m: the number of extra zeros implicitly\n",
       "        concatenated at the start and at the end of each\n",
       "        dimension.\n",
       "\n",
       "    •    \u001b[36mstride=window\u001b[39m: the number of elements to slide to reach\n",
       "        the next pooling window.\n",
       "\n",
       "    •    \u001b[36mmode=0\u001b[39m: 0 for max, 1 for average including padded values,\n",
       "        2 for average excluding padded values, 3 for deterministic\n",
       "        max.\n",
       "\n",
       "    •    \u001b[36mmaxpoolingNanOpt=1\u001b[39m: Nan numbers are not propagated if 0,\n",
       "        they are propagated if 1.\n",
       "\n",
       "    •    \u001b[36malpha=1\u001b[39m: can be used to scale the result."
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pooling operator in Knet\n",
    "@doc pool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = [1.0; 2.0; 3.0; 4.0; 5.0; 6.0]\n",
      "pool(x; window = (2, 1)) = [2.0; 4.0; 6.0]\n"
     ]
    }
   ],
   "source": [
    "# 1-D pooling example\n",
    "x = reshape([1.0:6.0...], (6,1,1,1)); @show x\n",
    "@show pool(x; window=(2,1));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = [1.0; 2.0; 3.0; 4.0; 5.0; 6.0]\n",
      "pool(x; window = (3, 1)) = [3.0; 6.0]\n"
     ]
    }
   ],
   "source": [
    "# Window size\n",
    "x = reshape([1.0:6.0...], (6,1,1,1)); @show x\n",
    "@show pool(x; window=(3,1));  # size Y = floor(X/W)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = [1.0; 2.0; 3.0; 4.0; 5.0; 6.0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "┌ Warning: Pool padding is buggy in NNlib, use with caution. See https://github.com/FluxML/NNlib.jl/issues/229\n",
      "└ @ Knet.Ops20 /home/deniz/.julia/dev/Knet/src/ops20/conv.jl:183\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pool(x; window = (2, 1), padding = (1, 0)) = [1.0; 3.0; 5.0; 6.0]\n"
     ]
    }
   ],
   "source": [
    "# Padding\n",
    "x = reshape([1.0:6.0...], (6,1,1,1)); @show x\n",
    "@show pool(x; window=(2,1), padding=(1,0));  # size Y = floor((X+2P)/W)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = [1.0; 2.0; 3.0; 4.0; 5.0; 6.0; 7.0; 8.0; 9.0; 10.0]\n",
      "pool(x; window = (2, 1), stride = 4) = [2.0; 6.0; 10.0]\n"
     ]
    }
   ],
   "source": [
    "# Stride\n",
    "x = reshape([1.0:10.0...], (10,1,1,1)); @show x\n",
    "@show pool(x; window=(2,1), stride=4);  # size Y = 1 + floor((X+2P-W)/S)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = K64(6,1,1,1)[1.0⋯]\n",
      "pool(x; padding = (1, 0), mode = 0) = K64(4,1,1,1)[1.0⋯]\n",
      "pool(x; padding = (1, 0), mode = 1) = K64(4,1,1,1)[0.5⋯]\n",
      "pool(x; padding = (1, 0), mode = 2) = K64(4,1,1,1)[1.0⋯]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×1×1×1 KnetArray{Float64,4}:\n",
       "[:, :, 1, 1] =\n",
       " 1.0\n",
       " 2.5\n",
       " 4.5\n",
       " 6.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Mode (using KnetArray here; not all modes are implemented on the CPU)\n",
    "if CUDA.functional()\n",
    "    x = KnetArray(reshape([1.0:6.0...], (6,1,1,1))); @show x\n",
    "    @show pool(x; padding=(1,0), mode=0)  # max pooling\n",
    "    @show pool(x; padding=(1,0), mode=1)  # avg pooling\n",
    "    @show pool(x; padding=(1,0), mode=2); # avg pooling excluding padded values (is not implemented on CPU)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×4×1×1 Array{Float64,4}:\n",
       "[:, :, 1, 1] =\n",
       " 1.0  5.0   9.0  13.0\n",
       " 2.0  6.0  10.0  14.0\n",
       " 3.0  7.0  11.0  15.0\n",
       " 4.0  8.0  12.0  16.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# More dimensions\n",
    "x = reshape([1.0:16.0...], (4,4,1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2×1×1 Array{Float64,4}:\n",
       "[:, :, 1, 1] =\n",
       " 6.0  14.0\n",
       " 8.0  16.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pool(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×4×2×1 Array{Float64,4}:\n",
       "[:, :, 1, 1] =\n",
       " 1.0  5.0   9.0  13.0\n",
       " 2.0  6.0  10.0  14.0\n",
       " 3.0  7.0  11.0  15.0\n",
       " 4.0  8.0  12.0  16.0\n",
       "\n",
       "[:, :, 2, 1] =\n",
       " 17.0  21.0  25.0  29.0\n",
       " 18.0  22.0  26.0  30.0\n",
       " 19.0  23.0  27.0  31.0\n",
       " 20.0  24.0  28.0  32.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiple channels and instances\n",
    "x = reshape([1.0:32.0...], (4,4,2,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2×2×1 Array{Float64,4}:\n",
       "[:, :, 1, 1] =\n",
       " 6.0  14.0\n",
       " 8.0  16.0\n",
       "\n",
       "[:, :, 2, 1] =\n",
       " 22.0  30.0\n",
       " 24.0  32.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# each channel and each instance is pooled separately\n",
    "pool(x)  # size Y = (Y1,...,Yd,Cx,N) where Yi are spatial dims, Cx and N are identical to input X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Experiment setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load MNIST data\n",
    "xtrn,ytrn = MNIST.traindata(Float32); ytrn[ytrn.==0] .= 10\n",
    "xtst,ytst = MNIST.testdata(Float32);  ytst[ytst.==0] .= 10\n",
    "dtrn = minibatch(xtrn, ytrn, 100; xsize = (28,28,1,:))\n",
    "dtst = minibatch(xtst, ytst, 100; xsize = (28,28,1,:));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28×28×1×100 KnetArray{Float32,4}\n",
      "100-element Array{Int64,1}\n"
     ]
    }
   ],
   "source": [
    "(x,y) = first(dtst)\n",
    "println.(summary.((x,y)));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "trainresults (generic function with 1 method)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# For running experiments\n",
    "function trainresults(file,model; o...)\n",
    "    if (print(\"Train from scratch? \"); readline()[1]=='y')\n",
    "        r = ((model(dtrn), model(dtst), zeroone(model,dtrn), zeroone(model,dtst))\n",
    "             for x in takenth(progress(sgd(model,ncycle(dtrn,100))),length(dtrn)))\n",
    "        r = reshape(collect(Float32,flatten(r)),(4,:))\n",
    "        Knet.save(file,\"results\",r)\n",
    "        GC.gc(true) # To save gpu memory\n",
    "    else\n",
    "        isfile(file) || download(\"http://people.csail.mit.edu/deniz/models/tutorial/$file\",file)\n",
    "        r = Knet.load(file,\"results\")\n",
    "    end\n",
    "    println(minimum(r,dims=2))\n",
    "    return r\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A convolutional neural network model for MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Conv"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define a convolutional layer:\n",
    "struct Conv; w; b; f; p; end\n",
    "(c::Conv)(x) = c.f.(pool(conv4(c.w, dropout(x,c.p)) .+ c.b))\n",
    "Conv(w1::Int,w2::Int,cx::Int,cy::Int,f=relu;pdrop=0) = Conv(param(w1,w2,cx,cy), param0(1,1,cy,1), f, pdrop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dense"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Redefine dense layer (See mlp.ipynb):\n",
    "struct Dense; w; b; f; p; end\n",
    "(d::Dense)(x) = d.f.(d.w * mat(dropout(x,d.p)) .+ d.b) # mat reshapes 4-D tensor to 2-D matrix so we can use matmul\n",
    "Dense(i::Int,o::Int,f=relu;pdrop=0) = Dense(param(o,i), param0(o), f, pdrop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's define a chain of layers\n",
    "struct Chain\n",
    "    layers\n",
    "    Chain(layers...) = new(layers)\n",
    "end\n",
    "(c::Chain)(x) = (for l in c.layers; x = l(x); end; x)\n",
    "(c::Chain)(x,y) = nll(c(x),y)\n",
    "(c::Chain)(d::Data) = mean(c(x,y) for (x,y) in d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{String,1}:\n",
       " \"5×5×1×20 AutoGrad.Param{KnetArray{Float32,4}}\"\n",
       " \"5×5×20×50 AutoGrad.Param{KnetArray{Float32,4}}\"\n",
       " \"500×800 AutoGrad.Param{KnetArray{Float32,2}}\"\n",
       " \"10×500 AutoGrad.Param{KnetArray{Float32,2}}\""
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lenet =   Chain(Conv(5,5,1,20), \n",
    "                Conv(5,5,20,50), \n",
    "                Dense(800,500,pdrop=0.3), \n",
    "                Dense(500,10,identity,pdrop=0.3))\n",
    "summary.(l.w for l in lenet.layers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.292842f0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lenet(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## CNN vs MLP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train from scratch? stdin> n\n",
      "Float32[0.00016041519; 0.018454755; 0.0; 0.005]\n"
     ]
    }
   ],
   "source": [
    "# 1.08e-02  100.00%┣████████████████▉┫ 60000/60000 [03:50/03:50, 260.67i/s]\n",
    "# [0.000135032; 0.0196918; 0.0; 0.0053]\n",
    "cnn = trainresults(\"cnn113.jld2\", lenet);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "mlp = Knet.load(\"mlp113f.jld2\",\"results\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "using Plots; default(fmt=:png,ls=:auto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comparison to MLP shows faster convergence, better generalization\n",
    "plot([mlp[1,:], mlp[2,:], cnn[1,:], cnn[2,:]],ylim=(0.0,0.1),\n",
    "     labels=[\"trnMLP\" \"tstMLP\" \"trnCNN\" \"tstCNN\"],xlabel=\"Epochs\",ylabel=\"Loss\")  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot([mlp[3,:], mlp[4,:], cnn[3,:], cnn[4,:]],ylim=(0.0,0.03),\n",
    "    labels=[\"trnMLP\" \"tstMLP\" \"trnCNN\" \"tstCNN\"],xlabel=\"Epochs\",ylabel=\"Error\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Convolution vs Matrix Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = reshape([1.0, 2.0, 3.0], (3, 1, 1, 1)) = [1.0; 2.0; 3.0]\n",
      "x = reshape([1.0:7.0...], (7, 1, 1, 1)) = [1.0; 2.0; 3.0; 4.0; 5.0; 6.0; 7.0]\n",
      "y = conv4(w, x) = [10.0; 16.0; 22.0; 28.0; 34.0]\n"
     ]
    }
   ],
   "source": [
    "# Convolution and matrix multiplication can be implemented in terms of each other.\n",
    "# Convolutional networks have no additional representational power, only statistical efficiency.\n",
    "# Our original 1-D example\n",
    "@show w = reshape([1.0,2.0,3.0], (3,1,1,1))\n",
    "@show x = reshape([1.0:7.0...], (7,1,1,1))\n",
    "@show y = conv4(w, x);  # size Y = X - W + 1 = 5 by default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5×7 Array{Float64,2}:\n",
       " 3.0  2.0  1.0  0.0  0.0  0.0  0.0\n",
       " 0.0  3.0  2.0  1.0  0.0  0.0  0.0\n",
       " 0.0  0.0  3.0  2.0  1.0  0.0  0.0\n",
       " 0.0  0.0  0.0  3.0  2.0  1.0  0.0\n",
       " 0.0  0.0  0.0  0.0  3.0  2.0  1.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convolution as matrix multiplication (1)\n",
    "# Turn w into a (Y,X) sparse matrix\n",
    "w2 = Float64[3 2 1 0 0 0 0; 0 3 2 1 0 0 0; 0 0 3 2 1 0 0; 0 0 0 3 2 1 0; 0 0 0 0 3 2 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y2 = w2 * mat(x) = [10.0; 16.0; 22.0; 28.0; 34.0]\n"
     ]
    }
   ],
   "source": [
    "@show y2 = w2 * mat(x);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×5 Array{Float64,2}:\n",
       " 1.0  2.0  3.0  4.0  5.0\n",
       " 2.0  3.0  4.0  5.0  6.0\n",
       " 3.0  4.0  5.0  6.0  7.0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convolution as matrix multiplication (2)\n",
    "# Turn x into a (W,Y) dense matrix (aka the im2col operation)\n",
    "# This is used to speed up convolution with known efficient matmul algorithms\n",
    "x3 = Float64[1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w3 = [3.0 2.0 1.0] = [3.0 2.0 1.0]\n",
      "y3 = w3 * x3 = [10.0 16.0 22.0 28.0 34.0]\n"
     ]
    }
   ],
   "source": [
    "@show w3 = [3.0 2.0 1.0]\n",
    "@show y3 = w3 * x3;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×3 Array{Float64,2}:\n",
       " 1.0  3.0  5.0\n",
       " 2.0  4.0  6.0"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Matrix multiplication as convolution\n",
    "# This could be used to make a fully connected network accept variable sized inputs.\n",
    "w = reshape([1.0:6.0...], (2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×1 Array{Float64,2}:\n",
       " 1.0\n",
       " 2.0\n",
       " 3.0"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = reshape([1.0:3.0...], (3,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×1 Array{Float64,2}:\n",
       " 22.0\n",
       " 28.0"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = w * x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×1×1×2 Array{Float64,4}:\n",
       "[:, :, 1, 1] =\n",
       " 1.0\n",
       " 3.0\n",
       " 5.0\n",
       "\n",
       "[:, :, 1, 2] =\n",
       " 2.0\n",
       " 4.0\n",
       " 6.0"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Consider w with size (Y,X)\n",
    "# Treat each of the Y rows of w as a convolution filter\n",
    "w2 = copy(reshape(Array(w)', (3,1,1,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×1×1×1 Array{Float64,4}:\n",
       "[:, :, 1, 1] =\n",
       " 1.0\n",
       " 2.0\n",
       " 3.0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reshape x for convolution\n",
    "x2 = reshape(x, (3,1,1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×1×2×1 Array{Float64,4}:\n",
       "[:, :, 1, 1] =\n",
       " 22.0\n",
       "\n",
       "[:, :, 2, 1] =\n",
       " 28.0"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use conv4 for matrix multiplication\n",
    "y2 = conv4(w2, x2; mode=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* So there is no difference between the class of functions representable with an MLP vs CNN.\n",
    "* Sparse connections and weight sharing give CNNs more generalization power with images.\n",
    "* Number of parameters in MLP256: (256x784)+256+(10x256)+10 = 203530\n",
    "* Number of parameters in LeNet: (5*5*1*20)+20+(5*5*20*50)+50+(500*800)+500+(10*500)+10 = 431080"
   ]
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "julia.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Julia 1.5.0",
   "language": "julia",
   "name": "julia-1.5"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}