extra_capsnets-cn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 胶囊网络(CapsNets) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "基于论文：[Dynamic Routing Between Capsules](https://arxiv.org/abs/1710.09829)，作者：Sara Sabour, Nicholas Frosst and Geoffrey E. Hinton (NIPS 2017)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "部分启发来自于Huadong Liao的实现[CapsNet-TensorFlow](https://github.com/naturomics/CapsNet-Tensorflow)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 简介"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "观看 [视频](https://youtu.be/pPN8d0E3900)来理解胶囊网络背后的关键想法（大家可能看不到，因为youtube被墙了）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/pPN8d0E3900\" frameborder=\"0\" allowfullscreen></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import HTML\n",
    "HTML(\"\"\"<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/pPN8d0E3900\" frameborder=\"0\" allowfullscreen></iframe>\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你或许也需要观看[视频](https://youtu.be/2Kawrd5szHE)，其展示了这个notebook的难点（大家可能看不到，因为youtube被墙了）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/2Kawrd5szHE\" frameborder=\"0\" allowfullscreen></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML(\"\"\"<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/2Kawrd5szHE\" frameborder=\"0\" allowfullscreen></iframe>\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同时支持 Python 2 和 Python 3："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division, print_function, unicode_literals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了绘制好看的图："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们会用到 NumPy 和 TensorFlow："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 可重复性"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了能够在不重新启动Jupyter Notebook Kernel的情况下重新运行本notebook，我们需要重置默认的计算图。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.reset_default_graph()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "设置随机种子，以便于本notebook总是可以输出相同的输出："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "tf.set_random_seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 装载MNIST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "是的，我知道，又是MNIST。但我们希望这个极具威力的想法可以工作在更大的数据集上，时间会说明一切。（译注：因为是Hinton吗，因为他老是对;-)？）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting /tmp/data/train-images-idx3-ubyte.gz\n",
      "Extracting /tmp/data/train-labels-idx1-ubyte.gz\n",
      "Extracting /tmp/data/t10k-images-idx3-ubyte.gz\n",
      "Extracting /tmp/data/t10k-labels-idx1-ubyte.gz\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "\n",
    "mnist = input_data.read_data_sets(\"/tmp/data/\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "让我们看一下这些手写数字图像是什么样的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1e4ea31ac8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_samples = 5\n",
    "\n",
    "plt.figure(figsize=(n_samples * 2, 3))\n",
    "for index in range(n_samples):\n",
    "    plt.subplot(1, n_samples, index + 1)\n",
    "    sample_image = mnist.train.images[index].reshape(28, 28)\n",
    "    plt.imshow(sample_image, cmap=\"binary\")\n",
    "    plt.axis(\"off\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以及相应的标签："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 3, 4, 6, 1], dtype=uint8)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnist.train.labels[:n_samples]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们建立一个胶囊网络来区分这些图像。这里有一个其总体的架构，享受一下ASCII字符的艺术吧! ;-)\n",
    "注意：为了可读性，我摒弃了两种箭头：标签 → 掩盖，以及 输入的图像 → 重新构造损失。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "                            损 失\n",
    "                              ↑\n",
    "                    ┌─────────┴─────────┐\n",
    "          标 签 → 边 际 损 失     重 新 构 造 损 失\n",
    "                    ↑                   ↑\n",
    "                  模 长               解 码 器\n",
    "                    ↑                   ↑ \n",
    "             数 字 胶 囊 们  ────遮 盖─────┘\n",
    "               ↖↑↗ ↖↑↗ ↖↑↗\n",
    "                 主 胶 囊 们\n",
    "                    ↑      \n",
    "               输 入 的 图 像\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们打算从底层开始构建该计算图，然后逐步上移，左侧优先。让我们开始！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 输入图像"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "让我们通过为输入图像创建一个占位符作为起步，该输入图像具有28×28个像素，1个颜色通道=灰度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = tf.placeholder(shape=[None, 28, 28, 1], dtype=tf.float32, name=\"X\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 主胶囊"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第一层由32个特征映射组成，每个特征映射为6$\\times$6个胶囊，其中每个胶囊输出8维的激活向量："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "caps1_n_maps = 32\n",
    "caps1_n_caps = caps1_n_maps * 6 * 6  # 1152 主胶囊们\n",
    "caps1_n_dims = 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了计算它们的输出，我们首先应用两个常规的卷积层："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv1_params = {\n",
    "    \"filters\": 256,\n",
    "    \"kernel_size\": 9,\n",
    "    \"strides\": 1,\n",
    "    \"padding\": \"valid\",\n",
    "    \"activation\": tf.nn.relu,\n",
    "}\n",
    "\n",
    "conv2_params = {\n",
    "    \"filters\": caps1_n_maps * caps1_n_dims, # 256 个卷积滤波器\n",
    "    \"kernel_size\": 9,\n",
    "    \"strides\": 2,\n",
    "    \"padding\": \"valid\",\n",
    "    \"activation\": tf.nn.relu\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv1 = tf.layers.conv2d(X, name=\"conv1\", **conv1_params)\n",
    "conv2 = tf.layers.conv2d(conv1, name=\"conv2\", **conv2_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意：由于我们使用一个尺寸为9的核，并且没有使用填充（出于某种原因，这就是`\"valid\"`的含义），该图像每经历一个卷积层就会缩减 $9-1=8$ 个像素（从 $28\\times 28$ 到 $20 \\times 20$，再从 $20\\times 20$ 到 $12\\times 12$），并且由于在第二个卷积层中使用了大小为2的步幅，那么该图像的大小就被除以2。这就是为什么我们最后会得到 $6\\times 6$ 的特征映射（feature map）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接着，我们重塑该输出以获得一组8D向量，用来表示主胶囊的输出。`conv2`的输出是一个数组，包含对于每个实例都有32×8=256个特征映射（feature map），其中每个特征映射为6×6。所以该输出的形状为 (_batch size_, 6, 6, 256)。我们想要把256分到32个8维向量中，可以通过使用重塑 (_batch size_, 6, 6, 32, 8)来达到目的。然而，由于首个胶囊层会被完全连接到下一个胶囊层，那么我们就可以简单地把它扁平成6×6的网格。这意味着我们只需要把它重塑成 (_batch size_, 6×6×32, 8) 即可。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "caps1_raw = tf.reshape(conv2, [-1, caps1_n_caps, caps1_n_dims],\n",
    "                       name=\"caps1_raw\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在我们需要压缩这些向量。让我们来定义`squash()`函数，基于论文中的公式（1）：\n",
    "\n",
    "$\\operatorname{squash}(\\mathbf{s}) = \\dfrac{\\|\\mathbf{s}\\|^2}{1 + \\|\\mathbf{s}\\|^2} \\dfrac{\\mathbf{s}}{\\|\\mathbf{s}\\|}$\n",
    "\n",
    "该`squash()`函数将会压缩所有的向量到给定的数组中，沿给定轴（默认情况为最后一个轴）。\n",
    "\n",
    "**当心**，这里有一个很讨厌的bug在等着你：当 $\\|\\mathbf{s}\\|=0$时，$\\|\\mathbf{s}\\|$ 为 undefined，这让我们不能直接使用 `tf.norm()`，否则会在训练过程中失败：如果一个向量为0，那么梯度就会是 `nan`，所以当优化器更新变量时，这些变量也会变为 `nan`，从那个时刻起，你就止步在 `nan` 那里了。解决的方法是手工实现norm，在计算的时候加上一个很小的值 epsilon：$\\|\\mathbf{s}\\| \\approx \\sqrt{\\sum\\limits_i{{s_i}^2}\\,\\,+ \\epsilon}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def squash(s, axis=-1, epsilon=1e-7, name=None):\n",
    "    with tf.name_scope(name, default_name=\"squash\"):\n",
    "        squared_norm = tf.reduce_sum(tf.square(s), axis=axis,\n",
    "                                     keep_dims=True)\n",
    "        safe_norm = tf.sqrt(squared_norm + epsilon)\n",
    "        squash_factor = squared_norm / (1. + squared_norm)\n",
    "        unit_vector = s / safe_norm\n",
    "        return squash_factor * unit_vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们应用这个函数以获得每个主胶囊$\\mathbf{u}_i$的输出："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "caps1_output = squash(caps1_raw, name=\"caps1_output\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "太棒了！我们有了首个胶囊层的输出了。不是很难，对吗？然后，计算下一层才是真正乐趣的开始（译注：好戏刚刚开始）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 数字胶囊们"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "要计算数字胶囊们的输出，我们必须首先计算预测的输出向量（每个对应一个主胶囊/数字胶囊的对）。接着，我们就可以通过协议算法来运行路由。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 计算预测输出向量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "该数字胶囊层包含10个胶囊（每个代表一个数字），每个胶囊16维："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "caps2_n_caps = 10\n",
    "caps2_n_dims = 16"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于在第一层里的每个胶囊 $i$，我们会在第二层中预测出每个胶囊 $j$ 的输出。为此，我们需要一个变换矩阵 $\\mathbf{W}_{i,j}$（每一对就是胶囊($i$, $j$) 中的一个），接着我们就可以计算预测的输出$\\hat{\\mathbf{u}}_{j|i} = \\mathbf{W}_{i,j} \\, \\mathbf{u}_i$（论文中的公式（2）的右半部分）。由于我们想要将8维向量变形为16维向量，因此每个变换向量$\\mathbf{W}_{i,j}$必须具备(16, 8)形状。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "要为每对胶囊 ($i$, $j$) 计算 $\\hat{\\mathbf{u}}_{j|i}$，我们会利用 `tf.matmul()` 函数的一个特点：你可能知道它可以让你进行两个矩阵相乘，但你可能不知道它可以让你进行更高维度的数组相乘。它将这些数组视作为数组矩阵，并且它会执行每项的矩阵相乘。例如，设有两个4D数组，每个包含2×3网格的矩阵。第一个包含矩阵为：$\\mathbf{A}, \\mathbf{B}, \\mathbf{C}, \\mathbf{D}, \\mathbf{E}, \\mathbf{F}$，第二个包含矩阵为：$\\mathbf{G}, \\mathbf{H}, \\mathbf{I}, \\mathbf{J}, \\mathbf{K}, \\mathbf{L}$。如果你使用 `tf.matmul`函数 对这两个4D数组进行相乘，你就会得到：\n",
    "\n",
    "$\n",
    "\\pmatrix{\n",
    "\\mathbf{A} & \\mathbf{B} & \\mathbf{C} \\\\\n",
    "\\mathbf{D} & \\mathbf{E} & \\mathbf{F}\n",
    "} \\times\n",
    "\\pmatrix{\n",
    "\\mathbf{G} & \\mathbf{H} & \\mathbf{I} \\\\\n",
    "\\mathbf{J} & \\mathbf{K} & \\mathbf{L}\n",
    "} = \\pmatrix{\n",
    "\\mathbf{AG} & \\mathbf{BH} & \\mathbf{CI} \\\\\n",
    "\\mathbf{DJ} & \\mathbf{EK} & \\mathbf{FL}\n",
    "}\n",
    "$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以把这个函数用来计算每对胶囊 ($i$, $j$) 的 $\\hat{\\mathbf{u}}_{j|i}$，就像这样（回忆一下，有 6×6×32=1152 个胶囊在第一层，还有10个在第二层）：\n",
    "\n",
    "$\n",
    "\\pmatrix{\n",
    "  \\mathbf{W}_{1,1} & \\mathbf{W}_{1,2} & \\cdots & \\mathbf{W}_{1,10} \\\\\n",
    "  \\mathbf{W}_{2,1} & \\mathbf{W}_{2,2} & \\cdots & \\mathbf{W}_{2,10} \\\\\n",
    "  \\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "  \\mathbf{W}_{1152,1} & \\mathbf{W}_{1152,2} & \\cdots & \\mathbf{W}_{1152,10}\n",
    "} \\times\n",
    "\\pmatrix{\n",
    "  \\mathbf{u}_1 & \\mathbf{u}_1 & \\cdots & \\mathbf{u}_1 \\\\\n",
    "  \\mathbf{u}_2 & \\mathbf{u}_2 & \\cdots & \\mathbf{u}_2 \\\\\n",
    "  \\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "  \\mathbf{u}_{1152} & \\mathbf{u}_{1152} & \\cdots & \\mathbf{u}_{1152}\n",
    "}\n",
    "=\n",
    "\\pmatrix{\n",
    "\\hat{\\mathbf{u}}_{1|1} & \\hat{\\mathbf{u}}_{2|1} & \\cdots & \\hat{\\mathbf{u}}_{10|1} \\\\\n",
    "\\hat{\\mathbf{u}}_{1|2} & \\hat{\\mathbf{u}}_{2|2} & \\cdots & \\hat{\\mathbf{u}}_{10|2} \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "\\hat{\\mathbf{u}}_{1|1152} & \\hat{\\mathbf{u}}_{2|1152} & \\cdots & \\hat{\\mathbf{u}}_{10|1152}\n",
    "}\n",
    "$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第一个数组的形状为 (1152, 10, 16, 8)，第二个数组的形状为 (1152, 10, 8, 1)。注意到第二个数组必须包含10个对于向量$\\mathbf{u}_1$ 到 $\\mathbf{u}_{1152}$ 的完全拷贝。为了要创建这样的数组，我们将使用好用的 `tf.tile()` 函数，它可以让你创建包含很多基数组拷贝的数组，并且根据你想要的进行平铺。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "哦，稍等！我们还忘了一个维度：_batch size（批量/批次的大小）_。假设我们要给胶囊网络提供50张图片，那么该网络需要同时作出这50张图片的预测。所以第一个数组的形状为 (50, 1152, 10, 16, 8)，而第二个数组的形状为 (50, 1152, 10, 8, 1)。第一层的胶囊实际上已经对于所有的50张图像作出预测，所以第二个数组没有问题，但对于第一个数组，我们需要使用 `tf.tile()` 让其具有50个拷贝的变换矩阵。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "好了，让我们开始，创建一个可训练的变量，形状为 (1, 1152, 10, 16, 8) 可以用来持有所有的变换矩阵。第一个维度的大小为1，可以让这个数组更容易的平铺。我们使用标准差为0.1的常规分布，随机初始化这个变量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "init_sigma = 0.1\n",
    "\n",
    "W_init = tf.random_normal(\n",
    "    shape=(1, caps1_n_caps, caps2_n_caps, caps2_n_dims, caps1_n_dims),\n",
    "    stddev=init_sigma, dtype=tf.float32, name=\"W_init\")\n",
    "W = tf.Variable(W_init, name=\"W\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在我们可以通过每个实例重复一次`W`来创建第一个数组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = tf.shape(X)[0]\n",
    "W_tiled = tf.tile(W, [batch_size, 1, 1, 1, 1], name=\"W_tiled\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "就是这样！现在转到第二个数组。如前所述，我们需要创建一个数组，形状为 (_batch size_, 1152, 10, 8, 1)，包含第一层胶囊的输出，重复10次（一次一个数字，在第三个维度，即axis=2）。 `caps1_output` 数组的形状为 (_batch size_, 1152, 8)，所以我们首先需要展开两次来获得形状 (_batch size_, 1152, 1, 8, 1) 的数组，接着在第三维度重复它10次。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "caps1_output_expanded = tf.expand_dims(caps1_output, -1,\n",
    "                                       name=\"caps1_output_expanded\")\n",
    "caps1_output_tile = tf.expand_dims(caps1_output_expanded, 2,\n",
    "                                   name=\"caps1_output_tile\")\n",
    "caps1_output_tiled = tf.tile(caps1_output_tile, [1, 1, caps2_n_caps, 1, 1],\n",
    "                             name=\"caps1_output_tiled\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "让我们检查以下第一个数组的形状："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'W_tiled:0' shape=(?, 1152, 10, 16, 8) dtype=float32>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "W_tiled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "很好，现在第二个："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'caps1_output_tiled:0' shape=(?, 1152, 10, 8, 1) dtype=float32>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "caps1_output_tiled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "好！现在，为了要获得所有的预测好的输出向量 $\\hat{\\mathbf{u}}_{j|i}$，我们只需要将这两个数组使用`tf.malmul()`函数进行相乘，就像前面解释的那样："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "caps2_predicted = tf.matmul(W_tiled, caps1_output_tiled,\n",
    "                            name=\"caps2_predicted\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "让我们检查一下形状："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'caps2_predicted:0' shape=(?, 1152, 10, 16, 1) dtype=float32>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "caps2_predicted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "非常好，对于在该批次（我们还不知道批次的大小，使用 \"?\" 替代）中的每个实例以及对于每对第一和第二层的胶囊（1152×10），我们都有一个16D预测的输出列向量 (16×1)。我们已经准备好应用 根据协议算法的路由 了！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 根据协议的路由"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先，让我们初始化原始的路由权重 $b_{i,j}$ 到0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_weights = tf.zeros([batch_size, caps1_n_caps, caps2_n_caps, 1, 1],\n",
    "                       dtype=np.float32, name=\"raw_weights\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们马上将会看到为什么我们需要最后两维大小为1的维度。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 第一轮"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先，让我们应用 sofmax 函数来计算路由权重，$\\mathbf{c}_{i} = \\operatorname{softmax}(\\mathbf{b}_i)$ （论文中的公式（3））："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "routing_weights = tf.nn.softmax(raw_weights, dim=2, name=\"routing_weights\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们为每个第二层胶囊计算其预测输出向量的加权，$\\mathbf{s}_j = \\sum\\limits_{i}{c_{i,j}\\hat{\\mathbf{u}}_{j|i}}$ （论文公式（2）的左半部分）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "weighted_predictions = tf.multiply(routing_weights, caps2_predicted,\n",
    "                                   name=\"weighted_predictions\")\n",
    "weighted_sum = tf.reduce_sum(weighted_predictions, axis=1, keep_dims=True,\n",
    "                             name=\"weighted_sum\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里有几个重要的细节需要注意：\n",
    "* 要执行元素级别矩阵相乘（也称为Hadamard积，记作$\\circ$），我们需要使用`tf.multiply()` 函数。它要求  `routing_weights` 和 `caps2_predicted` 具有相同的秩，这就是为什么前面我们在 `routing_weights` 上添加了两个额外的维度。\n",
    "* `routing_weights`的形状为 (_batch size_, 1152, 10, 1, 1) 而 `caps2_predicted` 的形状为 (_batch size_, 1152, 10, 16, 1)。由于它们在第四个维度上不匹配（1 _vs_ 16），`tf.multiply()` 自动地在 `routing_weights` 该维度上 _广播_ 了16次。如果你不熟悉广播，这里有一个简单的例子，也许可以帮上忙：\n",
    "\n",
    "  $ \\pmatrix{1 & 2 & 3 \\\\ 4 & 5 & 6} \\circ \\pmatrix{10 & 100 & 1000} = \\pmatrix{1 & 2 & 3 \\\\ 4 & 5 & 6} \\circ \\pmatrix{10 & 100 & 1000 \\\\ 10 & 100 & 1000} = \\pmatrix{10 & 200 & 3000 \\\\ 40 & 500 & 6000} $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，让我们应用squash函数到在协议算法的第一次迭代迭代结束时获取第二层胶囊的输出上，$\\mathbf{v}_j = \\operatorname{squash}(\\mathbf{s}_j)$："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "caps2_output_round_1 = squash(weighted_sum, axis=-2,\n",
    "                              name=\"caps2_output_round_1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'caps2_output_round_1/mul:0' shape=(?, 1, 10, 16, 1) dtype=float32>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "caps2_output_round_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "好！我们对于每个实例有了10个16D输出向量，就像我们期待的那样。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 第二轮"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先，让我们衡量一下，每个预测向量 $\\hat{\\mathbf{u}}_{j|i}$ 对于实际输出向量 $\\mathbf{v}_j$ 之间到底有多接近，这是通过它们的标量乘积 $\\hat{\\mathbf{u}}_{j|i} \\cdot \\mathbf{v}_j$来完成的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 快速数学上的提示：如果 $\\vec{a}$ and $\\vec{b}$ 是长度相等的向量，并且 $\\mathbf{a}$ 和 $\\mathbf{b}$ 是相应的列向量（如，只有一列的矩阵），那么 $\\mathbf{a}^T \\mathbf{b}$ （即 $\\mathbf{a}$的转置和 $\\mathbf{b}$的矩阵相乘）为一个1×1的矩阵，包含两个向量$\\vec{a}\\cdot\\vec{b}$的标量积。在机器学习中，我们通常将向量表示为列向量，所以当我们探讨关于计算标量积 $\\hat{\\mathbf{u}}_{j|i} \\cdot \\mathbf{v}_j$的时候，其实意味着计算 ${\\hat{\\mathbf{u}}_{j|i}}^T \\mathbf{v}_j$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于我们需要对每个实例和每个第一和第二层的胶囊对$(i, j)$，计算标量积 $\\hat{\\mathbf{u}}_{j|i} \\cdot \\mathbf{v}_j$ ，我们将再次利用`tf.matmul()`可以同时计算多个矩阵相乘的特点。这就要求使用 `tf.tile()`来使得所有维度都匹配（除了倒数第二个），就像我们之前所作的那样。所以让我们查看`caps2_predicted`的形状，因为它持有对每个实例和每个胶囊对的所有预测输出向量$\\hat{\\mathbf{u}}_{j|i}$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'caps2_predicted:0' shape=(?, 1152, 10, 16, 1) dtype=float32>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "caps2_predicted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们查看 `caps2_output_round_1` 的形状，它有10个输出向量，每个16D，对应每个实例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'caps2_output_round_1/mul:0' shape=(?, 1, 10, 16, 1) dtype=float32>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "caps2_output_round_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了让这些形状相匹配，我们只需要在第二个维度平铺 `caps2_output_round_1` 1152次（一次一个主胶囊）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "caps2_output_round_1_tiled = tf.tile(\n",
    "    caps2_output_round_1, [1, caps1_n_caps, 1, 1, 1],\n",
    "    name=\"caps2_output_round_1_tiled\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在我们已经准备好可以调用 `tf.matmul()`（注意还需要告知它在第一个数组中的矩阵进行转置，让${\\hat{\\mathbf{u}}_{j|i}}^T$ 来替代 $\\hat{\\mathbf{u}}_{j|i}$）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "agreement = tf.matmul(caps2_predicted, caps2_output_round_1_tiled,\n",
    "                      transpose_a=True, name=\"agreement\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们现在可以通过对于刚计算的标量积$\\hat{\\mathbf{u}}_{j|i} \\cdot \\mathbf{v}_j$进行简单相加，来进行原始路由权重 $b_{i,j}$ 的更新：$b_{i,j} \\gets b_{i,j} + \\hat{\\mathbf{u}}_{j|i} \\cdot \\mathbf{v}_j$ （参见论文过程1中第7步）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_weights_round_2 = tf.add(raw_weights, agreement,\n",
    "                             name=\"raw_weights_round_2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第二轮的其余部分和第一轮相同："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "routing_weights_round_2 = tf.nn.softmax(raw_weights_round_2,\n",
    "                                        dim=2,\n",
    "                                        name=\"routing_weights_round_2\")\n",
    "weighted_predictions_round_2 = tf.multiply(routing_weights_round_2,\n",
    "                                           caps2_predicted,\n",
    "                                           name=\"weighted_predictions_round_2\")\n",
    "weighted_sum_round_2 = tf.reduce_sum(weighted_predictions_round_2,\n",
    "                                     axis=1, keep_dims=True,\n",
    "                                     name=\"weighted_sum_round_2\")\n",
    "caps2_output_round_2 = squash(weighted_sum_round_2,\n",
    "                              axis=-2,\n",
    "                              name=\"caps2_output_round_2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以继续更多轮，只需要重复第二轮中相同的步骤，但为了保持简洁，我们就到这里："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "caps2_output = caps2_output_round_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 静态还是动态循环？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在上面的代码中，我们在TensorFlow计算图中为协调算法的每一轮路由创建了不同的操作。换句话说，它是一个静态循环。\n",
    "\n",
    "当然，与其拷贝/粘贴这些代码几次，通常在python中，我们可以写一个 `for` 循环，但这不会改变这样一个事实，那就是在计算图中最后对于每个路由迭代都会有不同的操作。这其实是可接受的，因为我们通常不会具有超过5次路由迭代，所以计算图不会成长得太大。\n",
    "\n",
    "然而，你可能更倾向于在TensorFlow计算图自身实现路由循环，而不是使用Python的`for`循环。为了要做到这点，将需要使用TensorFlow的 `tf.while_loop()` 函数。这种方式，所有的路由循环都可以重用在该计算图中的相同的操作，这被称为动态循环。\n",
    "\n",
    "例如，这里是如何构建一个小循环用来计算1到100的平方和："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(328350, 100)\n"
     ]
    }
   ],
   "source": [
    "def condition(input, counter):\n",
    "    return tf.less(counter, 100)\n",
    "\n",
    "def loop_body(input, counter):\n",
    "    output = tf.add(input, tf.square(counter))\n",
    "    return output, tf.add(counter, 1)\n",
    "\n",
    "with tf.name_scope(\"compute_sum_of_squares\"):\n",
    "    counter = tf.constant(1)\n",
    "    sum_of_squares = tf.constant(0)\n",
    "\n",
    "    result = tf.while_loop(condition, loop_body, [sum_of_squares, counter])\n",
    "    \n",
    "\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run(result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如你所见， `tf.while_loop()` 函数期望的循环条件和循环体由两个函数来提供。这些函数仅会被TensorFlow调用一次，在构建计算图阶段，_不_ 在执行计算图的时候。 `tf.while_loop()` 函数将由 `condition()` 和 `loop_body()` 创建的计算图碎片同一些用来创建循环的额外操作缝制在一起。\n",
    "\n",
    "还注意到在训练的过程中，TensorFlow将自动地通过循环处理反向传播，因此你不需要担心这些事情。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然，我们也可以一行代码搞定！;)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum([i**2 for i in range(1, 100 + 1)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "开个玩笑，抛开缩减计算图的大小不说，使用动态循环而不是静态循环能够帮助减少很多的GPU RAM的使用（如果你使用GPU的话）。事实上，如果但调用 `tf.while_loop()` 函数时，你设置了 `swap_memory=True` ，TensorFlow会在每个循环的迭代上自动检查GPU RAM使用情况，并且它会照顾到在GPU和CPU之间swapping内存时的需求。既然CPU的内存便宜量又大，相对GPU RAM而言，这就很有意义了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 估算的分类概率（模长）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "输出向量的模长代表了分类的概率，所以我们就可以使用`tf.norm()`来计算它们，但由于我们在讨论`squash`函数时看到的那样，可能会有风险，所以我们创建了自己的 `safe_norm()` 函数来进行替代："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def safe_norm(s, axis=-1, epsilon=1e-7, keep_dims=False, name=None):\n",
    "    with tf.name_scope(name, default_name=\"safe_norm\"):\n",
    "        squared_norm = tf.reduce_sum(tf.square(s), axis=axis,\n",
    "                                     keep_dims=keep_dims)\n",
    "        return tf.sqrt(squared_norm + epsilon)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_proba = safe_norm(caps2_output, axis=-2, name=\"y_proba\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "要预测每个实例的分类，我们只需要选择那个具有最高估算概率的就可以了。要做到这点，让我们通过使用 `tf.argmax()` 来达到我们的目的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_proba_argmax = tf.argmax(y_proba, axis=2, name=\"y_proba\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "让我们检查一下 `y_proba_argmax` 的形状："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'y_proba_1:0' shape=(?, 1, 1) dtype=int64>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_proba_argmax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这正好是我们想要的：对于每一个实例，我们现在有了最长的输出向量的索引。让我们用 `tf.squeeze()` 来移除后两个大小为1的维度。这就给出了该胶囊网络对于每个实例的预测分类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = tf.squeeze(y_proba_argmax, axis=[1,2], name=\"y_pred\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'y_pred:0' shape=(?,) dtype=int64>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "好了，我们现在准备好开始定义训练操作，从损失开始。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 标签"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先，我们将需要一个对于标签的占位符："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = tf.placeholder(shape=[None], dtype=tf.int64, name=\"y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 边际损失"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "论文使用了一个特殊的边际损失，来使得在每个图像中侦测多于两个以上的数字成为可能：\n",
    "\n",
    "$ L_k = T_k \\max(0, m^{+} - \\|\\mathbf{v}_k\\|)^2 + \\lambda (1 - T_k) \\max(0, \\|\\mathbf{v}_k\\| - m^{-})^2$\n",
    "\n",
    "* $T_k$ 等于1，如果分类$k$的数字出现，否则为0.\n",
    "* 在论文中，$m^{+} = 0.9$, $m^{-} = 0.1$，并且$\\lambda = 0.5$\n",
    "* 注意在视频15:47秒处有个错误：应该是最大化操作，而不是norms，被平方。不好意思。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "m_plus = 0.9\n",
    "m_minus = 0.1\n",
    "lambda_ = 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "既然 `y` 将包含数字分类，从0到9，要对于每个实例和每个分类获取 $T_k$ ，我们只需要使用 `tf.one_hot()` 函数即可："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = tf.one_hot(y, depth=caps2_n_caps, name=\"T\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一个小例子应该可以说明这到底做了什么："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session():\n",
    "    print(T.eval(feed_dict={y: np.array([0, 1, 2, 3, 9])}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们对于每个输出胶囊和每个实例计算输出向量。首先，让我们验证 `caps2_output` 形状："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'caps2_output_round_2/mul:0' shape=(?, 1, 10, 16, 1) dtype=float32>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "caps2_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这些16D向量位于第二到最后的维度，因此让我们在 `axis=-2` 使用 `safe_norm()` 函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "caps2_output_norm = safe_norm(caps2_output, axis=-2, keep_dims=True,\n",
    "                              name=\"caps2_output_norm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们计算 $\\max(0, m^{+} - \\|\\mathbf{v}_k\\|)^2$，并且重塑其结果以获得一个简单的具有形状(_batch size_, 10)的矩阵："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "present_error_raw = tf.square(tf.maximum(0., m_plus - caps2_output_norm),\n",
    "                              name=\"present_error_raw\")\n",
    "present_error = tf.reshape(present_error_raw, shape=(-1, 10),\n",
    "                           name=\"present_error\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来让我们计算 $\\max(0, \\|\\mathbf{v}_k\\| - m^{-})^2$ 并且重塑成(_batch size_,10)："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "absent_error_raw = tf.square(tf.maximum(0., caps2_output_norm - m_minus),\n",
    "                             name=\"absent_error_raw\")\n",
    "absent_error = tf.reshape(absent_error_raw, shape=(-1, 10),\n",
    "                          name=\"absent_error\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们准备好为每个实例和每个数字计算损失："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = tf.add(T * present_error, lambda_ * (1.0 - T) * absent_error,\n",
    "           name=\"L\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在我们可以把对于每个实例的数字损失进行相加($L_0 + L_1 + \\cdots + L_9$)，并且在所有的实例中计算均值。这给予我们最后的边际损失："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "margin_loss = tf.reduce_mean(tf.reduce_sum(L, axis=1), name=\"margin_loss\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 重新构造"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们添加一个解码器网络，其位于胶囊网络之上。它是一个常规的3层全连接神经网络，其将基于胶囊网络的输出，学习重新构建输入图像。这将强制胶囊网络保留所有需要重新构造数字的信息，贯穿整个网络。该约束正则化了模型：它减少了训练数据集过拟合的风险，并且它有助于泛化到新的数字。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 遮盖"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "论文中提及了在训练的过程中，与其发送所有的胶囊网络的输出到解码器网络，不如仅发送与目标数字对应的胶囊输出向量。所有其余输出向量必须被遮盖掉。在推断的时候，我们必须遮盖所有输出向量，除了最长的那个。即，预测的数字相关的那个。你可以查看论文中的图2（视频中的18:15）：所有的输出向量都被遮盖掉了，除了那个重新构造目标的输出向量。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们需要一个占位符来告诉TensorFlow，是否我们想要遮盖这些输出向量，根据标签 (`True`) 或 预测 (`False`, 默认)："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask_with_labels = tf.placeholder_with_default(False, shape=(),\n",
    "                                               name=\"mask_with_labels\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们使用 `tf.cond()` 来定义重新构造的目标，如果 `mask_with_labels` 为 `True` 就是标签 `y`，否则就是 `y_pred`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "reconstruction_targets = tf.cond(mask_with_labels, # 条件\n",
    "                                 lambda: y,        # if True\n",
    "                                 lambda: y_pred,   # if False\n",
    "                                 name=\"reconstruction_targets\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意到 `tf.cond()` 函数期望的是通过函数传递而来的if-True 和 if-False张量：这些函数会在计算图构造阶段（而非执行阶段）被仅调用一次，和`tf.while_loop()`类似。这可以允许TensorFlow添加必要操作，以此处理if-True 和 if-False 张量的条件评估。然而，在这里，张量 `y` 和 `y_pred` 已经在我们调用 `tf.cond()` 时被创建，不幸地是TensorFlow会认为 `y` 和 `y_pred` 是 `reconstruction_targets` 张量的依赖项。虽然，`reconstruction_targets` 张量最终是会计算出正确值，但是：\n",
    "1. 无论何时，我们评估某个依赖于 `reconstruction_targets` 的张量，`y_pred` 张量也会被评估（即便 `mask_with_layers` 为 `True`）。这不是什么大问题，因为，在训练阶段计算`y_pred` 张量不会添加额外的开销，而且不管怎么样我们都需要它来计算边际损失。并且在测试中，如果我们做的是分类，我们就不需要重新构造，所以`reconstruction_grpha`根本不会被评估。\n",
    "2. 我们总是需要为`y`占位符递送一个值（即使`mask_with_layers`为`False`）。这就有点讨厌了，当然我们可以传递一个空数组，因为TensorFlow无论如何都不会用到它（就是当检查依赖项的时候还不知道）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在我们有了重新构建的目标，让我们创建重新构建的遮盖。对于目标类型它应该为1.0，对于其他类型应该为0.0。为此我们就可以使用`tf.one_hot()`函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "reconstruction_mask = tf.one_hot(reconstruction_targets,\n",
    "                                 depth=caps2_n_caps,\n",
    "                                 name=\"reconstruction_mask\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "让我们检查一下 `reconstruction_mask`的形状："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'reconstruction_mask:0' shape=(?, 10) dtype=float32>"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reconstruction_mask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "和 `caps2_output` 的形状比对一下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'caps2_output_round_2/mul:0' shape=(?, 1, 10, 16, 1) dtype=float32>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "caps2_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "嗯，它的形状是 (_batch size_, 1, 10, 16, 1)。我们想要将它和 `reconstruction_mask` 进行相乘，但 `reconstruction_mask`的形状是(_batch size_, 10)。我们必须对此进行reshape成 (_batch size_, 1, 10, 1, 1) 来满足相乘的要求："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "reconstruction_mask_reshaped = tf.reshape(\n",
    "    reconstruction_mask, [-1, 1, caps2_n_caps, 1, 1],\n",
    "    name=\"reconstruction_mask_reshaped\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最终我们可以应用 遮盖 了！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "caps2_output_masked = tf.multiply(\n",
    "    caps2_output, reconstruction_mask_reshaped,\n",
    "    name=\"caps2_output_masked\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'caps2_output_masked:0' shape=(?, 1, 10, 16, 1) dtype=float32>"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "caps2_output_masked"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后还有一个重塑操作被用来扁平化解码器的输入："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "decoder_input = tf.reshape(caps2_output_masked,\n",
    "                           [-1, caps2_n_caps * caps2_n_dims],\n",
    "                           name=\"decoder_input\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这给予我们一个形状是 (_batch size_, 160) 的数组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'decoder_input:0' shape=(?, 160) dtype=float32>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decoder_input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 解码器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们来构建该解码器。它非常简单：两个密集（全连接）ReLU 层紧跟这一个密集输出sigmoid层："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_hidden1 = 512\n",
    "n_hidden2 = 1024\n",
    "n_output = 28 * 28"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope(\"decoder\"):\n",
    "    hidden1 = tf.layers.dense(decoder_input, n_hidden1,\n",
    "                              activation=tf.nn.relu,\n",
    "                              name=\"hidden1\")\n",
    "    hidden2 = tf.layers.dense(hidden1, n_hidden2,\n",
    "                              activation=tf.nn.relu,\n",
    "                              name=\"hidden2\")\n",
    "    decoder_output = tf.layers.dense(hidden2, n_output,\n",
    "                                     activation=tf.nn.sigmoid,\n",
    "                                     name=\"decoder_output\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 重新构造的损失"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们计算重新构造的损失。它不过是输入图像和重新构造过的图像的平方差。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_flat = tf.reshape(X, [-1, n_output], name=\"X_flat\")\n",
    "squared_difference = tf.square(X_flat - decoder_output,\n",
    "                               name=\"squared_difference\")\n",
    "reconstruction_loss = tf.reduce_mean(squared_difference,\n",
    "                                    name=\"reconstruction_loss\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 最终损失"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最终损失为边际损失和重新构造损失（使用放大因子0.0005确保边际损失在训练过程中处于支配地位）的和："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha = 0.0005\n",
    "\n",
    "loss = tf.add(margin_loss, alpha * reconstruction_loss, name=\"loss\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 最后润色"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了衡量模型的精度，我们需要计算实例被正确分类的数量。为此，我们可以简单地比较`y`和`y_pred`，并将比较结果的布尔值转换成float32（0.0代表False，1.0代表True），并且计算所有实例的均值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "correct = tf.equal(y, y_pred, name=\"correct\")\n",
    "accuracy = tf.reduce_mean(tf.cast(correct, tf.float32), name=\"accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "论文中提到作者使用Adam优化器，使用了TensorFlow的默认参数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.train.AdamOptimizer()\n",
    "training_op = optimizer.minimize(loss, name=\"training_op\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 初始化和Saver"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "让我们来添加变量初始器，还要加一个 `Saver`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "init = tf.global_variables_initializer()\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还有... 我们已经完成了构造阶段！花点时间可以庆祝🎉一下。:)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练我们的胶囊网络是非常标准的。为了简化，我们不需要作任何花哨的超参调整、丢弃等，我们只是一遍又一遍运行训练操作，显示损失，并且在每个epoch结束的时候，根据验证集衡量一下精度，显示出来，并且保存模型，当然，验证损失是目前为止最低的模型才会被保存（这是一种基本的实现早停的方法，而不需要实际上打断训练的进程）。我们希望代码能够自释，但这里应该有几个细节值得注意：\n",
    "* 如果某个checkpoint文件已经存在，那么它会被恢复（这可以让训练被打断，再从最新的checkpoint中进行恢复成为可能），\n",
    "* 我们不要忘记在训练的时候传递`mask_with_labels=True`，\n",
    "* 在测试的过程中，我们可以让`mask_with_labels`默认为`False`（但是我们仍然需要传递标签，因为它们在计算精度的时候会被用到），\n",
    "* 通过 `mnist.train.next_batch()`装载的图片会被表示为类型 `float32` 数组，其形状为\\[784\\]，但输入的占位符`X`期望的是一个`float32`数组，其形状为 \\[28, 28, 1\\]，所以在我们把送到模型之前，必须把这些图像进行重塑，\n",
    "* 我们在整个完整的验证集上对模型的损失和精度进行评估。为了能够看到进度和支持那些并没有太多RAM的系统，评估损失和精度的代码在一个批次上执行一次，并且最后再计算平均损失和平均精度。\n",
    "\n",
    "*警告*：如果你没有GPU，训练将会非常漫长（至少几个小时）。当使用GPU，它应该对于每个epoch只需要几分钟（如，在NVidia GeForce GTX 1080Ti上只需要6分钟）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1  Val accuracy: 98.9400%  Loss: 0.015190 (improved)\n",
      "Epoch: 2  Val accuracy: 99.2000%  Loss: 0.010183 (improved)\n",
      "Epoch: 3  Val accuracy: 99.3200%  Loss: 0.008860 (improved)\n",
      "Epoch: 4  Val accuracy: 99.3000%  Loss: 0.007782 (improved)\n",
      "Epoch: 5  Val accuracy: 99.2400%  Loss: 0.008245\n",
      "Epoch: 6  Val accuracy: 99.3200%  Loss: 0.008094\n",
      "Epoch: 7  Val accuracy: 99.3400%  Loss: 0.007472 (improved)\n",
      "Epoch: 8  Val accuracy: 99.3800%  Loss: 0.007024 (improved)\n",
      "Epoch: 9  Val accuracy: 99.2400%  Loss: 0.007232\n",
      "Epoch: 10  Val accuracy: 99.3200%  Loss: 0.007789\n"
     ]
    }
   ],
   "source": [
    "n_epochs = 10\n",
    "batch_size = 50\n",
    "restore_checkpoint = True\n",
    "\n",
    "n_iterations_per_epoch = mnist.train.num_examples // batch_size\n",
    "n_iterations_validation = mnist.validation.num_examples // batch_size\n",
    "best_loss_val = np.infty\n",
    "checkpoint_path = \"./my_capsule_network\"\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    if restore_checkpoint and tf.train.checkpoint_exists(checkpoint_path):\n",
    "        saver.restore(sess, checkpoint_path)\n",
    "    else:\n",
    "        init.run()\n",
    "\n",
    "    for epoch in range(n_epochs):\n",
    "        for iteration in range(1, n_iterations_per_epoch + 1):\n",
    "            X_batch, y_batch = mnist.train.next_batch(batch_size)\n",
    "            # 运行训练操作并且评估损失:\n",
    "            _, loss_train = sess.run(\n",
    "                [training_op, loss],\n",
    "                feed_dict={X: X_batch.reshape([-1, 28, 28, 1]),\n",
    "                           y: y_batch,\n",
    "                           mask_with_labels: True})\n",
    "            print(\"\\rIteration: {}/{} ({:.1f}%)  Loss: {:.5f}\".format(\n",
    "                      iteration, n_iterations_per_epoch,\n",
    "                      iteration * 100 / n_iterations_per_epoch,\n",
    "                      loss_train),\n",
    "                  end=\"\")\n",
    "\n",
    "        # 在每个epoch之后，\n",
    "        # 衡量验证损失和精度：\n",
    "        loss_vals = []\n",
    "        acc_vals = []\n",
    "        for iteration in range(1, n_iterations_validation + 1):\n",
    "            X_batch, y_batch = mnist.validation.next_batch(batch_size)\n",
    "            loss_val, acc_val = sess.run(\n",
    "                    [loss, accuracy],\n",
    "                    feed_dict={X: X_batch.reshape([-1, 28, 28, 1]),\n",
    "                               y: y_batch})\n",
    "            loss_vals.append(loss_val)\n",
    "            acc_vals.append(acc_val)\n",
    "            print(\"\\rEvaluating the model: {}/{} ({:.1f}%)\".format(\n",
    "                      iteration, n_iterations_validation,\n",
    "                      iteration * 100 / n_iterations_validation),\n",
    "                  end=\" \" * 10)\n",
    "        loss_val = np.mean(loss_vals)\n",
    "        acc_val = np.mean(acc_vals)\n",
    "        print(\"\\rEpoch: {}  Val accuracy: {:.4f}%  Loss: {:.6f}{}\".format(\n",
    "            epoch + 1, acc_val * 100, loss_val,\n",
    "            \" (improved)\" if loss_val < best_loss_val else \"\"))\n",
    "\n",
    "        # 如果有进步就保存模型：\n",
    "        if loss_val < best_loss_val:\n",
    "            save_path = saver.save(sess, checkpoint_path)\n",
    "            best_loss_val = loss_val"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们在训练结束后，在验证集上达到了99.32%的精度，只用了5个epoches，看上去不错。现在让我们将模型运用到测试集上。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./my_capsule_network\n",
      "Final test accuracy: 99.2100%  Loss: 0.007933   \n"
     ]
    }
   ],
   "source": [
    "n_iterations_test = mnist.test.num_examples // batch_size\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    saver.restore(sess, checkpoint_path)\n",
    "\n",
    "    loss_tests = []\n",
    "    acc_tests = []\n",
    "    for iteration in range(1, n_iterations_test + 1):\n",
    "        X_batch, y_batch = mnist.test.next_batch(batch_size)\n",
    "        loss_test, acc_test = sess.run(\n",
    "                [loss, accuracy],\n",
    "                feed_dict={X: X_batch.reshape([-1, 28, 28, 1]),\n",
    "                           y: y_batch})\n",
    "        loss_tests.append(loss_test)\n",
    "        acc_tests.append(acc_test)\n",
    "        print(\"\\rEvaluating the model: {}/{} ({:.1f}%)\".format(\n",
    "                  iteration, n_iterations_test,\n",
    "                  iteration * 100 / n_iterations_test),\n",
    "              end=\" \" * 10)\n",
    "    loss_test = np.mean(loss_tests)\n",
    "    acc_test = np.mean(acc_tests)\n",
    "    print(\"\\rFinal test accuracy: {:.4f}%  Loss: {:.6f}\".format(\n",
    "        acc_test * 100, loss_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们在测试集上达到了99.21%的精度。相当棒！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 预测"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们进行一些预测！首先从测试集确定一些图片，接着开始一个session，恢复已经训练好的模型，评估`cap2_output`来获得胶囊网络的输出向量，`decoder_output`来重新构造，用`y_pred`来获得类型预测："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./my_capsule_network\n"
     ]
    }
   ],
   "source": [
    "n_samples = 5\n",
    "\n",
    "sample_images = mnist.test.images[:n_samples].reshape([-1, 28, 28, 1])\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    saver.restore(sess, checkpoint_path)\n",
    "    caps2_output_value, decoder_output_value, y_pred_value = sess.run(\n",
    "            [caps2_output, decoder_output, y_pred],\n",
    "            feed_dict={X: sample_images,\n",
    "                       y: np.array([], dtype=np.int64)})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意：我们传递的`y`使用了一个空的数组，不过TensorFlow并不会用到它，前面已经解释过了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们把这些图片和它们的标签绘制出来，同时绘制出来的还有相应的重新构造和预测："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1e55c37668>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1e55ad5278>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sample_images = sample_images.reshape(-1, 28, 28)\n",
    "reconstructions = decoder_output_value.reshape([-1, 28, 28])\n",
    "\n",
    "plt.figure(figsize=(n_samples * 2, 3))\n",
    "for index in range(n_samples):\n",
    "    plt.subplot(1, n_samples, index + 1)\n",
    "    plt.imshow(sample_images[index], cmap=\"binary\")\n",
    "    plt.title(\"Label:\" + str(mnist.test.labels[index]))\n",
    "    plt.axis(\"off\")\n",
    "\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(n_samples * 2, 3))\n",
    "for index in range(n_samples):\n",
    "    plt.subplot(1, n_samples, index + 1)\n",
    "    plt.title(\"Predicted:\" + str(y_pred_value[index]))\n",
    "    plt.imshow(reconstructions[index], cmap=\"binary\")\n",
    "    plt.axis(\"off\")\n",
    "    \n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "预测都正确，而且重新构造的图片看上去很棒。阿弥陀佛！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 理解输出向量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "让我们调整一下输出向量，对它们的姿态参数表示进行查看。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先让我们检查`cap2_output_value` NumPy数组的形状："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 1, 10, 16, 1)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "caps2_output_value.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "让我们创建一个函数，该函数在所有的输出向量里对于每个 16（维度）姿态参数进行调整。每个调整过的输出向量将和原来的输出向量相同，除了它的 姿态参数 中的一个会加上一个-0.5到0.5之间变动的值。默认的会有11个步数(-0.5, -0.4, ..., +0.4, +0.5)。这个函数会返回一个数组，其形状为(_调整过的姿态参数_=16, _步数_=11, _batch size_=5, 1, 10, 16, 1)："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tweak_pose_parameters(output_vectors, min=-0.5, max=0.5, n_steps=11):\n",
    "    steps = np.linspace(min, max, n_steps) # -0.25, -0.15, ..., +0.25\n",
    "    pose_parameters = np.arange(caps2_n_dims) # 0, 1, ..., 15\n",
    "    tweaks = np.zeros([caps2_n_dims, n_steps, 1, 1, 1, caps2_n_dims, 1])\n",
    "    tweaks[pose_parameters, :, 0, 0, 0, pose_parameters, 0] = steps\n",
    "    output_vectors_expanded = output_vectors[np.newaxis, np.newaxis]\n",
    "    return tweaks + output_vectors_expanded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "让我们计算所有的调整过的输出向量并且重塑结果到 (_parameters_×_steps_×_instances_, 1, 10, 16, 1) 以便于我们能够传递该数组到解码器中："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_steps = 11\n",
    "\n",
    "tweaked_vectors = tweak_pose_parameters(caps2_output_value, n_steps=n_steps)\n",
    "tweaked_vectors_reshaped = tweaked_vectors.reshape(\n",
    "    [-1, 1, caps2_n_caps, caps2_n_dims, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们递送这些调整过的输出向量到解码器并且获得重新构造，它会产生："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./my_capsule_network\n"
     ]
    }
   ],
   "source": [
    "tweak_labels = np.tile(mnist.test.labels[:n_samples], caps2_n_dims * n_steps)\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    saver.restore(sess, checkpoint_path)\n",
    "    decoder_output_value = sess.run(\n",
    "            decoder_output,\n",
    "            feed_dict={caps2_output: tweaked_vectors_reshaped,\n",
    "                       mask_with_labels: True,\n",
    "                       y: tweak_labels})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "让我们重塑解码器的输出以便于我们能够在输出维度，调整步数，和实例之上进行迭代："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "tweak_reconstructions = decoder_output_value.reshape(\n",
    "        [caps2_n_dims, n_steps, n_samples, 28, 28])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，让我们绘制所有的重新构造，对于前三个输出维度，对于每个调整中的步数（列）和每个数字（行）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tweaking output dimension #0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1e5583e588>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tweaking output dimension #1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1e55a68390>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tweaking output dimension #2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1e4d3608d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for dim in range(3):\n",
    "    print(\"Tweaking output dimension #{}\".format(dim))\n",
    "    plt.figure(figsize=(n_steps / 1.2, n_samples / 1.5))\n",
    "    for row in range(n_samples):\n",
    "        for col in range(n_steps):\n",
    "            plt.subplot(n_samples, n_steps, row * n_steps + col + 1)\n",
    "            plt.imshow(tweak_reconstructions[dim, col, row], cmap=\"binary\")\n",
    "            plt.axis(\"off\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 小结"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我试图让这个notebook中的代码尽量的扁平和线性，为了让大家容易跟上，当然在实践中大家可能想要包装这些代码成可重用的函数和类。例如，你可以尝试实现你自己的`PrimaryCapsuleLayer`，和`DeseRoutingCapsuleLayer` 类，其参数可以是胶囊的数量，路由迭代的数量，是使用动态循环还是静态循环，诸如此类。对于基于TensorFlow模块化的胶囊网络的实现，可以参考[CapsNet-TensorFlow](https://github.com/naturomics/CapsNet-Tensorflow) 项目。\n",
    "\n",
    "这就是今天所有的内容，我希望你们喜欢这个notebook！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.4"
  },
  "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": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "336px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}