22. 实现卷积神经网络.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实验：实现卷积神经网络"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 实验概要\n",
    "\n",
    "卷积神经网络和常规神经网络非常相似：它们都是由神经元组成，神经元中有具有学习能力的权重和偏差。每个神经元都得到一些输入数据，进行内积运算后再进行激活函数运算。整个网络依旧是一个可导的评分函数：该函数的输入是原始的图像像素，输出是不同类别的评分。在最后一层（**往往是全连接层**），网络依旧有一个损失函数（比如 SVM 或 Softmax），并且在神经网络中我们实现的各种技巧和要点依旧适用于卷积神经网络。\n",
    "\n",
    "那么有哪些地方变化了呢？卷积神经网络的结构基于一个假设，即输入数据是图像，基于该假设，我们就向结构中添加了一些特有的性质。这些特有属性使得前向传播函数实现起来更高效，并且大幅度降低了网络中参数的数量。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 卷积神经网络结构概述\n",
    "\n",
    "##### 常规神经网络。\n",
    "\n",
    "神经网络的输入是一个向量，然后在一系列的隐层中对它做变换。每个 **隐藏层** 都是由若干的神经元组成，每个神经元都与前一层中的所有神经元连接。但是在一个 **隐藏层** 中，神经元相互独立不进行任何连接。最后的全连接层被称为 **输出层**，在分类问题中，它输出的值被看做是不同类别的评分值。\n",
    "\n",
    "常规神经网络对于大尺寸图像效果不尽人意。在 CIFAR-10 中，图像的尺寸是 `32x32x3`（宽高均为 `32` 像素，`3` 个颜色通道），因此，对应的的常规神经网络的第一个 **隐藏层** 中，每一个单独的全连接神经元就有 `32x32x3=3072` 个权重。这个数量看起来还可以接受，但是很显然这个全连接的结构不适用于更大尺寸的图像。举例说来，一个尺寸为 `200x200x3` 的图像，会让神经元包含 `200x200x3=120,000` 个权重值。而网络中肯定不止一个神经元，那么参数的量就会快速增加！显而易见，这种全连接方式效率低下，大量的参数也很快会导致网络过拟合。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#####  神经元的三维排列\n",
    "\n",
    "卷积神经网络针对输入全部是图像的情况，将结构调整得更加合理，获得了不小的优势。与常规神经网络不同，卷积神经网络的各层中的神经元是三维排列的：**宽度、高度和深度**（这里的 **深度** 指的是激活数据体的第三个维度，而不是整个网络的深度，整个网络的深度指的是网络的层数）。举个例子，CIFAR-10 中的图像是作为卷积神经网络的输入，该数据体的维度是 `32x32x3`（**宽度，高度和深度**）。我们将看到，层中的神经元将只与前一层中的一小块区域连接，而不是采取全连接方式。对于用来分类 CIFAR-10 中的图像的卷积网络，其最后的输出层的维度是 `1x1x10`，因为在卷积神经网络结构的最后部分将会把全尺寸的图像压缩为包含分类评分的一个向量，向量是在深度方向排列的。下面是例子：\n",
    "\n",
    "![](./img/1_22.jpg)\n",
    "\n",
    "*左边是一个三层的神经网络。右边是一个卷积神经网络，图例中网络将它的神经元都排列成三个维度（**宽、高和深度**）。卷积神经网络的每一层都将 3D 的输入数据变化为神经元 3D 的激活数据并输出。在这个例子中，红色的输入层装的是图像，所以它的宽度和高度就是图像的宽度和高度，它的深度是 `3`（代表了红、绿、蓝三种颜色通道）。*\n",
    "\n",
    "> 卷积神经网络是由层组成的。每一层都有一个简单的 API：用一些含或者不含参数的可导的函数，将输入的 3D 数据变换为 3D 的输出数据。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 构建卷积神经网络的各种层\n",
    "\n",
    "一个简单的卷积神经网络是由各种层按照顺序排列组成，网络中的每个层使用一个可以微分的函数将激活数据从一个层传递到另一个层。卷积神经网络主要由三种类型的层构成：\n",
    "\n",
    "- **卷积（Convolutional）层**\n",
    "- **汇聚/池化（Pooling）层**\n",
    "- **全连接（Fully-Connected）层（全连接层和常规神经网络中的一样）**\n",
    "\n",
    "通过将这些层叠加起来，就可以构建一个完整的卷积神经网络。我们先举一个网络结构例子：这仅仅是个概述，下面会更详解的介绍细节。\n",
    "\n",
    "一个用于 CIFAR-10 图像数据分类的卷积神经网络的结构可以是：**`[输入层-卷积层-ReLU层-汇聚层-全连接层]`**，细节如下：\n",
    "\n",
    "- **输入：** `[32x32x3]` 存有图像的原始像素值，本例中图像宽高均为 `32`，有三个颜色通道。\n",
    "- **卷积层：** 神经元与输入层中的一个局部区域相连，每个神经元都计算自己与输入层相连的小区域与自己权重的内积。卷积层会计算所有神经元的输出。如果我们使用 `12` 个滤波器（也叫作核），得到的输出数据体的维度就是 `[32x32x12]`。\n",
    "- **ReLU 层：** 将会逐个元素地进行激活函数操作，比如使用以 `0` 为阈值的 $\\max (0, x)$ 作为激活函数。该层对数据尺寸没有改变，还是 `[32x32x12]`。\n",
    "- **汇聚层：** 会在空间维度（宽度和高度）上进行降采样（downsampling）操作，数据尺寸变为 `[16x16x12]`。\n",
    "- **全连接层：** 将会计算分类评分，数据尺寸变为 `[1x1x10]`，其中 **10** 个数字对应的就是 CIFAR-10 中 **10** 个类别的分类评分值。正如其名，全连接层与常规神经网络一样，其中每个神经元都与前一层中所有神经元相连接。\n",
    "\n",
    "由此看来，卷积神经网络一层一层地将图像从原始像素值变换成最终的分类评分值。其中有的层含有参数，有的没有。具体说来，卷积层和全连接层（CONV/FC）对输入执行变换操作的时候，不仅会用到激活函数，还会用到很多参数（神经元的突触权值和偏差）。而 ReLU 层和汇聚层则是进行一个固定不变的函数操作。卷积层和全连接层中的参数会随着梯度下降被训练，这样卷积神经网络计算出的分类评分就能和训练集中的每个图像的标签吻合了。\n",
    "\n",
    "**小结一下：**\n",
    "\n",
    "- 简单案例中卷积神经网络的结构，就是一系列的层将输入数据变换为输出数据（比如分类评分）。\n",
    "- 卷积神经网络结构中有几种不同类型的层（目前最流行的有卷积层、全连接层、ReLU 层和汇聚层）。\n",
    "- 每个层的输入是3D数据，然后使用一个可导的函数将其变换为 3D 的输出数据。\n",
    "- 有的层有参数，有的没有（卷积层和全连接层有，ReLU 层和汇聚层没有）。\n",
    "- 有的层有额外的超参数，有的没有（卷积层、全连接层和汇聚层有，ReLU 层没有）。\n",
    "\n",
    "<img src=\"./img/2_22.jpg\" width=\"75%\">\n",
    "\n",
    "*上图是一个卷积神经网络的激活输出例子。左边的输入层存有原始图像像素，右边的输出层存有类别分类评分。在处理流程中的每个激活数据体是铺成一列来展示的。因为对 3D 数据作图比较困难，我们就把每个数据体切成层，然后铺成一列显示。最后一层装的是针对不同类别的分类得分，这里只显示了得分最高的 5 个评分值和对应的类别。本例中的结构是一个小的 VGG 网络，VGG 网络后面会有讨论。*\n",
    "\n",
    "下面，讲解不同的层，层的超参数和连接情况的细节。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 卷积层 ( Convolutional Layer )\n",
    "\n",
    "卷积层是构建卷积神经网络的核心层，它产生了网络中大部分的计算量。\n",
    "\n",
    "**概述和直观介绍：** 首先讨论的是，在没有大脑和生物意义上的神经元之类的比喻下，卷积层到底在计算什么。卷积层的参数是有一些可学习的滤波器集合构成的。每个滤波器在空间上（宽度和高度）都比较小，但是深度和输入数据一致。举例来说，卷积神经网络第一层的一个典型的滤波器的尺寸可以是 `5x5x3`（宽高都是 `5` 像素，深度是 `3` 是因为图像应为颜色通道，所以有 `3` 的深度）。在前向传播的时候，让每个滤波器都在输入数据的宽度和高度上滑动（更精确地说是卷积），然后计算整个滤波器和输入数据任一处的内积。当滤波器沿着输入数据的宽度和高度滑过后，会生成一个 **二维的激活图（activation map）**，激活图给出了在每个空间位置处滤波器的反应。直观地来说，网络会让滤波器学习到当它看到某些类型的视觉特征时就激活，具体的视觉特征可能是某些方位上的边界，或者在第一层上某些颜色的斑点，甚至可以是网络更高层上的蜂巢状或者车轮状图案。\n",
    "\n",
    "在每个卷积层上，我们会有一整个集合的滤波器（比如 `12` 个），每个都会生成一个不同的二维激活图。将这些激活映射在深度方向上层叠起来就生成了输出数据。\n",
    "\n",
    "**以大脑做比喻：** 如果你喜欢用大脑和生物神经元来做比喻，那么输出的 3D 数据中的每个数据项可以被看做是神经元的一个输出，而该神经元只观察输入数据中的一小部分，并且和空间上左右两边的所有神经元共享参数（因为这些数字都是使用同一个滤波器得到的结果）。现在开始讨论神经元的连接，它们在空间中的排列，以及它们参数共享的模式。\n",
    "\n",
    "**局部连接：** 在处理图像这样的高维度输入时，让每个神经元都与前一层中的所有神经元进行全连接是不现实的。相反，我们让每个神经元只与输入数据的一个局部区域连接。该连接的空间大小叫做神经元的 **感受野（receptive field）**，它的尺寸是一个超参数（其实就是滤波器的空间尺寸）。在深度方向上，这个连接的大小总是和输入量的深度相等。**需要再次强调的是，我们对待空间维度（宽和高）与深度维度是不同的：连接在空间（宽高）上是局部的，但是在深度上总是和输入数据的深度一致**。\n",
    "\n",
    "> ***例1：*** 假设输入数据体尺寸为 `[32x32x3]`（比如 CIFAR-10 的 RGB 图像），如果感受野（或滤波器尺寸）是 `5x5`，那么卷积层中的每个神经元会有输入数据体中 `[5x5x3]` 区域的权重，共 `5x5x3=75` 个权重（还要加一个偏差参数）。注意这个连接在深度维度上的大小必须为 `3`，和输入数据体的深度一致。\n",
    "\n",
    "> ***例2：*** 假设输入数据体的尺寸是 `[16x16x20]`，感受野尺寸是 `3x3`，那么卷积层中每个神经元和输入数据体就有 `3x3x20=180` 个连接。**再次提示：** 在空间上连接是局部的（`3x3`），但是在深度上是和输入数据体一致的（`20`）。\n",
    "\n",
    "<img src=\"./img/3_22.jpg\" width=\"75%\">\n",
    "\n",
    "***左边：*** *红色的是输入数据体（比如 CIFAR-10 中的图像），蓝色的部分是第一个卷积层中的神经元。卷积层中的每个神经元都只是与输入数据体的一个局部在空间上相连，但是与输入数据体的所有深度维度全部相连（所有颜色通道）。在深度方向上有多个神经元（本例中 5 个），它们都接受输入数据的同一块区域（感受野相同）。至于深度列的讨论在下文中有。* ***右边：*** *神经网络章节中介绍的神经元保持不变，它们还是计算权重和输入的内积，然后进行激活函数运算，只是它们的连接被限制在一个局部空间。*\n",
    "\n",
    "**空间排列：** 上文讲解了卷积层中每个神经元与输入数据体之间的连接方式，但是尚未讨论输出数据体中神经元的数量，以及它们的排列方式。3个超参数控制着输出数据体的尺寸：**深度（depth）**，**步长（stride）** 和 **零填充（zero-padding）**。下面是对它们的解释：\n",
    "\n",
    "1. 首先，输出数据体的深度是一个超参数：它和使用的滤波器的数量一致，而每个滤波器在输入数据中寻找一些不同的东西。举例来说，如果第一个卷积层的输入是原始图像，那么在深度维度上的不同神经元将可能被不同方向的边界，或者是颜色斑点激活。我们将这些沿着深度方向排列、感受野相同的神经元集合称为 **深度列（depth column）**，也有人使用纤维（fibre）来称呼它们。\n",
    "2. 其次，在滑动滤波器的时候，必须指定步长。当步长为 1，滤波器每次移动 1 个像素。当步长为 2（或者不常用的 3，或者更多，这些在实际中很少使用），滤波器滑动时每次移动 2 个像素。这个操作会让输出数据体在空间上变小。\n",
    "3. 在下文可以看到，有时候将输入数据体用0在边缘处进行填充是很方便的。这个 **零填充（zero-padding）** 的尺寸是一个超参数。零填充有一个良好性质，即可以控制输出数据体的空间尺寸（最常用的是用来保持输入数据体在空间上的尺寸，这样输入和输出的宽高都相等）。\n",
    "\n",
    "输出数据体在空间上的尺寸可以通过输入数据体尺寸（$W$），卷积层中神经元的感受野尺寸（$F$），步长（$S$）和零填充的数量（$P$）的函数来计算。（*注：这里假设输入数组的空间形状是正方形，即高度和宽度相等*）输出数据体的空间尺寸为 $(W-F +2P)/S+1$。比如：输入是 `7x7`，滤波器是 `3x3`，步长为 `1`，填充为 `0`，那么就能得到一个 `5x5` 的输出。如果步长为 `2`，输出就是 `3x3`。下面是例子：\n",
    "\n",
    "![](./img/4_22.jpg)\n",
    "\n",
    "上图为空间排列的图示。在本例中只有一个空间维度（x 轴），神经元的感受野尺寸 `F=3`，输入尺寸 `W=5`，零填充 `P=1`。\n",
    "\n",
    "- 左边：神经元使用的步长 `S=1`，所以输出尺寸是 `(5-3+2)/1+1=5`。\n",
    "- 右边：神经元的步长 `S=2`，则输出尺寸是 `(5-3+2)/2+1=3`。注意当步长 `S=3` 时是无法使用的，因为它无法整齐地穿过数据体。从等式上来说，因为 `(5-3+2)=4` 是不能被 `3` 整除的。\n",
    "\n",
    "本例中，神经元的权重是 `[1,0,-1]`，显示在图的右上角，偏差值为 `0`。这些权重是被所有黄色的神经元共享的（参数共享的内容看下文相关内容）。\n",
    "\n",
    "**使用零填充：** 在上面左边例子中，注意输入维度是 `5`，输出维度也是 `5`。之所以如此，是因为感受野是 `3` 并且使用了 `1` 的零填充。如果不使用零填充，则输出数据体的空间维度就只有 `3`，因为这就是滤波器整齐滑过并覆盖原始数据需要的数目。一般说来，当步长 $S=1$ 时，零填充的值是 $P=(F−1)/2 $，这样就能保证输入和输出数据体有相同的空间尺寸。这样做非常常见，在介绍卷积神经网络的结构的时候我们会详细讨论其原因。\n",
    "\n",
    "**步长的限制：** 注意这些空间排列的超参数之间是相互限制的。举例说来，当输入尺寸 $W=10$，不使用零填充则 $P=0$，滤波器尺寸 $F=3 $，这样步长 $S=2$ 就行不通，因为 $(W−F+2P)/S+1=(10−3+0)/2+1=4.5$，结果不是整数，这就是说神经元不能整齐对称地滑过输入数据体。因此，这些超参数的设定就被认为是无效的，一个卷积神经网络库可能会报出一个错误，或者修改零填充值来让设置合理，或者修改输入数据体尺寸来让设置合理，或者其他什么措施。在后面的卷积神经网络结构小节中，你可以看到合理地设置网络的尺寸让所有的维度都能正常工作，这件事可是相当让人头痛的。而使用零填充和遵守其他一些设计策略将会有效解决这个问题。\n",
    "\n",
    "譬如：[Krizhevsky 架构](http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks) 赢得了 2012 年的 ImageNet 挑战，其输入图像的尺寸是 `[227x227x3]`。在第一个卷积层，神经元使用的感受野尺寸 $F=11 $，步长 $S=4$，不使用零填充 $P=0$。因为 `(227-11)/4+1=55`，卷积层的深度 $K=96 $，则卷积层的输出数据体尺寸为 `[55x55x96]`。`55x55x96` 个神经元中，每个都和输入数据体中一个尺寸为 `[11x11x3]` 的区域全连接。在深度列上的 `96` 个神经元都是与输入数据体中同一个 `[11x11x3]` 区域连接，但是权重不同。有一个有趣的细节，在原论文中，说的输入图像尺寸是 `224x224`，这是肯定错误的，因为 `(224-11)/4+1` 的结果不是整数。这件事在卷积神经网络的历史上让很多人迷惑，而这个错误到底是怎么发生的没人知道。估计是 Alex 忘记在论文中指出自己使用了尺寸为 `3` 的额外的零填充。\n",
    "\n",
    "**参数共享：** 在卷积层中使用参数共享是用来控制参数的数量。就用上面的例子，在第一个卷积层就有 `55x55x96=290,400` 个神经元，每个有 `11x11x3=364` 个参数和 `1` 个偏置。将这些合起来就是 ·290400x364=105,705,600· 个参数。单单第一层就有这么多参数，显然这个数目是非常大的。\n",
    "\n",
    "作一个合理的假设：如果一个特征在计算某个空间位置 `(x,y)` 的时候有用，那么它在计算另一个不同位置 `(x2,y2)` 的时候也有用。基于这个假设，可以显著地减少参数数量。换言之，就是将深度维度上一个单独的2维切片看做 **深度切片（depth slice）**，比如一个数据体尺寸为 `[55x55x96]` 的就有 `96` 个深度切片，每个尺寸为 `[55x55]`。在每个深度切片上的神经元都使用同样的权重和偏差。在这样的参数共享下，例子中的第一个卷积层就只有 `96` 个不同的权重集了，一个权重集对应一个深度切片，共有 `96x11x11x3=34,848` 个不同的权重，或 `34,944`个参数（ `+96` 个偏差）。在每个深度切片中的 `55x55` 个权重使用的都是同样的参数。在反向传播的时候，都要计算每个神经元对它的权重的梯度，但是需要把同一个深度切片上的所有神经元对权重的梯度累加，这样就得到了对共享权重的梯度。这样，每个切片只更新一个权重集。\n",
    "\n",
    "注意，如果在一个深度切片中的所有权重都使用同一个权重向量，那么卷积层的前向传播在每个深度切片中可以看做是在计算神经元权重和输入数据体的 **卷积**（这就是 **卷积层** 名字由来）。这也是为什么总是将这些权重集合称为 **滤波器（filter**）（或 **卷积核（kernel）**），因为它们和输入进行了卷积。\n",
    "\n",
    "![](./img/5_22.jpg)\n",
    "\n",
    "*以上是 Krizhevsky 等学习到的滤波器例子。这 `96` 个滤波器的尺寸都是 `[11x11x3]`，在一个深度切片中，每个滤波器都被 `55x55` 个神经元共享。注意参数共享的假设是有道理的：如果在图像某些地方探测到一个水平的边界是很重要的，那么在其他一些地方也会同样是有用的，这是因为图像结构具有平移不变性。所以在卷积层的输出数据体的 `55x55` 个不同位置中，就没有必要重新学习去探测一个水平边界了。*\n",
    "\n",
    "注意有时候参数共享假设可能没有意义，特别是当卷积神经网络的输入图像是一些明确的中心结构时候。这时候我们就应该期望在图片的不同位置学习到完全不同的特征。一个具体的例子就是输入图像是人脸，人脸一般都处于图片中心。你可能期望不同的特征，比如眼睛特征或者头发特征可能（也应该）会在图片的不同位置被学习。在这个例子中，通常就放松参数共享的限制，将层称为 **局部连接层（Locally-Connected Layer）**。\n",
    "\n",
    "**Numpy 例子：** 为了让讨论更加的具体，我们用代码来展示上述思路。假设输入数据体是 numpy 数组 `X`。那么：\n",
    "\n",
    "- 一个位于 `(x,y)` 的 **深度列**（或 **纤维**）将会是 `X[x,y,:]`。\n",
    "- 在深度为 `d` 处的 **深度切片**，或 **激活图** 应该是 `X[:,:,d]`。\n",
    "\n",
    "**卷积层例子：** 假设输入数据体 `X` 的尺寸 `X.shape:(11,11,4)`，不使用零填充（$P=0$），滤波器的尺寸是 $F=5$，步长 $S=2$。那么输出数据体的空间尺寸就是 `(11-5)/2+1=4`，即输出数据体的宽度和高度都是 `4`。那么在输出数据体中的激活映射（称其为 `V`）看起来就是下面这样（在这个例子中，只有部分元素被计算）：\n",
    "\n",
    "- `V[0,0,0] = np.sum(X[:5,:5,:] * W0) + b0`\n",
    "- `V[1,0,0] = np.sum(X[2:7,:5,:] * W0) + b0`\n",
    "- `V[2,0,0] = np.sum(X[4:9,:5,:] * W0) + b0`\n",
    "- `V[3,0,0] = np.sum(X[6:11,:5,:] * W0) + b0`\n",
    "\n",
    "在numpy 中，`*` 操作是进行数组间的逐元素相乘。权重向量 `W0` 是该神经元的权重，`b0` 是其偏差。在这里，`W0` 被假设尺寸是 `W0.shape: (5,5,4)`，因为滤波器的宽高是 `5`，输入数据量的深度是 `4`。注意在每一个点，计算点积的方式和之前的常规神经网络是一样的。同时，计算内积的时候使用的是同一个权重和偏差（因为参数共享），在宽度方向的数字每次上升 `2`（因为步长为 `2`）。要构建输出数据体中的第二张激活图，代码应该是：\n",
    "\n",
    "- `V[0,0,1] = np.sum(X[:5,:5,:] * W1) + b1`\n",
    "- `V[1,0,1] = np.sum(X[2:7,:5,:] * W1) + b1`\n",
    "- `V[2,0,1] = np.sum(X[4:9,:5,:] * W1) + b1`\n",
    "- `V[3,0,1] = np.sum(X[6:11,:5,:] * W1) + b1`\n",
    "- `V[0,1,1] = np.sum(X[:5,2:7,:] * W1) + b1`（在 y 方向上）\n",
    "- `V[2,3,1] = np.sum(X[4:9,6:11,:] * W1) + b1`（或两个方向上同时）\n",
    "\n",
    "我们访问的是 `V` 的深度维度上的第二层（即 `index1`），因为是在计算第二个激活图，所以这次试用的参数集就是 `W1` 了。在上面的例子中，为了简洁略去了卷积层对于输出数组 `V` 中其他部分的操作。还有，要记得这些卷积操作通常后面接的是 **ReLU 层**，对激活图中的每个元素做激活函数运算，这里没有显示。\n",
    "\n",
    "**小结**，我们总结一下卷积层的性质：\n",
    "\n",
    "- 输入数据体的尺寸为：$W_{1} \\times H_{1} \\times D_{1}$\n",
    "- 4 个超参数：\n",
    "   - 滤波器的数量 $K$\n",
    "   - 滤波器的空间尺寸 $F$\n",
    "   - 步长 $S$\n",
    "   - 零填充数量 $P$\n",
    "- 输出数据体的尺寸为：$W_{2} \\times H_{2} \\times D_{2}$，其中：\n",
    "   - $W_{2}=\\left(W_{1}-F+2 P\\right) / S+1$\n",
    "   - $H_{2}=\\left(H_{1}-F+2 P\\right) / S+1$（宽度和高度的计算方法相同）\n",
    "   - $D_{2}=K$\n",
    "- 由于参数共享，每个滤波器包含 $F \\cdot F \\cdot D_{1}$ 个权重，卷积层一共有 $F \\cdot F \\cdot D_{1} \\cdot K$ 个权重和 $K$ 个偏置。\n",
    "- 在输出数据体中，第 $d$ 个深度切片（空间尺寸是 $W_{2} \\times H_{2}$），用第 $d$ 个滤波器和输入数据进行有效卷积运算的结果（使用步长 $S$），最后在加上第 $d$ 个偏差。\n",
    "\n",
    "**卷积层演示：** 下面是一个卷积层的运行演示。因为 3D 数据难以可视化，所以所有的数据（输入数据体是蓝色，权重数据体是红色，输出数据体是绿色）都采取将深度切片按照列的方式排列展现。输入数据体的尺寸是 $W_{1}=5, H_{1}=5, D_{1}=3$，卷积层参数 $K=2, F=3, S=2, P=1$。就是说，有 2 个滤波器，滤波器的尺寸是 $3 \\cdot 3$，它们的步长是 `2`.因此，输出数据体的空间尺寸是 `(5-3+2)/2+1=3` 。注意输入数据体使用了零填充 $P=1$，所以输入数据体外边缘一圈都是 `0`。下面的例子在绿色的输出激活数据上循环演示，展示了其中每个元素都是先通过蓝色的输入数据和红色的滤波器逐元素相乘，然后求其总和，最后加上偏差得来。\n",
    "\n",
    "![](./img/6_22.gif)\n",
    "\n",
    "**用矩阵乘法实现：** 卷积运算本质上就是在滤波器和输入数据的局部区域间做点积。卷积层的常用实现方式就是利用这一点，将卷积层的前向传播变成一个巨大的矩阵乘法：\n",
    "\n",
    "1. 输入图像的局部区域被 **im2col** 操作拉伸为列。比如，如果输入是 `[227x227x3]`，要与尺寸为 `11x11x3` 的滤波器以步长为 `4` 进行卷积，就取输入中的 `[11x11x3]` 数据块，然后将其拉伸为长度为 `11x11x3=363` 的列向量。重复进行这一过程，因为步长为 `4`，所以输出的宽高为 `(227-11)/4+1=55`，所以得到 **im2col** 操作的输出矩阵 `X_col` 的尺寸是 `[363x3025]`，其中每列是拉伸的感受野，共有 `55x55=3,025` 个。注意因为感受野之间有重叠，所以输入数据体中的数字在不同的列中可能有重复。\n",
    "2. 卷积层的权重也同样被拉伸成行。举例，如果有 96 个尺寸为 `[11x11x3]` 的滤波器，就生成一个矩阵 `W_row`，尺寸为 `[96x363]`。\n",
    "3. 现在卷积的结果和进行一个大矩阵乘 **np.dot(W_row, X_col)** 是等价的了，能得到每个滤波器和每个感受野间的点积。在我们的例子中，这个操作的输出是 `[96x3025]`，给出了每个滤波器在每个位置的点积输出。\n",
    "4. 结果最后必须被重新变为合理的输出尺寸 `[55x55x96]`。\n",
    "\n",
    "这个方法的缺点就是占用内存太多，因为在输入数据体中的某些值在 `X_col` 中被复制了多次。但是，其优点是矩阵乘法有非常多的高效实现方式，我们都可以使用（比如常用的 [BLAS API](http://www.netlib.org/blas/)）。还有，同样的 **im2col** 思路可以用在汇聚操作中。\n",
    "\n",
    "**反向传播：** 卷积操作的反向传播（同时对于数据和权重）还是一个卷积（但是是和空间上翻转的滤波器）。使用一个一维的例子比较容易演示。\n",
    "\n",
    "**1x1 卷积：** 一些论文中使用了 `1x1` 的卷积，这个方法最早是在论文 [Network in Network](http://arxiv.org/abs/1312.4400) 中出现。人们刚开始看见这个 `1x1` 卷积的时候比较困惑，尤其是那些具有信号处理专业背景的人。因为信号是二维的，所以 `1x1` 卷积就没有意义。但是，在卷积神经网络中不是这样，因为这里是对三个维度进行操作，滤波器和输入数据体的深度是一样的。比如，如果输入是 `[32x32x3]`，那么 `1x1` 卷积就是在高效地进行三维点积（因为输入深度是三个通道）。\n",
    "\n",
    "**扩张卷积：** 最近一个研究（[Fisher Yu 和 Vladlen Koltun 的论文](https://arxiv.org/abs/1511.07122)）给卷积层引入了一个新的叫 **扩张（dilation）** 的超参数。到目前为止，我们只讨论了卷积层滤波器是连续的情况。但是，让滤波器中元素之间有间隙也是可以的，这就叫做 **扩张**。举例，在某个维度上滤波器 `w` 的尺寸是 `3`，那么计算输入 `x` 的方式是：`w[0]*x[0] + w[1]*x[1] + w[2]*x[2]`，此时扩张为 `0`。如果扩张为 `1`，那么计算为： `w[0]*x[0] + w[1]*x[2] + w[2]*x[4]`。换句话说，操作中存在 `1` 的间隙。在某些设置中，扩张卷积与正常卷积结合起来非常有用，因为在很少的层数内更快地汇集输入图片的大尺度特征。比如，如果上下重叠 2 个 `3x3` 的卷积层，那么第二个卷积层的神经元的感受野是输入数据体中 `5x5` 的区域（可以成这些神经元的有效感受野是 `5x5`）。如果我们对卷积进行扩张，那么这个有效感受野就会迅速增长。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 汇聚层  ( 池化层 - Pooling Layer )\n",
    "\n",
    "通常，在连续的卷积层之间会周期性地插入一个汇聚层。它的作用是逐渐降低数据体的空间尺寸，这样的话就能减少网络中参数的数量，使得计算资源耗费变少，也能有效控制过拟合。汇聚层使用 **MAX** 操作，对输入数据体的每一个深度切片独立进行操作，改变它的空间尺寸。最常见的形式是汇聚层使用尺寸 `2x2` 的滤波器，以步长为 `2` 来对每个深度切片进行降采样，将其中75%的激活信息都丢掉。每个 **MAX** 操作是从 `4` 个数字中取最大值（也就是在深度切片中某个 `2x2` 的区域）。深度保持不变。汇聚层的一些公式：\n",
    "\n",
    "- 输入数据体尺寸：$W_{1} \\cdot H_{1} \\cdot D_{1}$\n",
    "- 有两个超参数：\n",
    "  - 空间大小：$F$\n",
    "  - 步长：$S$\n",
    "- 输出数据体尺寸：$W_{2} \\cdot H_{2} \\cdot D_{2}$，其中\n",
    "  - $W_{2}=\\left(W_{1}-F\\right) / S+1$\n",
    "  - $H_{2}=\\left(H_{1}-F\\right) / S+1$\n",
    "  - $D_{2}=D_{1}$\n",
    "- 因为对输入进行的是固定函数计算，所以没有引入参数\n",
    "- 在汇聚层中很少使用零填充\n",
    "\n",
    "在实践中，最大汇聚层通常只有两种形式：一种是 $F = 3, S = 2$，也叫重叠汇聚（overlapping pooling），另一个更常用的是 $F = 2, S = 2$。对更大感受野进行汇聚需要的汇聚尺寸也更大，而且往往对网络有破坏性。\n",
    "\n",
    "**普通汇聚（General Pooling）：** 除了最大汇聚，汇聚单元还可以使用其他的函数，比如：平均汇聚（average pooling）或 $L2$ **范式汇聚（L2-norm pooling）**。平均汇聚历史上比较常用，但是现在已经很少使用了。因为实践证明，最大汇聚的效果比平均汇聚要好。\n",
    "\n",
    "![](./img/7_22.jpg)\n",
    "\n",
    "*汇聚层在输入数据体的每个深度切片上，独立地对其进行空间上的降采样。左边：本例中，输入数据体尺寸 `[224x224x64]` 被降采样到了 `[112x112x64]`，采取的滤波器尺寸是 `2`，步长为 `2`，而深度不变。右边：最常用的降采样操作是取最大值，也就是最大汇聚，这里步长为 `2`，每个取最大值操作是从 4 个数字中选取（即 `2x2` 的方块区域中）。*\n",
    "\n",
    "**反向传播：** 回顾一下反向传播的内容，其中 $max(x, y)$ 函数的反向传播可以简单理解为将梯度只沿最大的数回传。因此，在向前传播经过汇聚层的时候，通常会把池中最大元素的索引记录下来（有时这个也叫作：**道岔（switches）**），这样在反向传播的时候梯度的路由就很高效。\n",
    "\n",
    "**不使用汇聚层：** 很多人不喜欢汇聚操作，认为可以不使用它。比如在 [Striving for Simplicity: The All Convolutional Net](https://link.zhihu.com/?target=http%3A//arxiv.org/abs/1412.6806) 一文中，提出使用一种只有重复的卷积层组成的结构，抛弃汇聚层。通过在卷积层中使用更大的步长来降低数据体的尺寸。有发现认为，在训练一个良好的生成模型时，弃用汇聚层也是很重要的。比如变化自编码器（VAEs：variational autoencoders）和生成性对抗网络（GANs：generative adversarial networks）。现在看起来，未来的卷积网络结构中，可能会很少使用甚至不使用汇聚层。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 归一化层 ( Normalization Layer )\n",
    "\n",
    "在卷积神经网络的结构中，提出了很多不同类型的归一化层，有时候是为了实现在生物大脑中观测到的抑制机制。但是这些层渐渐都不再流行，因为实践证明它们的效果即使存在，也是极其有限的。对于不同类型的归一化层，可以看看 Alex Krizhevsky 的关于 [cuda-convnet library API](https://link.zhihu.com/?target=https%3A//code.google.com/p/cuda-convnet/wiki/LayerParams%23Local_response_normalization_layer_%28same_map%29) 的讨论。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 全连接层 ( Fully-connected layer )\n",
    "\n",
    "在全连接层中，神经元对于前一层中的所有激活数据是全部连接的，这个常规神经网络中一样。它们的激活可以先用矩阵乘法，再加上偏差。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 全连接层转化成卷积层\n",
    "\n",
    "全连接层和卷积层之间唯一的不同就是卷积层中的神经元只与输入数据中的一个局部区域连接，并且在卷积列中的神经元共享参数。然而在两类层中，神经元都是计算点积，所以它们的函数形式是一样的。因此，将此两者相互转化是可能的：\n",
    "\n",
    "- 对于任一个卷积层，都存在一个能实现和它一样的前向传播函数的全连接层。权重矩阵是一个巨大的矩阵，除了某些特定块（这是因为有局部连接），其余部分都是零。而在其中大部分块中，元素都是相等的（因为参数共享）。\n",
    "- 相反，任何全连接层都可以被转化为卷积层。比如，一个 $K = 4096$ 的全连接层，输入数据体的尺寸是 $7 x 7 x 512$，这个全连接层可以被等效地看做一个 $F = 7, P = 0, S = 1, K = 4096$ 的卷积层。换句话说，就是将滤波器的尺寸设置为和输入数据体的尺寸一致了。因为只有一个单独的深度列覆盖并滑过输入数据体，所以输出将变成 $1 x 1 x 4096$，这个结果就和使用初始的那个全连接层一样了。\n",
    "\n",
    "在两种变换中，将全连接层转化为卷积层在实际运用中更加有用。假设一个卷积神经网络的输入是 `224x224x3` 的图像，一系列的卷积层和汇聚层将图像数据变为尺寸为 `7x7x512` 的激活数据体（在 AlexNet 中就是这样，通过使用5个汇聚层来对输入数据进行空间上的降采样，每次尺寸下降一半，所以最终空间尺寸为 `224/2/2/2/2/2=7`）。从这里可以看到，AlexNet 使用了两个尺寸为 `4096` 的全连接层，最后一个有 `1000` 个神经元的全连接层用于计算分类评分。我们可以将这 3 个全连接层中的任意一个转化为卷积层：\n",
    "\n",
    "- 针对第一个连接区域是 `[7x7x512]` 的全连接层，令其滤波器尺寸为 $F = 7$，这样输出数据体就为 `[1x1x4096]` 了。\n",
    "- 针对第二个全连接层，令其滤波器尺寸为 $F = 1$，这样输出数据体为 `[1x1x4096]`。\n",
    "- 对最后一个全连接层也做类似的，令其 $F = 1$，最终输出为 `[1x1x1000]`。\n",
    "\n",
    "实际操作中，每次这样的变换都需要把全连接层的权重 $W$ 重塑成卷积层的滤波器。那么这样的转化有什么作用呢？它在下面的情况下可以更高效：让卷积网络在一张更大的输入图片上滑动（*注：即把一张更大的图片的不同区域都分别带入到卷积网络，得到每个区域的得分*），得到多个输出，这样的转化可以让我们在单个向前传播的过程中完成上述的操作。\n",
    "\n",
    "举个例子，如果我们想让 `224x224` 尺寸的浮窗，以步长为 `32` 在 `384x384` 的图片上滑动，把每个经停的位置都带入卷积网络，最后得到 `6x6` 个位置的类别得分。上述的把全连接层转换成卷积层的做法会更简便。如果 `224x224` 的输入图片经过卷积层和汇聚层之后得到了 `[7x7x512]` 的数组，那么，`384x384` 的大图片直接经过同样的卷积层和汇聚层之后会得到 `[12x12x512]` 的数组（因为途径 5 个汇聚层，尺寸变为 `384/2/2/2/2/2 = 12`）。然后再经过上面由 3 个全连接层转化得到的 3 个卷积层，最终得到 `[6x6x1000]` 的输出（因为 `(12 - 7)/1 + 1 = 6` ）。这个结果正是浮窗在原图经停的 `6x6` 个位置的得分！\n",
    "\n",
    "> 面对 `384x384` 的图像，让（含全连接层）的初始卷积神经网络以 32 像素的步长独立对图像中的 `224x224` 块进行多次评价，其效果和使用把全连接层变换为卷积层后的卷积神经网络进行一次前向传播是一样的。\n",
    "\n",
    "自然，相较于使用被转化前的原始卷积神经网络对所有36个位置进行迭代计算，使用转化后的卷积神经网络进行一次前向传播计算要高效得多，因为 36 次计算都在共享计算资源。这一技巧在实践中经常使用，一次来获得更好的结果。比如，通常将一张图像尺寸变得更大，然后使用变换后的卷积神经网络来对空间上很多不同位置进行评价得到分类评分，然后在求这些分值的平均值。\n",
    "\n",
    "最后，如果我们想用步长小于 32 的浮窗怎么办？用多次的向前传播就可以解决。比如我们想用步长为 `16` 的浮窗。那么先使用原图在转化后的卷积网络执行向前传播，然后分别沿宽度，沿高度，最后同时沿宽度和高度，把原始图片分别平移 `16` 个像素，然后把这些平移之后的图分别带入卷积网络。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 卷积神经网络结构详解\n",
    "\n",
    "卷积神经网络通常是由三种层构成：卷积层，汇聚层（除非特别说明，一般就是最大值汇聚）和全连接层（简称 FC）。ReLU 激活函数也应该算是是一层，它逐元素地进行激活函数操作。我们将讨论在卷积神经网络中这些层通常是如何组合在一起的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 层的排列规律\n",
    "\n",
    "卷积神经网络最常见的形式就是将一些卷积层和 ReLU 层放在一起，其后紧跟汇聚层，然后重复如此直到图像在空间上被缩小到一个足够小的尺寸，在某个地方过渡成成全连接层也较为常见。最后的全连接层得到输出，比如分类评分等。换句话说，最常见的卷积神经网络结构如下：\n",
    "\n",
    "`INPUT -> [[CONV -> RELU]*N -> POOL?]*M -> [FC -> RELU]*K -> FC`\n",
    "\n",
    "其中，`*` 指的是重复次数，`POOL?` 指的是一个可选的汇聚层。其中 `N >= 0`，通常 `N <= 3,M >= 0,K >= 0`,通常 `K<3`。例如，下面是一些常见的网络结构规律：\n",
    "\n",
    "- `INPUT -> FC`, 实现一个线性分类器，此处 `N = M = K = 0`。\n",
    "- `INPUT -> CONV -> RELU -> FC`\n",
    "- `INPUT -> [CONV -> RELU -> POOL]*2 -> FC -> RELU -> FC`。此处在每个汇聚层之间有一个卷积层。\n",
    "- `INPUT -> [CONV -> RELU -> CONV -> RELU -> POOL]*3 -> [FC -> RELU]*2 -> FC`。此处每个汇聚层前有两个卷积层，这个思路适用于更大更深的网络，因为在执行具有破坏性的汇聚操作前，多重的卷积层可以从输入数据中学习到更多的复杂特征。\n",
    "\n",
    "**几个小滤波器卷积层的组合比一个大滤波器卷积层好：**\n",
    "\n",
    "假设你一层一层地重叠了 3 个 `3x3` 的卷积层（层与层之间有非线性激活函数）。在这个排列下，第一个卷积层中的每个神经元都对输入数据体有一个 `3x3` 的视野。第二个卷积层上的神经元对第一个卷积层有一个 `3x3` 的视野，也就是对输入数据体有 `5x5` 的视野。同样，在第三个卷积层上的神经元对第二个卷积层有 `3x3` 的视野，也就是对输入数据体有 `7x7` 的视野。假设不采用这 3 个 `3x3` 的卷积层，二是使用一个单独的有 `7x7` 的感受野的卷积层，那么所有神经元的感受野也是 `7x7`，但是就有一些缺点。首先，多个卷积层与非线性的激活层交替的结构，比单一卷积层的结构更能提取出深层的更好的特征。其次，假设所有的数据有 $C$ 个通道，那么单独的 `7x7` 卷积层将会包含 $C \\times(7 \\times 7 \\times C)=49 C^{2}$ 个参数，而 3 个 `3x3` 的卷积层的组合仅有 $3 \\times(C \\times(3 \\times 3 \\times C))=27 C^{2}$ 个参数。直观说来，最好选择带有小滤波器的卷积层组合，而不是用一个带有大的滤波器的卷积层。前者可以表达出输入数据中更多个强力特征，使用的参数也更少。唯一的不足是，在进行反向传播时，中间的卷积层可能会导致占用更多的内存。\n",
    "\n",
    "**最新进展：** 传统的将层按照线性进行排列的方法已经受到了挑战，挑战来自谷歌的 Inception 结构和微软亚洲研究院的残差网络（Residual Net）结构。这两个网络（下文案例学习小节中有细节）的特征更加复杂，连接结构也不同。\n",
    "\n",
    "**实践经验：** 实践中：使用 ImageNet 上最合适的方法。如果你在考虑架构决策时感到困惑，那么实际上在 90％ 或更多的应用程序中，你都不必担心这些。 大部分情况下，你没必要研究自己的体系结构来解决问题，而应查看 ImageNet 上当前最有效的体系结构，下载经过预训练的模型并在数据上进行微调，而不需要从头开始训练 ConvNet 或从头开始设计一个 ConvNet。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 层的尺寸设置规律\n",
    "\n",
    "到现在为止，我们都没有提及卷积神经网络中每层的超参数的使用。现在先介绍设置结构尺寸的一般性规则，然后根据这些规则进行讨论：\n",
    "\n",
    "- 输入层（包含图像的）应该能被 2 多次整除。常用数字包括 —— `32`（比如：CIFAR-10），`64`，`96`（比如：STL-10）或 `224`（比如：ImageNet 卷积神经网络），`384` 和 `512`。\n",
    "- 卷积层应该使用小尺寸滤波器（比如 `3x3` 或最多 `5x5`），使用步长 $S = 1$。还有一点非常重要，就是对输入数据进行零填充，这样卷积层就不会改变输入数据在空间维度上的尺寸。比如，当 $F = 3$，那就使用 $P = 1$ 来保持输入尺寸。当 $F = 5, P = 2$，一般对于任意 $F$，当 $P=(F−1)/2$ 的时候能保持输入尺寸。如果必须使用更大的滤波器尺寸（比如 `7x7` 之类），通常只用在第一个面对原始图像的卷积层上。\n",
    "- 汇聚层负责对输入数据的空间维度进行降采样。最常用的设置是用用 `2x2` 感受野（即 $F = 2$）的最大值汇聚，步长为 2（$S = 2$）。注意这一操作将会把输入数据中 75% 的激活数据丢弃（因为对宽度和高度都进行了 `2` 的降采样）。另一个不那么常用的设置是使用 `3x3` 的感受野，步长为 `2`。最大值汇聚的感受野尺寸很少有超过 `3` 的，因为汇聚操作过于激烈，易造成数据信息丢失，这通常会导致算法性能变差。\n",
    "\n",
    "**减少尺寸设置的问题：** 上文中展示的两种设置是很好的，因为所有的卷积层都能保持其输入数据的空间尺寸，汇聚层只负责对数据体从空间维度进行降采样。如果使用的步长大于 `1` 并且不对卷积层的输入数据使用零填充，那么就必须非常仔细地监督输入数据体通过整个卷积神经网络结构的过程，确认所有的步长和滤波器都尺寸互相吻合，卷积神经网络的结构美妙对称地联系在一起。\n",
    "\n",
    "**为什么在卷积层使用1的步长？** 在实际应用中，更小的步长效果更好。上文也已经提过，步长为 `1` 可以让空间维度的降采样全部由汇聚层负责，卷积层只负责对输入数据体的深度进行变换。\n",
    "\n",
    "**为何使用零填充？** 使用零填充除了前面提到的可以让卷积层的输出数据保持和输入数据在空间维度的不变，还可以提高算法性能。如果卷积层值进行卷积而不进行零填充，那么数据体的尺寸就会略微减小，那么图像边缘的信息就会过快地损失掉。\n",
    "\n",
    "**因为内存限制所做的妥协：** 在某些案例（尤其是早期的卷积神经网络结构）中，基于前面的各种规则，内存的使用量迅速飙升。例如，使用 64 个尺寸为 `3x3` 的滤波器对 `224x224x3` 的图像进行卷积，零填充为 `1`，得到的激活数据体尺寸是 `[224x224x64]`。这个数量就是一千万的激活数据，或者就是 72MB 的内存（每张图就是这么多，激活函数和梯度都是）。因为 GPU 通常因为内存导致性能瓶颈，所以做出一些妥协是必须的。在实践中，人们倾向于在网络的第一个卷积层做出妥协。例如，可以妥协可能是在第一个卷积层使用步长为 `2`，尺寸为 `7x7` 的滤波器（比如在 ZFnet 中）。在 AlexNet 中，滤波器的尺寸是 `11x11`，步长为 `4`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 著名的神经网络结构\n",
    "\n",
    "下面是卷积神经网络领域中比较有名的几种结构：\n",
    "\n",
    "<img src=\"img/8_22.jpg\" width=\"60%\">\n",
    "\n",
    "*上图可见，当前深度计算机视觉的判断失误率已低于人类的误判率*\n",
    "\n",
    "- **LeNet：** 第一个成功的卷积神经网络应用，是 Yann LeCun 在上世纪 90 年代实现的。当然，最著名还是被应用在识别数字和邮政编码等的 [LeNet](http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf) 结构。\n",
    "- **AlexNet：** AlexNet 卷积神经网络在计算机视觉领域中受到欢迎，它由 Alex Krizhevsky，Ilya Sutskever 和 Geoff Hinton 实现。[AlexNet](http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks) 在 2012 年的 ImageNet ILSVRC 竞赛中夺冠，性能远远超出第二名（AlexNet 是 16% 的 top5 错误率，而第二名是 26% 的 top5 错误率）。这个网络的结构和 LeNet 非常类似，但是更深更大，并且使用了层叠的卷积层来获取特征（之前通常是只用一个卷积层并且在其后马上跟着一个汇聚层）。\n",
    "- **ZF Net：** Matthew Zeiler 和 Rob Fergus 发明的网络在 ILSVRC 2013 比赛中夺冠，它被称为 [ZFNet](http://arxiv.org/abs/1311.2901)（Zeiler & Fergus Net 的简称）。它通过修改结构中的超参数来实现对 AlexNet 的改良，具体说来就是增加了中间卷积层的尺寸，让第一层的步长和滤波器尺寸更小。\n",
    "- **GoogLeNet：** ILSVRC 2014 的胜利者是谷歌的 Szeged 等实现的卷积神经网络。它主要的贡献就是实现了一个奠基模块，它能够显著地减少网络中参数的数量（AlexNet 中有 60M，该网络中只有 4M）。还有，这个论文中没有使用卷积神经网络顶部使用全连接层，而是使用了一个平均汇聚，把大量不是很重要的参数都去除掉了。GooLeNet 还有几种改进的版本，最新的一个是 [Inception-v4](http://arxiv.org/abs/1602.07261)。\n",
    "- **VGGNet：** ILSVRC 2014 的第二名是 Karen Simonyan 和 Andrew Zisserman 实现的卷积神经网络，现在称其为 [VGGNet](http://www.robots.ox.ac.uk/~vgg/research/very_deep/)。它主要的贡献是展示出网络的深度是算法优良性能的关键部分。他们最好的网络包含了 16 个卷积/全连接层。网络的结构非常一致，从头到尾全部使用的是 `3x3` 的卷积和 `2x2` 的汇聚。他们的预训练模型是可以在网络上获得并在 Caffe 中使用的。VGGNet 不好的一点是它耗费更多计算资源，并且使用了更多的参数，导致更多的内存占用（140M）。其中绝大多数的参数都是来自于第一个全连接层。后来发现这些全连接层即使被去除，对于性能也没有什么影响，这样就显著降低了参数数量。\n",
    "- **ResNet：** [残差网络](http://arxiv.org/abs/1512.03385)（Residual Network）是 ILSVRC2015 的胜利者，由何恺明等人实现。它使用了特殊的跳跃链接，大量使用了[批量归一化](http://arxiv.org/abs/1502.03167)（`batch normalization`）。这个结构同样在最后没有使用全连接层。\n",
    "\n",
    "**VGGNet 的细节：** 我们进一步对 VGGNet 的细节进行分析学习。整个 VGGNet 中的卷积层都是以步长为 `1` 进行 `3x3` 的卷积，使用了 `1` 的零填充，汇聚层都是以步长为 `2` 进行了 `2x2` 的最大值汇聚。可以写出处理过程中每一步数据体尺寸的变化，然后对数据尺寸和整体权重的数量进行查看：\n",
    "\n",
    "```\n",
    "INPUT: [224x224x3]        memory:  224*224*3=150K   weights: 0\n",
    "CONV3-64: [224x224x64]  memory:  224*224*64=3.2M   weights: (3*3*3)*64 = 1,728\n",
    "CONV3-64: [224x224x64]  memory:  224*224*64=3.2M   weights: (3*3*64)*64 = 36,864\n",
    "POOL2: [112x112x64]  memory:  112*112*64=800K   weights: 0\n",
    "CONV3-128: [112x112x128]  memory:  112*112*128=1.6M   weights: (3*3*64)*128 = 73,728\n",
    "CONV3-128: [112x112x128]  memory:  112*112*128=1.6M   weights: (3*3*128)*128 = 147,456\n",
    "POOL2: [56x56x128]  memory:  56*56*128=400K   weights: 0\n",
    "CONV3-256: [56x56x256]  memory:  56*56*256=800K   weights: (3*3*128)*256 = 294,912\n",
    "CONV3-256: [56x56x256]  memory:  56*56*256=800K   weights: (3*3*256)*256 = 589,824\n",
    "CONV3-256: [56x56x256]  memory:  56*56*256=800K   weights: (3*3*256)*256 = 589,824\n",
    "POOL2: [28x28x256]  memory:  28*28*256=200K   weights: 0\n",
    "CONV3-512: [28x28x512]  memory:  28*28*512=400K   weights: (3*3*256)*512 = 1,179,648\n",
    "CONV3-512: [28x28x512]  memory:  28*28*512=400K   weights: (3*3*512)*512 = 2,359,296\n",
    "CONV3-512: [28x28x512]  memory:  28*28*512=400K   weights: (3*3*512)*512 = 2,359,296\n",
    "POOL2: [14x14x512]  memory:  14*14*512=100K   weights: 0\n",
    "CONV3-512: [14x14x512]  memory:  14*14*512=100K   weights: (3*3*512)*512 = 2,359,296\n",
    "CONV3-512: [14x14x512]  memory:  14*14*512=100K   weights: (3*3*512)*512 = 2,359,296\n",
    "CONV3-512: [14x14x512]  memory:  14*14*512=100K   weights: (3*3*512)*512 = 2,359,296\n",
    "POOL2: [7x7x512]  memory:  7*7*512=25K  weights: 0\n",
    "FC: [1x1x4096]  memory:  4096  weights: 7*7*512*4096 = 102,760,448\n",
    "FC: [1x1x4096]  memory:  4096  weights: 4096*4096 = 16,777,216\n",
    "FC: [1x1x1000]  memory:  1000 weights: 4096*1000 = 4,096,000\n",
    "\n",
    "TOTAL memory: 24M * 4 bytes ~= 93MB / image (only forward! ~*2 for bwd)\n",
    "TOTAL params: 138M parameters\n",
    "```\n",
    "\n",
    "注意，大部分的内存和计算时间都被前面的卷积层占用，大部分的参数都用在后面的全连接层，这在卷积神经网络中是比较常见的。在这个例子中，全部参数有 140M，但第一个全连接层就包含了 100M 的参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 计算资源评估\n",
    "\n",
    "在构建卷积神经网络结构时，最大的瓶颈是内存瓶颈。要注意三种内存占用来源：\n",
    "\n",
    "- 来自中间数据体尺寸：卷积神经网络中的每一层中都有激活数据体的原始数值，以及损失函数对它们的梯度（和激活数据体尺寸一致）。通常，大部分激活数据都是在网络中靠前的层中（比如第一个卷积层）。在训练时，这些数据需要放在内存中，因为反向传播的时候还会用到。但是在测试时可以聪明点：让网络在测试运行时候每层都只存储当前的激活数据，然后丢弃前面层的激活数据，这样就能减少巨大的激活数据量。\n",
    "- 来自参数尺寸：即整个网络的参数的数量，在反向传播时它们的梯度值，以及使用 momentum、Adagrad 或 RMSProp 等方法进行最优化时的每一步计算缓存。因此，存储参数向量的内存通常需要在参数向量的容量基础上乘以 3 或者更多。\n",
    "- 卷积神经网络实现还有各种零散的内存占用，比如：成批的训练数据，扩充的数据等等。\n",
    "\n",
    "一旦对于所有这些数值的数量有了一个大略估计（包含激活数据，梯度和各种杂项），数量应该转化为以 `GB` 为计量单位。把这个值乘以 4，得到原始的字节数（因为每个浮点数占用 `4` 个字节，如果是双精度浮点数那就是占用 `8` 个字节），然后多次除以 `1024` 分别得到占用内存的 `KB`，`MB`，最后是 `GB` 计量。如果你的网络工作得不好，一个常用的方法是降低 **批尺寸（batch size）**，因为绝大多数的内存都是被激活数据消耗掉了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 实验目标\n",
    "\n",
    "本实验中，我们在不使用任何框架的前提下，实现基本的卷积神经网络。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  1. 导入库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys, os \n",
    "import numpy as np\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 加载数据\n",
    "\n",
    "MNIST 是 TensorFlow 的内置数据集，直接从框架中导入即可。\n",
    "\n",
    "```keras.datasets.mnist.load_data()```\n",
    "\n",
    "但由于需要从互联网上下载，连接可能不稳定，我们直接下载到本地，使用下面的代码进行加载。\n",
    "\n",
    "与之前实验一样，训练集与测试据依然是 60000 张 / 10000 张 `28*28` 像素图片。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# (x_train_origin,t_train_origin),(x_test_origin,t_test_origin) = tf.keras.datasets.mnist.load_data()\n",
    "base_path = os.environ.get(\"BATH_PATH\",'./data/')\n",
    "data_path = os.path.join(base_path + \"lab22/\")\n",
    "result_path = \"result/\"\n",
    "os.makedirs(result_path, exist_ok=True)\n",
    "path = data_path+'mnist.npz'\n",
    "\n",
    "f = np.load(path)\n",
    "x_train_origin, t_train_origin = f['x_train'], f['y_train']\n",
    "x_test_origin, t_test_origin = f['x_test'], f['y_test']\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1 定义标签编码函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_hot_label(y):\n",
    "    one_hot_label = np.zeros((y.shape[0],10))\n",
    "    y = y.reshape(y.shape[0])\n",
    "    one_hot_label[range(y.shape[0]),y] = 1\n",
    "    return one_hot_label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2 切分训练集和测试集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of x_train is :(60000, 1, 28, 28)\n",
      "shape of t_train is :(60000, 10)\n",
      "shape of x_test is :(10000, 1, 28, 28)\n",
      "shape of t_test is :(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "X_train = x_train_origin/255.0\n",
    "X_test = x_test_origin/255.0\n",
    "\n",
    "m,h,w = x_train_origin.shape\n",
    "X_train = X_train.reshape((m,1,h,w))\n",
    "y_train = one_hot_label(t_train_origin)\n",
    "\n",
    "m,h,w = x_test_origin.shape\n",
    "X_test = X_test.reshape((m,1,h,w))\n",
    "y_test = one_hot_label(t_test_origin)\n",
    "\n",
    "print(\"shape of x_train is :\"+repr(X_train.shape))\n",
    "print(\"shape of t_train is :\"+repr(y_train.shape))\n",
    "print(\"shape of x_test is :\"+repr(X_test.shape))\n",
    "print(\"shape of t_test is :\"+repr(y_test.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3 显示图像"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y is:5\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "index = 0\n",
    "plt.imshow(X_train[index].reshape((28,28)),cmap = plt.cm.gray)\n",
    "print(\"y is:\"+str(np.argmax(y_train[index])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. 定义数据预处理函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1 定义输入数据转换为二维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def im2col2(input_data,fh,fw,stride=1,pad=0):\n",
    "    '''\n",
    "     Arguments:     \n",
    "     input_data--输入数据，shape为(Number of example,Channel,Height,Width)\n",
    "     fh -- 滤波器的height\n",
    "     fw --滤波器的width\n",
    "     stride -- 步幅\n",
    "     pad -- 填充\n",
    "     \n",
    "     Returns :\n",
    "     col -- 输入数据根据滤波器、步幅等展开的二维数组，每一行代表一条卷积数据\n",
    "    '''\n",
    "    N,C,H,W = input_data.shape\n",
    "    \n",
    "    out_h = (H + 2*pad - fh)//stride+1\n",
    "    out_w = (W+2*pad-fw)//stride+1\n",
    "    \n",
    "    img = np.pad(input_data,[(0,0),(0,0),(pad,pad),(pad,pad)],\"constant\")    \n",
    "    col = np.zeros((N,out_h,out_w,fh*fw*C))\n",
    "    \n",
    "    #将所有维度上需要卷积的值展开成一列\n",
    "    for y in range(out_h):\n",
    "        y_start = y * stride\n",
    "        y_end =  y_start + fh\n",
    "        for x in range(out_w):\n",
    "            x_start = x*stride\n",
    "            x_end = x_start+fw\n",
    "            col[:,y,x] = img[:,:,y_start:y_end,x_start:x_end].reshape(N,-1)\n",
    "    col = col.reshape(N*out_h*out_w,-1)\n",
    "    return col"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2 将二维数组转成 image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def col2im2(col,out_shape,fh,fw,stride=1,pad=0):\n",
    "    '''\n",
    "     Arguments:\n",
    "     col: 二维数组     \n",
    "     out_shape-- 输出的shape，shape为(Number of example,Channel,Height,Width)\n",
    "     fh -- 滤波器的height\n",
    "     fw --滤波器的width\n",
    "     stride -- 步幅\n",
    "     pad -- 填充\n",
    "     \n",
    "     Returns :\n",
    "     img -- 将col转换成的img ，shape为out_shape\n",
    "    '''\n",
    "    N,C,H,W = out_shape    \n",
    "    col_m,col_n = col.shape\n",
    "    \n",
    "    out_h = (H + 2*pad - fh)//stride+1\n",
    "    out_w = (W+2*pad-fw)//stride+1\n",
    "\n",
    "    img = np.zeros((N, C, H , W))\n",
    "\n",
    "    #将col转换成一个filter\n",
    "    for c in range(C):\n",
    "        for y in range(out_h):\n",
    "            for x in range(out_w):\n",
    "                col_index = (c*out_h*out_w)+y*out_w+x\n",
    "                ih = y*stride\n",
    "                iw =  x*stride\n",
    "                img[:,c,ih:ih+fh,iw:iw+fw] = col[col_index].reshape((fh,fw))\n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def im2col2test():\n",
    "    a = np.random.randint(0,5,size=(2,3,4,4))\n",
    "    c = im2col2(a,2,2,2,1)\n",
    "\n",
    "    a = np.random.randint(0,5,size=(1,1,3,3))\n",
    "    print(a)\n",
    "    c = im2col2(a,2,2,1,0)\n",
    "    print(c)\n",
    "    col2im2(c,out_shape=(1,1,3,3),fh=2,fw=2,stride=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. 定义神经网络参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1 定义激活函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def relu(input_X):\n",
    "    \n",
    "    A = np.where(input_X < 0 ,0,input_X)\n",
    "    return A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax(input_X):\n",
    "\n",
    "    exp_a = np.exp(input_X)\n",
    "    sum_exp_a = np.sum(exp_a,axis=1)\n",
    "    sum_exp_a = sum_exp_a.reshape(input_X.shape[0],-1)\n",
    "    ret = exp_a/sum_exp_a\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.2 定义损失函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cross_entropy_error(labels,logits):\n",
    "    return -np.sum(labels*np.log(logits))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 定义卷积神经网络基础层"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1 定义卷积层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Convolution:\n",
    "    def __init__(self,W,fb,stride = 1,pad = 0):\n",
    "        \"\"\"\n",
    "        W-- 滤波器权重，shape为(FN,NC,FH,FW),FN 为滤波器的个数\n",
    "        fb -- 滤波器的偏置，shape 为(1,FN) \n",
    "        stride -- 步长\n",
    "        pad -- 填充个数\n",
    "        \"\"\"\n",
    "        self.W = W\n",
    "        self.fb  = fb  \n",
    "        self.stride = stride\n",
    "        self.pad = pad\n",
    "        \n",
    "        \n",
    "        self.col_X = None\n",
    "        self.X = None\n",
    "        self.col_W = None\n",
    "        \n",
    "        self.dW = None\n",
    "        self.db = None\n",
    "        self.out_shape = None\n",
    "        \n",
    "    def forward (self ,input_X):\n",
    "        \"\"\"\n",
    "        input_X-- shape为(m,nc,height,width)\n",
    "        \"\"\"   \n",
    "        self.X = input_X\n",
    "        FN,NC,FH,FW = self.W.shape\n",
    "        \n",
    "        m,input_nc, input_h,input_w = self.X.shape\n",
    "    \n",
    "        #先计算输出的height和widt\n",
    "        out_h = int((input_h+2*self.pad-FH)/self.stride + 1)\n",
    "        out_w = int((input_w+2*self.pad-FW)/self.stride + 1)\n",
    "    \n",
    "        #将输入数据展开成二维数组，shape为（m*out_h*out_w,FH*FW*C)\n",
    "        self.col_X = col_X = im2col2(self.X,FH,FW,self.stride,self.pad)\n",
    "        \n",
    "        #将滤波器一个个按列展开(FH*FW*C,FN)\n",
    "        self.col_W = col_W = self.W.reshape(FN,-1).T\n",
    "        out = np.dot(col_X,col_W)+self.fb\n",
    "        out = out.T\n",
    "        out = out.reshape(m,FN,out_h,out_w)\n",
    "        self.out_shape = out.shape\n",
    "        return out\n",
    "    \n",
    "    def backward(self, dz,learning_rate):\n",
    "\n",
    "        assert(dz.shape == self.out_shape)\n",
    "    \n",
    "        FN,NC,FH,FW = self.W.shape\n",
    "        o_FN,o_NC,o_FH,o_FW = self.out_shape\n",
    "        \n",
    "        col_dz  = dz.reshape(o_NC,-1)\n",
    "        col_dz = col_dz.T\n",
    "        \n",
    "        self.dW = np.dot(self.col_X.T,col_dz)  #shape is (FH*FW*C,FN)\n",
    "        self.db = np.sum(col_dz,axis=0,keepdims=True)\n",
    "\n",
    "        \n",
    "        self.dW = self.dW.T.reshape(self.W.shape)\n",
    "        self.db = self.db.reshape(self.fb.shape)\n",
    "        \n",
    "    \n",
    "        d_col_x = np.dot(col_dz,self.col_W.T) #shape is (m*out_h*out_w,FH,FW*C)\n",
    "        dx = col2im2(d_col_x,self.X.shape,FH,FW,stride=1)\n",
    "        \n",
    "        assert(dx.shape == self.X.shape)\n",
    "        \n",
    "        #更新W和b\n",
    "        self.W = self.W - learning_rate*self.dW\n",
    "        self.fb = self.fb -learning_rate*self.db\n",
    "        \n",
    "        return dx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2 定义汇聚层 (池化层）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pooling:\n",
    "    def __init__(self,pool_h,pool_w,stride = 1,pad = 0):\n",
    "        self.pool_h = pool_h\n",
    "        self.pool_w = pool_w\n",
    "        self.stride = stride\n",
    "        self.pad = pad \n",
    "        self.X = None\n",
    "        self.arg_max = None\n",
    "        \n",
    "    def forward ( self,input_X) :\n",
    "        \"\"\"\n",
    "        前向传播\n",
    "        input_X-- shape为(m,nc,height,width)\n",
    "        \"\"\"  \n",
    "        self.X = input_X\n",
    "        N , C, H, W = input_X.shape\n",
    "        out_h = int(1+(H-self.pool_h)/self.stride)\n",
    "        out_w = int(1+(W-self.pool_w)/self.stride)\n",
    "        \n",
    "        #展开\n",
    "        col = im2col2(input_X,self.pool_h,self.pool_w,self.stride,self.pad)\n",
    "        col = col.reshape(-1,self.pool_h*self.pool_w)\n",
    "        arg_max = np.argmax(col,axis=1)\n",
    "        #最大值\n",
    "        out = np.max(col,axis=1)\n",
    "        out =out.T.reshape(N,C,out_h,out_w)\n",
    "        self.arg_max = arg_max\n",
    "        return out\n",
    "    \n",
    "    def backward(self ,dz):\n",
    "        \"\"\"\n",
    "        反向传播\n",
    "        Arguments:\n",
    "        dz-- out的导数，shape与out 一致\n",
    "        \n",
    "        Return:\n",
    "        返回前向传播是的input_X的导数\n",
    "        \"\"\" \n",
    "        pool_size = self.pool_h*self.pool_w\n",
    "        dmax = np.zeros((dz.size,pool_size))\n",
    "        dmax[np.arange(self.arg_max.size),self.arg_max.flatten()] = dz.flatten()\n",
    "        \n",
    "        dx = col2im2(dmax,out_shape=self.X.shape,fh=self.pool_h,fw=self.pool_w,stride=self.stride)\n",
    "        return dx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.3 定义 ReLu 层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Relu:\n",
    "    def __init__(self):\n",
    "        self.mask = None\n",
    "        \n",
    "    def forward(self ,X):\n",
    "        self.mask = X <= 0\n",
    "        out = X\n",
    "        out[self.mask] = 0\n",
    "        return out\n",
    "    \n",
    "    def backward(self,dz):\n",
    "        dz[self.mask] = 0\n",
    "        dx = dz \n",
    "        return dx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.4 定义 softmax 层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SoftMax:\n",
    "    def __init__ (self):\n",
    "        self.y_hat = None\n",
    "        \n",
    "    def forward(self,X):\n",
    "        \n",
    "        self.y_hat = softmax(X)\n",
    "        return self.y_hat\n",
    "    \n",
    "    def backward(self,labels):\n",
    "        m = labels.shape[0]\n",
    "        dx = (self.y_hat - labels)\n",
    "        \n",
    "        return dx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(logits,label):\n",
    "    return cross_entropy_error(label,logits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.4 定义全连接层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Affine:\n",
    "    def __init__(self,W,b):\n",
    "        # shape is (n_x,n_unit)\n",
    "        self.W = W \n",
    "        # shape is(1,n_unit)\n",
    "        self.b  = b  \n",
    "        self.X = None\n",
    "        self.origin_x_shape = None        \n",
    "        self.dW = None\n",
    "        self.db = None        \n",
    "        self.out_shape =None\n",
    "        \n",
    "    def forward(self,X):\n",
    "        self.origin_x_shape = X.shape \n",
    "        self.X = X.reshape(X.shape[0],-1)#(m,n)\n",
    "        out =  np.dot(self.X, self.W)+self.b\n",
    "        self.out_shape = out.shape\n",
    "        return out\n",
    "    \n",
    "    def backward(self,dz,learning_rate):\n",
    "        \"\"\"\n",
    "        dz-- 前面的导数\n",
    "        \"\"\"     \n",
    "        assert(dz.shape == self.out_shape)\n",
    "        \n",
    "        m = self.X.shape[0]\n",
    "        \n",
    "        self.dW = np.dot(self.X.T,dz)/m\n",
    "        self.db = np.sum(dz,axis=0,keepdims=True)/m\n",
    "        \n",
    "        assert(self.dW.shape == self.W.shape)\n",
    "        assert(self.db.shape == self.b.shape)\n",
    "        \n",
    "        dx = np.dot(dz,self.W.T)\n",
    "        assert(dx.shape == self.X.shape)\n",
    "        \n",
    "        # 保持与之前的x一样的shape\n",
    "        dx = dx.reshape(self.origin_x_shape) \n",
    "        \n",
    "        #更新W和b\n",
    "        self.W = self.W-learning_rate*self.dW\n",
    "        self.b = self.b - learning_rate*self.db\n",
    "        \n",
    "        return dx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. 组合卷积神经网络结构"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleConvNet:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.X = None\n",
    "        self.Y= None\n",
    "        self.layers = []\n",
    "\n",
    "    def add_conv_layer(self,n_filter,n_c , f, stride=1, pad=0):\n",
    "        \"\"\"\n",
    "        添加一层卷积层\n",
    "        Arguments:\n",
    "        n_c -- 输入数据通道数，也即卷积层的通道数\n",
    "        n_filter -- 滤波器的个数\n",
    "        f --滤波器的长/宽\n",
    "\n",
    "        Return :\n",
    "        Conv -- 卷积层\n",
    "        \"\"\"\n",
    "\n",
    "        # 初始化W，b\n",
    "        W = np.random.randn(n_filter, n_c, f, f)*0.01\n",
    "        fb = np.zeros((1, n_filter))\n",
    "        # 卷积层\n",
    "        Conv = Convolution(W, fb, stride=stride, pad=pad)\n",
    "        return Conv\n",
    "\n",
    "    def add_maxpool_layer(self, pool_shape, stride=1, pad=0):\n",
    "        \"\"\"\n",
    "        添加一层池化层\n",
    "        Arguments:\n",
    "        pool_shape -- 滤波器的shape\n",
    "        f -- 滤波器大小\n",
    "        Return :\n",
    "         Pool -- 初始化的Pool类\n",
    "        \"\"\"\n",
    "        pool_h, pool_w = pool_shape\n",
    "        pool = Pooling(pool_h, pool_w, stride=stride, pad=pad)\n",
    "        \n",
    "        return pool\n",
    "    \n",
    "    def add_affine(self,n_x, n_units):\n",
    "        \"\"\"\n",
    "        添加一层全连接层\n",
    "        Arguments:\n",
    "        n_x -- 输入个数\n",
    "        n_units -- 神经元个数\n",
    "        Return :\n",
    "        fc_layer -- Affine层对象\n",
    "        \"\"\"\n",
    "        \n",
    "        W= np.random.randn(n_x, n_units)*0.01\n",
    "        \n",
    "        b = np.zeros((1, n_units))\n",
    "        \n",
    "        fc_layer = Affine(W,b)\n",
    "        \n",
    "        return fc_layer\n",
    "    \n",
    "    def add_relu(self):\n",
    "        relu_layer =  Relu()\n",
    "        return relu_layer\n",
    "       \n",
    "    def add_softmax(self):\n",
    "        softmax_layer = SoftMax()\n",
    "        return softmax_layer\n",
    "    \n",
    "    #计算卷积或池化后的H和W\n",
    "    def cacl_out_hw(self,HW,f,stride = 1,pad = 0):\n",
    "        return (HW+2*pad - f)/stride+1  \n",
    "    \n",
    "    def init_model(self,train_X,n_classes):\n",
    "        \"\"\"\n",
    "        初始化一个卷积层网络\n",
    "        \"\"\"\n",
    "        N,C,H,W = train_X.shape\n",
    "        #卷积层\n",
    "        n_filter = 4\n",
    "        f = 7\n",
    "        \n",
    "        conv_layer = self.add_conv_layer(n_filter= n_filter,n_c=C,f=f,stride=1)\n",
    "        \n",
    "        out_h = self.cacl_out_hw(H,f)\n",
    "        out_w = self.cacl_out_hw(W,f)\n",
    "        out_ch = n_filter\n",
    "        \n",
    "        self.layers.append(conv_layer)\n",
    "        \n",
    "        #Relu\n",
    "        relu_layer = self.add_relu()\n",
    "        self.layers.append(relu_layer)\n",
    "        \n",
    "        #池化\n",
    "        f = 2\n",
    "        pool_layer = self.add_maxpool_layer(pool_shape=(f,f),stride=2)\n",
    "        out_h = self.cacl_out_hw(out_h,f,stride=2)\n",
    "        out_w = self.cacl_out_hw(out_w,f,stride=2)\n",
    "        #out_ch 不改变\n",
    "        self.layers.append(pool_layer)        \n",
    "        \n",
    "        #Affine层\n",
    "        n_x = int(out_h*out_w*out_ch)\n",
    "        n_units = 32\n",
    "        fc_layer = self.add_affine(n_x=n_x,n_units=n_units)\n",
    "        self.layers.append(fc_layer)\n",
    "        \n",
    "        #Relu\n",
    "        relu_layer = self.add_relu()\n",
    "        self.layers.append(relu_layer)\n",
    "        \n",
    "        #Affine\n",
    "        fc_layer = self.add_affine(n_x=n_units,n_units=n_classes)\n",
    "        self.layers.append(fc_layer)\n",
    "        \n",
    "        #SoftMax\n",
    "        softmax_layer = self.add_softmax()\n",
    "        self.layers.append(softmax_layer)\n",
    "              \n",
    "    def forward_progation(self,train_X, print_out = False):\n",
    "        \"\"\"\n",
    "        前向传播\n",
    "        Arguments:\n",
    "        train_X -- 训练数据\n",
    "        f -- 滤波器大小\n",
    "\n",
    "        Return :\n",
    "         Z-- 前向传播的结果\n",
    "         loss -- 损失值\n",
    "        \"\"\"           \n",
    "        N,C,H,W = train_X.shape\n",
    "        index = 0\n",
    "        # 卷积层\n",
    "        conv_layer = self.layers[index]\n",
    "        X = conv_layer.forward(train_X)\n",
    "        index =index+1\n",
    "        if print_out:\n",
    "            print(\"卷积之后：\"+str(X.shape))\n",
    "        # Relu\n",
    "        relu_layer =  self.layers[index]\n",
    "        index =index+1\n",
    "        X = relu_layer.forward(X)\n",
    "        if print_out:\n",
    "            print(\"Relu：\"+str(X.shape))\n",
    "                    \n",
    "        # 池化层\n",
    "        pool_layer = self.layers[index]\n",
    "        index =index+1\n",
    "        X = pool_layer.forward(X)\n",
    "        if print_out:\n",
    "            print(\"池化：\"+str(X.shape))\n",
    "\n",
    "        # Affine层\n",
    "        fc_layer = self.layers[index]\n",
    "        index =index+1\n",
    "        X = fc_layer.forward(X)\n",
    "        if print_out:\n",
    "            print(\"Affline 层的X：\"+str(X.shape))\n",
    "\n",
    "        # Relu\n",
    "        relu_layer = self.layers[index]\n",
    "        index =index+1\n",
    "        X = relu_layer.forward(X)\n",
    "        if print_out:\n",
    "            print(\"Relu 层的X：\"+str(X.shape))\n",
    "        \n",
    "        # Affine层\n",
    "        fc_layer = self.layers[index]\n",
    "        index =index+1\n",
    "        X = fc_layer.forward(X)\n",
    "        if print_out:\n",
    "            print(\"Affline 层的X：\"+str(X.shape))\n",
    "\n",
    "        # SoftMax层\n",
    "        sofmax_layer = self.layers[index]\n",
    "        index =index+1\n",
    "        A = sofmax_layer.forward(X)\n",
    "        if print_out:\n",
    "            print(\"Softmax 层的X：\"+str(A.shape))\n",
    "            \n",
    "        return A\n",
    "        \n",
    "    def back_progation(self,train_y,learning_rate):\n",
    "        \"\"\"\n",
    "        反向传播\n",
    "        Arguments:\n",
    "   \n",
    "        \"\"\"\n",
    "        index = len(self.layers)-1\n",
    "        sofmax_layer = self.layers[index]\n",
    "        index -= 1\n",
    "        dz = sofmax_layer.backward(train_y)\n",
    "        \n",
    "        fc_layer = self.layers[index]\n",
    "        dz = fc_layer.backward(dz,learning_rate=learning_rate)\n",
    "        index -= 1\n",
    "        \n",
    "        relu_layer = self.layers[index]\n",
    "        dz = relu_layer.backward(dz)\n",
    "        index -= 1\n",
    "        \n",
    "        fc_layer = self.layers[index]\n",
    "        dz = fc_layer.backward(dz,learning_rate=learning_rate)\n",
    "        index -= 1\n",
    "        \n",
    "        pool_layer = self.layers[index]\n",
    "        dz = pool_layer.backward(dz)\n",
    "        index -= 1\n",
    "        \n",
    "        relu_layer =  self.layers[index]\n",
    "        dz = relu_layer.backward(dz)\n",
    "        index -= 1\n",
    "        \n",
    "        conv_layer = self.layers[index]\n",
    "        conv_layer.backward(dz,learning_rate=learning_rate)\n",
    "        index -= 1\n",
    "        \n",
    "      \n",
    "    def get_minibatch(self,batch_data,minibatch_size,num):\n",
    "        m_examples = batch_data.shape[0]\n",
    "        minibatches = math.ceil( m_examples / minibatch_size)\n",
    " \n",
    "        if(num < minibatches):\n",
    "            return batch_data[num*minibatch_size:(num+1)*minibatch_size]\n",
    "        else:\n",
    "            return batch_data[num*minibatch_size:m_examples]\n",
    "    \n",
    "    \n",
    "    def optimize(self,train_X, train_y,minibatch_size,learning_rate=0.05,num_iters=500):\n",
    "        \"\"\"\n",
    "        优化方法\n",
    "        Arguments:\n",
    "        train_X -- 训练数据 \n",
    "        train_y -- 训练数据的标签\n",
    "        learning_rate -- 学习率\n",
    "        num_iters -- 迭代次数\n",
    "        minibatch_size \n",
    "        \"\"\"\n",
    "        m = train_X.shape[0]\n",
    "        num_batches  = math.ceil(m / minibatch_size)\n",
    "        \n",
    "        costs = []\n",
    "        for iteration in range(num_iters):\n",
    "            iter_cost = 0\n",
    "            for batch_num in range(num_batches):\n",
    "                minibatch_X = self.get_minibatch(train_X,minibatch_size,batch_num)\n",
    "                minibatch_y = self.get_minibatch(train_y,minibatch_size,batch_num)\n",
    "                \n",
    "                # 前向传播\n",
    "                A = self.forward_progation(minibatch_X,print_out=False)\n",
    "                #损失:\n",
    "                cost = compute_cost (A,minibatch_y)\n",
    "                #反向传播\n",
    "                self.back_progation(minibatch_y,learning_rate)\n",
    "                if(iteration%100 == 0):\n",
    "                    iter_cost += cost/num_batches\n",
    "                    \n",
    "            if(iteration%100 == 0):\n",
    "                print(\"After %d iters ,cost is :%g\" %(iteration,iter_cost))\n",
    "                costs.append(iter_cost)\n",
    "                        \n",
    "        #画出损失函数图\n",
    "        plt.plot(costs)\n",
    "        plt.xlabel(\"iterations/hundreds\")\n",
    "        plt.ylabel(\"costs\")\n",
    "        plt.show()\n",
    "        \n",
    "       \n",
    "    def predicate(self, train_X):\n",
    "        \"\"\"\n",
    "        预测\n",
    "        \"\"\"\n",
    "        logits = self.forward_progation(train_X)\n",
    "        one_hot = np.zeros_like(logits)\n",
    "        one_hot[range(train_X.shape[0]),np.argmax(logits,axis=1)] = 1\n",
    "        return one_hot   \n",
    "\n",
    "    def fit(self,train_X, train_y):\n",
    "        \"\"\"\n",
    "        训练\n",
    "        \"\"\"\n",
    "        self.X = train_X\n",
    "        self.Y = train_y\n",
    "        n_y = train_y.shape[1]\n",
    "        m = train_X.shape[0]\n",
    "        \n",
    "        #初始化模型\n",
    "        self.init_model(train_X,n_classes=n_y)\n",
    "\n",
    "        self.optimize(train_X, train_y,minibatch_size=10,learning_rate=0.05,num_iters=800)\n",
    "        \n",
    "        logits = self.predicate(train_X)\n",
    "        \n",
    "        accuracy = np.sum(np.argmax(logits,axis=1) == np.argmax(train_y,axis=1))/m\n",
    "        print(\"训练集的准确率为：%g\" %(accuracy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. 训练卷积神经网络模型\n",
    "\n",
    "> **训练预计需要 5 分钟，请耐心等待。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After 0 iters ,cost is :23.0262\n",
      "After 100 iters ,cost is :20.5606\n",
      "After 200 iters ,cost is :19.0754\n",
      "After 300 iters ,cost is :6.12289\n",
      "After 400 iters ,cost is :5.53925\n",
      "After 500 iters ,cost is :6.51583\n",
      "After 600 iters ,cost is :7.60763\n",
      "After 700 iters ,cost is :7.23506\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集的准确率为：0.6\n"
     ]
    }
   ],
   "source": [
    "convNet = SimpleConvNet()\n",
    "\n",
    "#取前10张图片先做实验\n",
    "train_X = X_train[0:10]\n",
    "train_y = y_train[0:10]\n",
    "convNet.fit(train_X,train_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. 卷积神经网络模型验证"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练的准确率为：0.6\n"
     ]
    }
   ],
   "source": [
    "logits = convNet.predicate(X_train[0:10])\n",
    "m = 10\n",
    "accuracy = np.sum(np.argmax(logits,axis=1) == np.argmax(y_train[0:10],axis=1))/m\n",
    "print(\"训练的准确率为：%g\" %(accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "图像标签是: 5\n",
      "你的模型预测结果是: 5\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvFvnyVgAADgdJREFUeJzt3X9sXfV5x/HPs9D8QRoIXjUTpWFpIhQUIuZOJkwoGkXM5YeCggGhWkLKRBT3j1ii0hQNZX8MNAVFg2RqBKrsqqHJ1KWZBCghqpp0CZBOTBEmhF9mKQylqi2TFAWTH/zIHD/74x53Lvh+r3Pvufdc+3m/JMv3nuecex4d5ZPz8/pr7i4A8fxJ0Q0AKAbhB4Ii/EBQhB8IivADQRF+ICjCDwRF+IGgCD8Q1GWNXJmZ8TghUGfublOZr6Y9v5ndYWbHzex9M3ukls8C0FhW7bP9ZjZL0m8kdUgalPSqpC53H0gsw54fqLNG7PlXSHrf3T9w9wuSfi5pdQ2fB6CBagn/Akm/m/B+MJv2R8ys28z6zay/hnUByFndL/i5e5+kPonDfqCZ1LLnH5K0cML7b2bTAEwDtYT/VUnXmtm3zGy2pO9J2ptPWwDqrerDfncfNbMeSfslzZK03d3fya0zAHVV9a2+qlbGOT9Qdw15yAfA9EX4gaAIPxAU4QeCIvxAUIQfCIrwA0ERfiAowg8ERfiBoAg/EBThB4Ii/EBQhB8IivADQRF+ICjCDwRF+IGgCD8QFOEHgiL8QFCEHwiK8ANBEX4gKMIPBEX4gaAIPxAU4QeCIvxAUFUP0S1JZnZC0llJFyWNunt7Hk0hP7NmzUrWr7zyyrquv6enp2zt8ssvTy67dOnSZH39+vXJ+pNPPlm21tXVlVz2888/T9Y3b96crD/22GPJejOoKfyZW939oxw+B0ADcdgPBFVr+F3SATN7zcy682gIQGPUeti/0t2HzOzPJP3KzP7b3Q9PnCH7T4H/GIAmU9Oe392Hst+nJD0vacUk8/S5ezsXA4HmUnX4zWyOmc0dfy3pu5LezqsxAPVVy2F/q6TnzWz8c/7N3X+ZS1cA6q7q8Lv7B5L+IsdeZqxrrrkmWZ89e3ayfvPNNyfrK1euLFubN29ectn77rsvWS/S4OBgsr5t27ZkvbOzs2zt7NmzyWXfeOONZP3ll19O1qcDbvUBQRF+ICjCDwRF+IGgCD8QFOEHgjJ3b9zKzBq3sgZqa2tL1g8dOpSs1/trtc1qbGwsWX/ooYeS9XPnzlW97uHh4WT9448/TtaPHz9e9brrzd1tKvOx5weCIvxAUIQfCIrwA0ERfiAowg8ERfiBoLjPn4OWlpZk/ciRI8n64sWL82wnV5V6HxkZSdZvvfXWsrULFy4kl436/EOtuM8PIInwA0ERfiAowg8ERfiBoAg/EBThB4LKY5Te8E6fPp2sb9iwIVlftWpVsv76668n65X+hHXKsWPHkvWOjo5k/fz588n69ddfX7b28MMPJ5dFfbHnB4Ii/EBQhB8IivADQRF+ICjCDwRF+IGgKn6f38y2S1ol6ZS7L8+mtUjaLWmRpBOSHnD39B8618z9Pn+trrjiimS90nDSvb29ZWtr165NLvvggw8m67t27UrW0Xzy/D7/TyXd8aVpj0g66O7XSjqYvQcwjVQMv7sflvTlR9hWS9qRvd4h6Z6c+wJQZ9We87e6+/h4Rx9Kas2pHwANUvOz/e7uqXN5M+uW1F3regDkq9o9/0kzmy9J2e9T5WZ09z53b3f39irXBaAOqg3/XklrstdrJO3Jpx0AjVIx/Ga2S9J/SVpqZoNmtlbSZkkdZvaepL/J3gOYRiqe87t7V5nSbTn3EtaZM2dqWv6TTz6petl169Yl67t3707Wx8bGql43isUTfkBQhB8IivADQRF+ICjCDwRF+IGgGKJ7BpgzZ07Z2gsvvJBc9pZbbknW77zzzmT9wIEDyToajyG6ASQRfiAowg8ERfiBoAg/EBThB4Ii/EBQ3Oef4ZYsWZKsHz16NFkfGRlJ1l988cVkvb+/v2zt6aefTi7byH+bMwn3+QEkEX4gKMIPBEX4gaAIPxAU4QeCIvxAUNznD66zszNZf+aZZ5L1uXPnVr3ujRs3Jus7d+5M1oeHh5P1qLjPDyCJ8ANBEX4gKMIPBEX4gaAIPxAU4QeCqnif38y2S1ol6ZS7L8+mPSppnaTfZ7NtdPdfVFwZ9/mnneXLlyfrW7duTdZvu636kdx7e3uT9U2bNiXrQ0NDVa97OsvzPv9PJd0xyfR/cfe27Kdi8AE0l4rhd/fDkk43oBcADVTLOX+Pmb1pZtvN7KrcOgLQENWG/0eSlkhqkzQsaUu5Gc2s28z6zaz8H3MD0HBVhd/dT7r7RXcfk/RjSSsS8/a5e7u7t1fbJID8VRV+M5s/4W2npLfzaQdAo1xWaQYz2yXpO5K+YWaDkv5R0nfMrE2SSzoh6ft17BFAHfB9ftRk3rx5yfrdd99dtlbpbwWYpW9XHzp0KFnv6OhI1mcqvs8PIInwA0ERfiAowg8ERfiBoAg/EBS3+lCYL774Ilm/7LL0Yyijo6PJ+u2331629tJLLyWXnc641QcgifADQRF+ICjCDwRF+IGgCD8QFOEHgqr4fX7EdsMNNyTr999/f7J+4403lq1Vuo9fycDAQLJ++PDhmj5/pmPPDwRF+IGgCD8QFOEHgiL8QFCEHwiK8ANBcZ9/hlu6dGmy3tPTk6zfe++9yfrVV199yT1N1cWLF5P14eHhZH1sbCzPdmYc9vxAUIQfCIrwA0ERfiAowg8ERfiBoAg/EFTF+/xmtlDSTkmtklxSn7v/0MxaJO2WtEjSCUkPuPvH9Ws1rkr30ru6usrWKt3HX7RoUTUt5aK/vz9Z37RpU7K+d+/ePNsJZyp7/lFJf+fuyyT9laT1ZrZM0iOSDrr7tZIOZu8BTBMVw+/uw+5+NHt9VtK7khZIWi1pRzbbDkn31KtJAPm7pHN+M1sk6duSjkhqdffx5ys/VOm0AMA0MeVn+83s65KelfQDdz9j9v/Dgbm7lxuHz8y6JXXX2iiAfE1pz29mX1Mp+D9z9+eyySfNbH5Wny/p1GTLunufu7e7e3seDQPIR8XwW2kX/xNJ77r71gmlvZLWZK/XSNqTf3sA6qXiEN1mtlLSryW9JWn8O5IbVTrv/3dJ10j6rUq3+k5X+KyQQ3S3tqYvhyxbtixZf+qpp5L166677pJ7ysuRI0eS9SeeeKJsbc+e9P6Cr+RWZ6pDdFc853f3/5RU7sNuu5SmADQPnvADgiL8QFCEHwiK8ANBEX4gKMIPBMWf7p6ilpaWsrXe3t7ksm1tbcn64sWLq+opD6+88kqyvmXLlmR9//79yfpnn312yT2hMdjzA0ERfiAowg8ERfiBoAg/EBThB4Ii/EBQYe7z33TTTcn6hg0bkvUVK1aUrS1YsKCqnvLy6aeflq1t27Ytuezjjz+erJ8/f76qntD82PMDQRF+ICjCDwRF+IGgCD8QFOEHgiL8QFBh7vN3dnbWVK/FwMBAsr5v375kfXR0NFlPfed+ZGQkuSziYs8PBEX4gaAIPxAU4QeCIvxAUIQfCIrwA0GZu6dnMFsoaaekVkkuqc/df2hmj0paJ+n32awb3f0XFT4rvTIANXN3m8p8Uwn/fEnz3f2omc2V9JqkeyQ9IOmcuz851aYIP1B/Uw1/xSf83H1Y0nD2+qyZvSup2D9dA6Bml3TOb2aLJH1b0pFsUo+ZvWlm283sqjLLdJtZv5n119QpgFxVPOz/w4xmX5f0sqRN7v6cmbVK+kil6wD/pNKpwUMVPoPDfqDOcjvnlyQz+5qkfZL2u/vWSeqLJO1z9+UVPofwA3U21fBXPOw3M5P0E0nvTgx+diFwXKekty+1SQDFmcrV/pWSfi3pLUlj2eSNkroktal02H9C0vezi4Opz2LPD9RZrof9eSH8QP3ldtgPYGYi/EBQhB8IivADQRF+ICjCDwRF+IGgCD8QFOEHgiL8QFCEHwiK8ANBEX4gKMIPBNXoIbo/kvTbCe+/kU1rRs3aW7P2JdFbtfLs7c+nOmNDv8//lZWb9bt7e2ENJDRrb83al0Rv1SqqNw77gaAIPxBU0eHvK3j9Kc3aW7P2JdFbtQrprdBzfgDFKXrPD6AghYTfzO4ws+Nm9r6ZPVJED+WY2Qkze8vMjhU9xFg2DNopM3t7wrQWM/uVmb2X/Z50mLSCenvUzIaybXfMzO4qqLeFZvaimQ2Y2Ttm9nA2vdBtl+irkO3W8MN+M5sl6TeSOiQNSnpVUpe7DzS0kTLM7ISkdncv/J6wmf21pHOSdo6PhmRm/yzptLtvzv7jvMrd/75JentUlzhyc516Kzey9N+qwG2X54jXeShiz79C0vvu/oG7X5D0c0mrC+ij6bn7YUmnvzR5taQd2esdKv3jabgyvTUFdx9296PZ67OSxkeWLnTbJfoqRBHhXyDpdxPeD6q5hvx2SQfM7DUz6y66mUm0ThgZ6UNJrUU2M4mKIzc30pdGlm6abVfNiNd544LfV61097+UdKek9dnhbVPy0jlbM92u+ZGkJSoN4zYsaUuRzWQjSz8r6QfufmZirchtN0lfhWy3IsI/JGnhhPffzKY1BXcfyn6fkvS8SqcpzeTk+CCp2e9TBffzB+5+0t0vuvuYpB+rwG2XjSz9rKSfuftz2eTCt91kfRW13YoI/6uSrjWzb5nZbEnfk7S3gD6+wszmZBdiZGZzJH1XzTf68F5Ja7LXayTtKbCXP9IsIzeXG1laBW+7phvx2t0b/iPpLpWu+P+PpH8ooocyfS2W9Eb2807RvUnapdJh4P+qdG1kraQ/lXRQ0nuS/kNSSxP19q8qjeb8pkpBm19QbytVOqR/U9Kx7Oeuorddoq9CthtP+AFBccEPCIrwA0ERfiAowg8ERfiBoAg/EBThB4Ii/EBQ/weCC5r/92q6mAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用第一张图片进行测试\n",
    "index = 0\n",
    "plt.imshow(X_train[index].reshape((28,28)),cmap = plt.cm.gray)\n",
    "print(\"图像标签是: \"+str(np.argmax(y_train[index])))\n",
    "print(\"你的模型预测结果是: \"+str(np.argmax(logits[index])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 实验小结\n",
    "\n",
    "作为本单元小结，在本实验中，我们详细的讨论了卷积神经网络的各种核心概念。之后，通过纯 Python 代码，展示了如何实现相关深度学习核心概念，并且从头构建一个深度学习卷积神经网络。本实验目标仅在于展示完整的卷积神经网络的构建及基础代码实现。很明显，无论从结果还是 MNIST 的基准 (Benchmark) 当前的网络存在大量可以优化和调整的空间 —— 这将留给你来实现！\n",
    "\n",
    "![](./img/cnn_car.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}