Instance Segmentation 比 Semantic Segmentation 难很多吗_百度知道
Instance Segmentation 比 Semantic Segmentation 难很多吗
我有更好的答案
你好！instance semantic segmentation 实例的语义分割
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。Instance Segmentation 比 Semantic Segmentation 难很多吗？ - 知乎862被浏览<strong class="NumberBoard-itemValue" title="3分享邀请回答895 条评论分享收藏感谢收起&figure&&img src=&https://pic1.zhimg.com/v2-8ba5ff20ea3f06d1341119_b.jpg& data-rawwidth=&683& data-rawheight=&526& class=&origin_image zh-lightbox-thumb& width=&683& data-original=&https://pic1.zhimg.com/v2-8ba5ff20ea3f06d1341119_r.jpg&&&/figure&&p&文章选自freecodecamp，作者：Nick Bourdakos，机器之心编译。&/p&&blockquote&CapsNet 将神经元的标量输出转换为向量输出提高了表征能力，我们不仅能用它表示图像是否有某个特征，同时还能表示这个特征的旋转和位置等物理特征。本文从可视化的角度出发详解释了 CapsNet 的原理的计算过程，非常有利于直观理解它的结构。&/blockquote&&p&尽管卷积神经网络已经做出了令人惊艳的成绩，但还是存在着一些根本性问题。是时候开始思考新的解决方案和改进了。现在就让我们一起来了解一下胶囊网络（capsules networks）。&/p&&p&在之前的文章中我曾简要地讨论过胶囊网络（&a href=&https://link.zhihu.com/?target=https%3A//hackernoon.com/capsule-networks-are-shaking-up-ai-heres-how-to-use-them-c233a0971952& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&hackernoon.com/capsule-&/span&&span class=&invisible&&networks-are-shaking-up-ai-heres-how-to-use-them-c233a0971952&/span&&span class=&ellipsis&&&/span&&/a&）是如何解决一些传统问题的。在过去的几个月里，我一直沉浸在各种各样的胶囊网络里。我觉得现在是时候一起更加深入地探索胶囊网络的实际运作方式了。&/p&&p&为了让后面的讨论更加容易，我开发了一款与胶囊网络实现配套的可视化工具，它能够让您看到网络的每一层是如何工作的。这些内容都可以在 GitHub 上找到（&a href=&https://link.zhihu.com/?target=https%3A//github.com/bourdakos1/CapsNet-Visualization& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&github.com/bourdakos1/C&/span&&span class=&invisible&&apsNet-Visualization&/span&&span class=&ellipsis&&&/span&&/a&）。&/p&&p&如下所示是 CapsNet 的结构。如果您现在还不理解每个部分的具体含义，不必担心。我会尽我所能一层一层地进行详细讨论。&/p&&figure&&img src=&https://pic1.zhimg.com/v2-8cf687e2ae95ae4cc054b_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&1080& data-rawheight=&374& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&https://pic1.zhimg.com/v2-8cf687e2ae95ae4cc054b_r.jpg&&&/figure&&p&&b&part 0: 网络输入&/b&&/p&&p&胶囊网络（CapsNet）的输入是提供给神经网络的真实图片。在这个例子中输入的图片长宽都为 28 个像素。一张图片实际上有 3 个维度用来存储不同颜色通道的信息。&/p&&p&因为是灰度图，而用作示例的图片仅仅有一个颜色通道。大家所熟悉的大多数图片都有 3 或 4 个通道用来存储红-绿-蓝和可能用于存储灰度或透明度的额外通道。 &/p&&figure&&img src=&https://pic4.zhimg.com/v2-f89dd855ddb7dd5cff7715d2_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&683& data-rawheight=&526& class=&origin_image zh-lightbox-thumb& width=&683& data-original=&https://pic4.zhimg.com/v2-f89dd855ddb7dd5cff7715d2_r.jpg&&&/figure&&p&每个像素都被表示为 0 到 255 之间的一个数字并且被存储在一个 28x28x1 的矩阵 [28, 28, 1] 里。每一个像素的颜色越明亮，其数值越大。 &/p&&p&&b&Part 1a: 卷积&/b&&/p&&p&胶囊网络的第一个部分是传统的卷积网络。那么什么是卷积网络，它是怎么工作，而又有什么作用呢？&/p&&p&我们的目标是要从输入图像中提取一些非常基础的特征，比如边缘或者曲线。那么我们是怎么做到的呢？让我们来思考一个边缘情况：&/p&&figure&&img src=&https://pic3.zhimg.com/v2-19d0f3d19e_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&391& data-rawheight=&443& class=&content_image& width=&391&&&/figure&&p&如果我们看到这个图片上的一些点，我们就能够从中发现出一种模式。而现在我们关注于这些点左右两侧的颜色：&/p&&figure&&img src=&https://pic3.zhimg.com/v2-3f0be719f466d3cdf5d57_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&508& data-rawheight=&487& class=&origin_image zh-lightbox-thumb& width=&508& data-original=&https://pic3.zhimg.com/v2-3f0be719f466d3cdf5d57_r.jpg&&&/figure&&p&你也许会注意到当这个点在边缘时，其两侧颜色之间的差别会很大。&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&255 - 114 = 141
114 - 153 = -39
153 - 153 = 0
255 - 255 = 0
&/code&&/pre&&/div&&p&如果我们纵览图片中的每一个像素并且用它和左右点之间的差异值来替换掉原始的值会发生什么？理论上这个图片除边缘外的部分会全部变成黑色。&/p&&p&我们可以通过循环来遍历图片中每一个像素并进行上述处理：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&for pixel in image {
result[pixel] = image[pixel - 1] - image[pixel + 1]
&/code&&/pre&&/div&&p&但是这是比较低效的。而实际上，我们可以使用卷积操作。更技术地来讲，这其实是「互相关」，但大家更喜欢称之为卷积。&/p&&p&本质上卷积操作和上述循环的效果几乎是一样的，但它可以充分利用矩阵运算的优势来提高效率。&/p&&p&卷积操作一开始会在图像的一角设置一个小的窗口，然后移动它遍历整幅图像。在每一个位置我们都仅仅关注窗口所覆盖的像素并且将其中全部的像素值与对应的权重相乘并求和。而这个窗口实质上是一个被称为「卷积核」的权重矩阵。&/p&&p&我们仅仅关注 2 个像素，但是当我们把它周围的窗口打包起来的时候，就可以让他们之间的像素变成胶囊。&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&Window:
┌─────────────────────────────────────┐
│ left_pixel middle_pixel right_pixel │
└─────────────────────────────────────┘
&/code&&/pre&&/div&&p&你能够找到一组权重与这些像素相乘并求和得到我们想要的值吗？&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&Window:
┌─────────────────────────────────────┐
│ left_pixel middle_pixel right_pixel │
└─────────────────────────────────────┘
(w1 * 255) + (w2 * 255) + (w3 * 114) = 141
&/code&&/pre&&/div&&p&Spoilers below!&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&│
&/code&&/pre&&/div&&p&我们可以进行这样的操作：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&Window:
┌─────────────────────────────────────┐
│ left_pixel middle_pixel right_pixel │
└─────────────────────────────────────┘
(1 * 255) + (0 * 255) + (-1 * 114) = 141
&/code&&/pre&&/div&&p&有了这些权重，我们可以得到卷积核：&/p&&p&kernel = [1 0 -1]&/p&&p&当然，卷积核通常来说是方阵，所以我们可以用 0 来填充其他位置： &/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&kernel = [
&/code&&/pre&&/div&&p&这里有一个很棒的动态图来描述卷积的运算过程：&/p&&figure&&img src=&https://pic4.zhimg.com/v2-deed516a8d858ecfaffa9_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&640& data-rawheight=&378& data-thumbnail=&https://pic4.zhimg.com/v2-deed516a8d858ecfaffa9_b.jpg& class=&origin_image zh-lightbox-thumb& width=&640& data-original=&https://pic4.zhimg.com/v2-deed516a8d858ecfaffa9_r.jpg&&&/figure&&p&在步幅为 1 的情况下，输出的维度为输入的维度减去卷积核的维度再加 1，比如 (7—3) + 1 = 5（更多相关内容请看下一小节）。&/p&&p&经过卷积变换后的图片如下所示：&/p&&figure&&img src=&https://pic2.zhimg.com/v2-affff4d78fd21acb82cfa_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&1080& data-rawheight=&479& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&https://pic2.zhimg.com/v2-affff4d78fd21acb82cfa_r.jpg&&&/figure&&p&你也许会注意到在变换后的图片中一些边缘丢失了。具体来说，是那些水平方向的边缘。为了突出这些信息，我们需要另外一个卷积核来处理像素上方和下方的信息。比如：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&kernel = [
&/code&&/pre&&/div&&p&此外，这两个卷积核在处理其他的角度或者模糊的边界时都无法获得很好的效果。因此我们要使用多个卷积核（在我们的胶囊网络实现中，我们使用了 256 个卷积核）并且卷积核一般有更大的尺寸以增加处理的空间（我们使用 9x9 的的卷积核）。&/p&&p&其中一个经过训练后的卷积核如下所示。虽然不是很明显，但我们还是可以看出它是一个更加鲁棒的放大版边缘探测器。它仅仅用来找到那些从亮变暗的边缘。&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&kernel = [
[ 0.02 -0.01
0.01 -0.05 -0.08 -0.14 -0.16 -0.22 -0.02]
0.00 -0.06 -0.14 -0.28
0.01 -0.11 -0.22 -0.08]
[ 0.03 -0.01 -0.02
0.07 -0.11 -0.24 -0.05]
[-0.01 -0.02 -0.02
0.12 -0.13 -0.31
[-0.05 -0.02
0.14 -0.17 -0.29
0.04 -0.18 -0.10
0.03 -0.01 -0.10 -0.07
0.02 -0.04 -0.02 -0.05
&/code&&/pre&&/div&&p&注意：我对所有的值都进行了取整，因为他们太长了，比如：0.。&/p&&p&幸运的是，我们不需要手动地设计这些卷积核。训练过程可以自动完成这一工作。所有的卷积核一开始都是空的（或者随机初始化），而在训练过程中他们被不断调整使得最终的输出和我们的目标更接近。&/p&&p&如下所示是经过训练后最终得到的 256 个卷积核（为了方便理解我给他们上了色）。我们用蓝色来表示负数, 用 0 来表示绿色，用黄色来表示正数. 并且颜色越强，其绝对值越大。&/p&&figure&&img src=&https://pic3.zhimg.com/v2-944adf3a0a996a001b9c08d2ba02fe86_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&656& data-rawheight=&661& class=&origin_image zh-lightbox-thumb& width=&656& data-original=&https://pic3.zhimg.com/v2-944adf3a0a996a001b9c08d2ba02fe86_r.jpg&&&/figure&&p&用所有的卷积核处理完图片后，我们可以得到一个含有 256 张输出图片的栈。&/p&&p&&b&Part 1b: 线性整流函数&/b&&/p&&p&ReLU（线性整流函数）也许听起来很复杂，但实际上非常简单。作为一个激活函数，它对输入的值进行处理然后输出。如果输入的值是负数，那么输出为 0，如果输入的值是正数，那么输出和输入完全一致。 &/p&&p&代码如下： &/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&x = max(0, x)
&/code&&/pre&&/div&&p&如图所示：&/p&&figure&&img src=&https://pic1.zhimg.com/v2-aa2d54314d8afd94faf35_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&718& data-rawheight=&439& class=&origin_image zh-lightbox-thumb& width=&718& data-original=&https://pic1.zhimg.com/v2-aa2d54314d8afd94faf35_r.jpg&&&/figure&&p&我们用这个函数对所有卷积输出进行处理。&/p&&p&为什么我们要这么做？因为如果我们不使用激活函数对神经元层的输出进行处理，那么整个网络就可以被描述为一个线性的函数，这样一来我们所有的努力就都失去意义了。 &/p&&p&添加一个非线性的部分使得我们可以描述所有种类的函数。我们可以使用很多不同种类的函数来作为激活函数，只是 ReLU 是最流行的一种，因为它使用起来最方便。 &/p&&p&第一个使用了 ReLU 的卷积层输出如下所示： &/p&&figure&&img src=&https://pic4.zhimg.com/v2-8abee7aeea0_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&652& data-rawheight=&652& class=&origin_image zh-lightbox-thumb& width=&652& data-original=&https://pic4.zhimg.com/v2-8abee7aeea0_r.jpg&&&/figure&&p&&b&Part 2a: 初级胶囊层（PrimaryCaps）&/b& &/p&&p&一开始我们使用一个普通的卷积层作为初级胶囊层。但这次我们要对前面输出的 256 个特征图进行操作，因此我们使用一个 9x9x256 的卷积核而不是 9x9x1 的卷积核。那么我们究竟想要得到什么？&/p&&p&在第一个卷积层我们在寻找简单的边角和曲线。现在我们希望从上一步得到的边缘信息中找到更加复杂一点的形状。&/p&&p&这次我们的步长是 2，即每次移动 2 个像素而不是 1 个。使用更大的步长可以让我们更快地降低输出尺寸。 &/p&&figure&&img src=&https://pic2.zhimg.com/v2-b41ce69bbeed97a06e3652_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&1080& data-rawheight=&453& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&https://pic2.zhimg.com/v2-b41ce69bbeed97a06e3652_r.jpg&&&/figure&&p&注意：一般来说，输出的维度是 12，但由于我们的步长为 2，所以输出向量的维度减半。比如：((20—9) + 1) / 2 = 6。&/p&&p&我们会对输出再进行 256 次卷积操作，这样我们最终可以得到一个含有 256 个输出（6x6）的栈。 &/p&&p&但这一次我们想要的不仅仅是一些糟糕而普通的旧数据。我们要把这个栈切分成 32 层，其中每层有 8 个块，我们称之为「胶囊层」，每个胶囊层有 36 个「胶囊」。&/p&&p&更进一步地说，这意味着每个胶囊含有一个拥有 8 个值的数组，而一般我们称之为向量。 &/p&&p&我所要强调的是： &/p&&figure&&img src=&https://pic1.zhimg.com/v2-19a52c6d62e61a42be14e_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&846& data-rawheight=&572& class=&origin_image zh-lightbox-thumb& width=&846& data-original=&https://pic1.zhimg.com/v2-19a52c6d62e61a42be14e_r.jpg&&&/figure&&p&这些「胶囊」是我们新的像素。 &/p&&p&对于单一的像素值来说，我们仅仅能够存储在特定位置是否有一个边角的置信度。数值越大，置信度越高。 &/p&&p&而对于一个胶囊，我们可以在每个位置存储 8 个值！这让我们有机会存储更多的信息而不仅仅是是否在某个位置找到了某种形状。但我们想要存储的还有哪些信息呢？ &/p&&p&当看到下面的形状的时候，你能够发现什么？如果你需要在对方不能观看的情况下告诉他如何复原这个形状，你会怎么说？ &/p&&figure&&img src=&https://pic2.zhimg.com/v2-f9a0ae5c16f838afc9e3a81d59cf887b_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&617& data-rawheight=&372& class=&origin_image zh-lightbox-thumb& width=&617& data-original=&https://pic2.zhimg.com/v2-f9a0ae5c16f838afc9e3a81d59cf887b_r.jpg&&&/figure&&p&这个图片非常基础，所以我们仅仅需要描述很少的一些细节。： &/p&&ul&&li&形状的类型 &/li&&li&位置&/li&&li&旋转&/li&&li&颜色&/li&&li&尺寸&/li&&/ul&&p&我们可以称之为「实例化参数」。对于更复杂的图片我们最终需要更多的细节。他们可以包括姿态（位置、尺寸、方向、）、畸变、速度、反照率、色调、质地等等。 &/p&&p&你也许还记得当我们为边缘检测设计卷积核的时候，它只会在某一个具体的角度起作用，因此对于每一个角度我们都需要一个卷积核。而事实上我们完全可以摆脱上述的过程，因为当我们在处理边缘时，描述边缘的方式是非常有限的。 &/p&&p&当我们在处理形状这一层次的特征时，我们不想给每一个角度的长方形、三角形、椭圆等等都去设计对应的卷积核。这太不明智了，尤其是当处理像光线一样有 3 个维度的旋转和特征的更复杂的形状时更是如此。 &/p&&p&而这恰恰正是传统的神经网络无法很好地处理微小旋转的原因。 &/p&&figure&&img src=&https://pic1.zhimg.com/v2-9b9c8dc24f5c16e1d122b5adcf2217dd_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&531& data-rawheight=&503& class=&origin_image zh-lightbox-thumb& width=&531& data-original=&https://pic1.zhimg.com/v2-9b9c8dc24f5c16e1d122b5adcf2217dd_r.jpg&&&/figure&&p&当我们从边缘到形状，再从形状到物体传递特征的时候，如果能够有更多的空间去存储额外有用的信息将会是很有帮助的。 &/p&&p&如下是两个胶囊层（一个用来处理长方形一个用来处理三角形）和 2 个传统像素输出的一个简化版对比： &/p&&figure&&img src=&https://pic1.zhimg.com/v2-738d34d3bde06c8de1fd5_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&770& data-rawheight=&391& class=&origin_image zh-lightbox-thumb& width=&770& data-original=&https://pic1.zhimg.com/v2-738d34d3bde06c8de1fd5_r.jpg&&&/figure&&p&与传统的 2 维或者 3 维的向量类似，这个向量也有角度和长度。长度描述概率而角度描述实例化的参数。在上面的例子中，这个角度实际上和形状的角度是一致的，但通常来说不一定是这样。 &/p&&p&在实际中想要可视化展示上述的向量是不可行或者至少是非常困难的，因为他们有 8 个维度。 &/p&&p&那么既然我们在胶囊中存储了这些额外的信息，我们应该可以在此基础上重构出最初的图片。这听起来很不错，但我们要怎样才能使得网络学习到这些内容呢？&/p&&p&在训练传统卷积神经网络的时候，我们仅仅关心模型是否能够预测正确的类别。而在训练胶囊网络的时候，我们有另外的一种叫做「重构」的方法。每次重构都尝试仅仅使用我们给出的向量复原原始图片。然后我们使用重构图片和目标图片的接近程度对模型进行评估。 &/p&&p&这里有一个简单的例子。而在接下来的部分中我会介绍更多的细节。 &/p&&figure&&img src=&https://pic1.zhimg.com/v2-738d34d3bde06c8de1fd5_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&770& data-rawheight=&391& class=&origin_image zh-lightbox-thumb& width=&770& data-original=&https://pic1.zhimg.com/v2-738d34d3bde06c8de1fd5_r.jpg&&&/figure&&p&&b&Part 2b: 非线性变换 Squashing&/b& &/p&&p&在得到胶囊之后，我们会再对其进行一次非线性变换（比如 ReLU），但这次的公式比之前略微难懂。这个函数成比例扩大了向量的值，使得它在角度不变的情况下长度有所增加。这样我们就可以让向量分布在 0 和 1 之间从而实际上获得一个概率值。 &/p&&p&经过压缩操作后胶囊向量的长度如下所示。在这时想要猜出每个胶囊的目标几乎是不可能的。 &/p&&figure&&img src=&https://pic4.zhimg.com/v2-8fb64a61784fbb609a84d296e2e0da43_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&1080& data-rawheight=&214& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&https://pic4.zhimg.com/v2-8fb64a61784fbb609a84d296e2e0da43_r.jpg&&&/figure&&p&要注意的是每个像素实际上都是一个长度为 8 的向量。 &/p&&p&&b&Part 3: 一致性路由&/b& &/p&&p&接下来的一步是决定将要被传递给下一个层级的信息。在传统的网络中，我们也许会使用类似于「最大池化」的一些方式。最大池化通过仅仅传递某一区域中激活值最大的像素到下一层的方式来降维。 &/p&&figure&&img src=&https://pic2.zhimg.com/v2-8ad8cb906c2e10d60e9e17ced59a6aa6_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&1080& data-rawheight=&492& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&https://pic2.zhimg.com/v2-8ad8cb906c2e10d60e9e17ced59a6aa6_r.jpg&&&/figure&&p&然而，在胶囊网络中，我们将使用一种被称作「一致性路由」的方式。其中每一个胶囊都试图基于它自己猜测下一层神经元的激活情况。 &/p&&figure&&img src=&https://pic4.zhimg.com/v2-683a52a5a77b527f557d22e15f3678ca_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&1080& data-rawheight=&648& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&https://pic4.zhimg.com/v2-683a52a5a77b527f557d22e15f3678ca_r.jpg&&&/figure&&p&看到这些预测并且在不知道输入的情况下，你将选择把哪一个物体传递给下一层呢？也许是船，长方形的胶囊和三角形的胶囊都在船应该是什么样子上达成了一致。但他们并没有在预测房子的样子上达成一致。所以很有可能这个物体不是一个房子。 &/p&&p&通过一致性路由，我们仅仅将有用的信息传递给下一层并且丢弃掉那些可能使结果中存在噪音的数据。这让我们能够做出更加智能的选择而不仅仅是像最大池化一样选择最大的数字。 &/p&&p&在传统网络中，错位的信息并不会造成什么困惑。 &/p&&figure&&img src=&https://pic1.zhimg.com/v2-98dadadf3671_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&522& data-rawheight=&503& class=&origin_image zh-lightbox-thumb& width=&522& data-original=&https://pic1.zhimg.com/v2-98dadadf3671_r.jpg&&&/figure&&p&而在胶囊网络中，这些特征相互之间将不会达成一致： &/p&&figure&&img src=&https://pic1.zhimg.com/v2-b8baaefe2a078faa02ed1cc1c09be110_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&697& data-rawheight=&359& class=&origin_image zh-lightbox-thumb& width=&697& data-original=&https://pic1.zhimg.com/v2-b8baaefe2a078faa02ed1cc1c09be110_r.jpg&&&/figure&&p&正如我们所期望的那样，这种方式在直觉上是可行的。而在数学上，它究竟是怎么运作的呢？ &/p&&p&我们的目标是预测 10 个不同的数字（每个数字为一类）&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&0, 1, 2, 3, 4, 5, 6, 7, 8, 9
&/code&&/pre&&/div&&p&注意：在船和房子的例子中，我们的目标是预测两个物体，而现在我们要预测 10 个。 &/p&&p&与船和房子的例子不同，在这里我们不是要预测实际的图片，而是要试图预测描述图片的向量。通过计算向量和每一个类别的权重矩阵的乘积，我们可以获得胶囊对于每一个类的预测结果。&/p&&p&注意我们有 32 个胶囊层，并且每个胶囊层有 36 个胶囊。这意味着我们总共有 1152 个胶囊。 &/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&cap_1 * weight_for_0 = prediction
cap_1 * weight_for_1 = prediction
cap_1 * weight_for_2 = prediction
cap_1 * ...
cap_1 * weight_for_9 = prediction
cap_2 * weight_for_0 = prediction
cap_2 * weight_for_1 = prediction
cap_2 * weight_for_2 = prediction
cap_2 * ...
cap_2 * weight_for_9 = prediction
cap_1152 * weight_for_0 = prediction
cap_1152 * weight_for_1 = prediction
cap_1152 * weight_for_2 = prediction
cap_1152 * ...
cap_1152 * weight_for_9 = prediction
&/code&&/pre&&/div&&p&经过计算，最终你将得到一个含有 11520 个预测值的列表。 &/p&&p&每个权重实际上是一个 16x8 的矩阵，所以每个预测都是胶囊向量同这个权重矩阵的乘积。 &/p&&figure&&img src=&https://pic1.zhimg.com/v2-83efa7f84ccfde26da2510e2_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&590& data-rawheight=&355& class=&origin_image zh-lightbox-thumb& width=&590& data-original=&https://pic1.zhimg.com/v2-83efa7f84ccfde26da2510e2_r.jpg&&&/figure&&p&正如你看到的那样，我们的预测结果是一个 16 维的向量。 &/p&&p&维度 16 是从何而来呢？这是一个任意的选择，就像我们最初使用 8 个胶囊一样。 &/p&&p&但需要注意的是，我们如果我们想要选择更深层的胶囊网络，我们就要扩大胶囊的维度。从直觉上来说，这是可行的。因为我们使用的网络越深，特征表达就越复杂，需要我们再现的参数就更多。举例来说，描述一整张脸比描述一只眼睛需要更多的信息。 &/p&&p&下一步是要找到在这 11520 个预测中和其他预测一致性最高的内容。 &/p&&p&想要可视化高维的向量是很有难度的一件事情，为了更符合人的直觉，我们假设这些向量仅仅是 2 维空间中的点。 &/p&&figure&&img src=&https://pic1.zhimg.com/v2-ee9a4b979e14079aeb7898_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&925& data-rawheight=&436& class=&origin_image zh-lightbox-thumb& width=&925& data-original=&https://pic1.zhimg.com/v2-ee9a4b979e14079aeb7898_r.jpg&&&/figure&&p&首先我们计算所有点的平均值。每个点在最初都被赋予了同样的重要性。 &/p&&figure&&img src=&https://pic3.zhimg.com/v2-dcda94afe4d41319bbcf_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&917& data-rawheight=&425& class=&origin_image zh-lightbox-thumb& width=&917& data-original=&https://pic3.zhimg.com/v2-dcda94afe4d41319bbcf_r.jpg&&&/figure&&p&接下来我们可以测量每个点和平均值点之间的距离。距离越远的点，其重要程度就越低。 &/p&&figure&&img src=&https://pic2.zhimg.com/v2-9eefb8febd808dac4b140dd0c2f88488_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&920& data-rawheight=&429& class=&origin_image zh-lightbox-thumb& width=&920& data-original=&https://pic2.zhimg.com/v2-9eefb8febd808dac4b140dd0c2f88488_r.jpg&&&/figure&&p&然后我们在考虑每个点的不同的重要性，重新计算平均值： &/p&&figure&&img src=&https://pic4.zhimg.com/v2-cc6deacfab233c89eb3648_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&916& data-rawheight=&417& class=&origin_image zh-lightbox-thumb& width=&916& data-original=&https://pic4.zhimg.com/v2-cc6deacfab233c89eb3648_r.jpg&&&/figure&&p&正如你能够看到的，随着我们重复进行这个循环，那些和其他点不一致的的点开始消失。而那些相互之间高度一致的点则最终将被传递给激活值最高的的下一层。 &/p&&p&&b&Part 4: DigitCaps&/b& &/p&&p&达成一致后，我们最终可以得到 10 个 16 维的向量，每个向量都和一个数字相对应。这个矩阵就是我们最终的预测结果。这个向量的长度是数字被找出的置信度——越长越好。这个向量也可以被用于生成输入图片的重构。 &/p&&figure&&img src=&https://pic1.zhimg.com/v2-ac2f2aaaae838_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&723& data-rawheight=&686& class=&origin_image zh-lightbox-thumb& width=&723& data-original=&https://pic1.zhimg.com/v2-ac2f2aaaae838_r.jpg&&&/figure&&p&这就是在输入为 4 的情况下向量的长度分布情况。 &/p&&p&第五个方块区域是最明亮的，意味着较高的置信度。注意数字 0 是第一类，所以我们在这里给出的预测是数字 4. &/p&&p&&b&Part 5: 重构&/b& &/p&&p&这个代码实现中重构的部分相对比较简单，它仅仅是一个多层的全连接网络，但重构本身的过程是非常有趣的。 &/p&&p&如果我们重构 4 个输入向量，我们将会得到：&/p&&figure&&img src=&https://pic2.zhimg.com/v2-3b27eb6c1f7beac2eab1_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&1080& data-rawheight=&635& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&https://pic2.zhimg.com/v2-3b27eb6c1f7beac2eab1_r.jpg&&&/figure&&p&如果我们调整这些滑动器，我们可以看到每一个维度是如何影响这 4 个输入的： &/p&&figure&&img src=&https://pic2.zhimg.com/v2-98e09b3c97f9afcbd0f54eeb_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&1080& data-rawheight=&593& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&https://pic2.zhimg.com/v2-98e09b3c97f9afcbd0f54eeb_r.jpg&&&/figure&&p&我推荐大家下载使用这个可视化工具来观察在不同输入下滑动向量数值是如何影响重构过程的。 &/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&git clone https://github.com/bourdakos1/CapsNet-Visualization.git
cd CapsNet-Visualization
pip install -r requirements.txt
&/code&&/pre&&/div&&p&运行可视化工具 &/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&python run_visualization.py
&/code&&/pre&&/div&&p&接下来用浏览器访问 &a href=&https://link.zhihu.com/?target=http%3A//localhost%3A5000& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&http://localhost:5000 (http://localhost:5000/)&/a&&/p&&p&&br&&/p&&p&&b&总结&/b& &/p&&p&我认为对于胶囊网络的重构是令人惊叹的。考虑到我们仅仅使用了一个简单的数据集来训练当前的模型，这让我不由期待经由大量数据训练的成熟胶囊网络结构，及其效果。 &/p&&p&我非常期待看到控制更为复杂图像的重构向量将对模型产生怎样的影响。因此在接下来的工作中，我将在 CIFAR 和 smallNORB 数据上对胶囊网络进行测试。&/p&&p&&br&&/p&&p&原文地址：&a href=&https://link.zhihu.com/?target=https%3A//medium.freecodecamp.org/understanding-capsule-networks-ais-alluring-new-architecture-bdb228173ddc& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&medium.freecodecamp.org&/span&&span class=&invisible&&/understanding-capsule-networks-ais-alluring-new-architecture-bdb228173ddc&/span&&span class=&ellipsis&&&/span&&/a&&/p&
文章选自freecodecamp，作者：Nick Bourdakos，机器之心编译。CapsNet 将神经元的标量输出转换为向量输出提高了表征能力，我们不仅能用它表示图像是否有某个特征，同时还能表示这个特征的旋转和位置等物理特征。本文从可视化的角度出发详解释了 CapsNet 的…
&p&&b&作为Google员工，我来谈谈两个令我体会比较深刻的原因吧。&/b&&/p&&p&&b&1. 神经网络/深度学习在机器翻译上的飞速进展。&/b&&/p&&p&大概在14年左右的时候，关于在机器翻译上应用神经网络/深度学习的论文开始大量地被发表。[&u&&a href=&//link.zhihu.com/?target=https%3A//papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Sutskever et al., 2014&/a&&/u&]把基于RNN的序列到序列（seq2seq）模型应用于机器翻译的任务上。&/p&&figure&&img src=&https://pic4.zhimg.com/v2-fcffa0fbb623_b.jpg& data-size=&small& data-rawwidth=&791& data-rawheight=&651& class=&origin_image zh-lightbox-thumb& width=&791& data-original=&https://pic4.zhimg.com/v2-fcffa0fbb623_r.jpg&&&figcaption&多层seq2seq模型&/figcaption&&/figure&&p&后来因为单纯的seq2seq对于长句的效果不佳，引入了注意力机制（Attention）。[&u&&a href=&//link.zhihu.com/?target=https%3A//arxiv.org/pdf/.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Bahdanau et al., 2015&/a&&/u&, &u&&a href=&//link.zhihu.com/?target=http%3A//aclweb.org/anthology/D15-1166& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Luong et al., 2015&/a&&/u&]。&/p&&figure&&img src=&https://pic4.zhimg.com/v2-ea1c45c439f_b.jpg& data-size=&small& data-rawwidth=&666& data-rawheight=&494& class=&origin_image zh-lightbox-thumb& width=&666& data-original=&https://pic4.zhimg.com/v2-ea1c45c439f_r.jpg&&&figcaption&Attention&/figcaption&&/figure&&p&大概的意思是把编码层的输出和解码层的输出结合起来计算一个含有对齐信息的上下文向量(Context Vector)。由于带上了对齐信息，对长句的翻译效果有了显著的提高。&/p&&p&再后来是去年诞生的GNMT [&u&&a href=&//link.zhihu.com/?target=https%3A//arxiv.org/pdf/.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Wu et al., 2016&/a&&/u&]，在上述工作的基础上加入了一些改进，如：&/p&&p&1）用WordPiece来解决低频词的问题。这个就相当于是子词，如 wordpiece 会被拆分成word和piece两个子词。&/p&&p&2）加入了残差连接（ResNet），提高了更深的网络的可训练性。&/p&&p&3）双向RNN。&/p&&p&基本上，每一次改进都是在原先的神经网络中一些新的结构来改善原先模型不足的地方。不得不说，神经网络其中一个美妙之处就在于可以很容易地通过在上面加结构/连接来改变模型性质，所以&b&实验一种新的模型不是一件难事&/b&，这也是促成神经网络在各个应用上研究大爆发的其中一个原因。&/p&&p&当然，为了解决RNN训练慢的问题，后来又有研究者提出了基于CNN的方法[&u&&a href=&//link.zhihu.com/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Gehring et al. 2017&/a&&/u&]，纯粹Attention的方法[&u&&a href=&//link.zhihu.com/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Vaswani, et al., 2017&/a&&/u&]。这些方法摈弃了传统的RNN方法，不过我们仍然可以看到组成这些模型的各个子结构大部分都是一些已经存在的结构。&/p&&p&另外值得一提的是，上述模型都是端到端的模型（模型的输入和输出都是句子），不需要我们去处理语法/句法之类的问题。这其实就是&b&降低了机器翻译研究的门槛&/b&，即不需要太多的领域内的专业知识。&/p&&p&&br&&/p&&p&&b&2. &a href=&//link.zhihu.com/?target=https%3A//www.tensorflow.org/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Tensorflow&/a&在Google内部的广泛应用，以及Google内部对Tensorflow强大的基础设施支持。&/b&&/p&&p&Google有着大量的机器集群，并且对Tensorflow有着很好的支持。在这些集群上部署神经网络训练任务是一件轻而易举的事情。基本上，我们只需要指定所需要的资源，就可以把我们的训练任务部署在机器集群上。这就大大地降低研究的成本。这不但把研究者们从这些琐碎的事情上解放出来专心于网络结构的研究，而且可以让研究者们同时进行很多实验去验证他们的想法、快速迭代。&b&快速迭代对于研究真的非常非常重要&/b&。&/p&&p&当然，&b&硬件革新也是很重要的&/b&，近年来GPU越来越快，并且Google自家也开发了专门用于机器学习的TPU。这都是对于&b&减低实验时间成本&/b&有着很积极的作用。&/p&&p&&br&&/p&&p&顺带一提，Google已经在Tensorflow的官方教程中加入了关于机器翻译的教程（&a href=&//link.zhihu.com/?target=https%3A//www.tensorflow.org/versions/master/tutorials/seq2seq& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://www.&/span&&span class=&visible&&tensorflow.org/versions&/span&&span class=&invisible&&/master/tutorials/seq2seq&/span&&span class=&ellipsis&&&/span&&/a&）。如果哪位同学对这个感兴趣的话，可以比较容易地跟着上面的教程，开发一个自己的机器翻译模型出来。&/p&&p&&/p&
作为Google员工，我来谈谈两个令我体会比较深刻的原因吧。1. 神经网络/深度学习在机器翻译上的飞速进展。大概在14年左右的时候，关于在机器翻译上应用神经网络/深度学习的论文开始大量地被发表。[]把基于RNN的序列到序列（seq2seq）…
&figure&&img src=&https://pic3.zhimg.com/v2-fea48ed82c9d75e48991d_b.jpg& data-rawwidth=&920& data-rawheight=&451& class=&origin_image zh-lightbox-thumb& width=&920& data-original=&https://pic3.zhimg.com/v2-fea48ed82c9d75e48991d_r.jpg&&&/figure&&p&这是「萌萌的技术客栈」第 12 篇文章。&br&&/p&&p&常言道：「兵熊熊一个，将熊熊一窝」，Leader 常常决定着团队能力的上限，其重要性不言而喻。那么，究竟什么样的 Leader 是称职的？什么样的 Leader 是不称职的呢？&br&&/p&&p&武断地说，称职的技术 Leader 很少，不称职的肯定是大多数。&/p&&p&唉，这个话题，真是主管看了会沉默，员工看了会流泪...&/p&&br&&p&下面的漫画取材于特赞CTO黄勇的朋友圈，在萌萌看来，能总结出称职与不称职主管的表现的黄老湿本身，就是好主管。&br&&/p&&p&对于这个问题，他却谦虚的说：是不是好主管，主管自己说了不算，队员说了算。&/p&&p&&strong&如果说称职技术 Leader 的日常是酱紫&/strong&↓↓↓&/p&&figure&&img src=&https://pic1.zhimg.com/v2-da991daafb9_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic1.zhimg.com/v2-da991daafb9_r.jpg&&&/figure&&figure&&img src=&https://pic2.zhimg.com/v2-2beaf9e4bae9b4cd09ea5ac_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic2.zhimg.com/v2-2beaf9e4bae9b4cd09ea5ac_r.jpg&&&/figure&&br&&figure&&img src=&https://pic2.zhimg.com/v2-6dd4cf400a8ef_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic2.zhimg.com/v2-6dd4cf400a8ef_r.jpg&&&/figure&&figure&&img src=&https://pic4.zhimg.com/v2-ac95cb3fc9ebc_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic4.zhimg.com/v2-ac95cb3fc9ebc_r.jpg&&&/figure&&figure&&img src=&https://pic3.zhimg.com/v2-51a80bffd4d26f7b19003c_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic3.zhimg.com/v2-51a80bffd4d26f7b19003c_r.jpg&&&/figure&&figure&&img src=&https://pic4.zhimg.com/v2-eae9df1be324e734aa83c0_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic4.zhimg.com/v2-eae9df1be324e734aa83c0_r.jpg&&&/figure&&figure&&img src=&https://pic1.zhimg.com/v2-d15a004c43d430f6c2413f_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic1.zhimg.com/v2-d15a004c43d430f6c2413f_r.jpg&&&/figure&&figure&&img src=&https://pic2.zhimg.com/v2-dade7d3bec4b_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic2.zhimg.com/v2-dade7d3bec4b_r.jpg&&&/figure&&p&&strong&那么，不称职技术 Leader 的表现却是这样&/strong&↓↓↓&/p&&figure&&img src=&https://pic3.zhimg.com/v2-7cc8f77bdccc76a7e8c2b24_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic3.zhimg.com/v2-7cc8f77bdccc76a7e8c2b24_r.jpg&&&/figure&&figure&&img src=&https://pic3.zhimg.com/v2-12ecad54a008d_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic3.zhimg.com/v2-12ecad54a008d_r.jpg&&&/figure&&figure&&img src=&https://pic3.zhimg.com/v2-ab56e8468a_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic3.zhimg.com/v2-ab56e8468a_r.jpg&&&/figure&&figure&&img src=&https://pic3.zhimg.com/v2-13c59ef36d691f11cb24e73_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic3.zhimg.com/v2-13c59ef36d691f11cb24e73_r.jpg&&&/figure&&figure&&img src=&https://pic4.zhimg.com/v2-e9a8bfdc31592fd3feb3fd2bdce058a8_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic4.zhimg.com/v2-e9a8bfdc31592fd3feb3fd2bdce058a8_r.jpg&&&/figure&&figure&&img src=&https://pic3.zhimg.com/v2-df7bdefa21cbc6_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic3.zhimg.com/v2-df7bdefa21cbc6_r.jpg&&&/figure&&figure&&img src=&https://pic2.zhimg.com/v2-c4d027c6eae_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic2.zhimg.com/v2-c4d027c6eae_r.jpg&&&/figure&&figure&&img src=&https://pic1.zhimg.com/v2-09e18d19afc73a6c8c6fa88fa0ddef8d_b.jpg& data-rawwidth=&1772& data-rawheight=&2395& class=&origin_image zh-lightbox-thumb& width=&1772& data-original=&https://pic1.zhimg.com/v2-09e18d19afc73a6c8c6fa88fa0ddef8d_r.jpg&&&/figure&&p&（PS. 感谢漫画师小威桑）&/p&&p&&br&所以，什么样的技术 Leader 是称职的呢？黄老湿是这样说的：&/p&&blockquote&&p&称职的主管知道给团队「正能量」，他全心全意为团队好，想尽一切办法让队员们进步；&/p&&p&称职的主管懂得自我提升，他将自己学到的宝贵知识，分享给队员们，大家一起进步，共同成长；&/p&&p&称职的主管从不独断专制，他懂得和队员们达成共识，建立共赢；&/p&&p&称职的主管会说话，他知道站在对方的立场上来说话，让对方喜欢和他交谈；&/p&&p&称职的主管会做人，心中有原则，也知道随机应变，懂得「圆满」大于「完美」。&/p&&p&主管不是公司给的，而是队员们给的。&/p&&p&&b&只有队员们认为你称职，你才真的称职。&/b&&/p&&/blockquote&&p&那么问题来了，你的主管称职吗？&/p&
这是「萌萌的技术客栈」第 12 篇文章。 常言道：「兵熊熊一个，将熊熊一窝」，Leader 常常决定着团队能力的上限，其重要性不言而喻。那么，究竟什么样的 Leader 是称职的？什么样的 Leader 是不称职的呢？ 武断地说，称职的技术 Leader 很少，不称职的肯定…
&p&上一篇文章已经介绍了几篇关于Seq-to-Seq模型的论文和应用，这里就主要从具体的模型细节、公式推导、结构图以及变形等几个方向详细介绍一下Seq-to-Seq模型。这里我们主要从下面几个层次来进行介绍：&/p&&ul&&li&Seq-to-Seq框架1&/li&&li&Seq-to-Seq框架2&/li&&li&Seq-to-Seq with Attention（NMT）&/li&&li&Seq-to-Seq with Attention各种变形&/li&&li&Seq-to-Seq with Beam-Search&/li&&/ul&&h2&&b&Seq-to-Seq框架1&/b&&/h2&&p&第一个要介绍的Seq-to-Seq模型来自“&a href=&https://link.zhihu.com/?target=https%3A//arxiv.org/pdf/.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation&/a&”这篇论文，其结构图如下所示：&/p&&figure&&img src=&https://pic1.zhimg.com/v2-cfa995cb403ac_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&300& data-rawheight=&315& class=&content_image& width=&300&&&/figure&&p&特点是Encoder阶段将整个source序列编码成一个固定维度的向量C（也就是RNN最终的隐藏状态hT），C = f(x1, x2,...,xT)，f就是各种RNN模型。并认为C中保存了source序列的信息，将其传入Decoder阶段即可，在每次进行decode时，仍然使用RNN神经元进行处理（下面公式中的f函数），不过输入包括前一时刻输出yt-1、前一时刻隐层状态ht-1、输入编码向量C三个向量，也就是解码时同时会考虑前一时刻的输出和source序列两方面的信息，如下图所示。&/p&&figure&&img src=&https://pic2.zhimg.com/v2-9ff709c43_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&277& data-rawheight=&64& class=&content_image& width=&277&&&/figure&&p&有了ht之后在计算该时刻的输出值yt，这里计算一个条件概率分布，计算出当前情况下target vocab中每个词所对应的概率，这里往往需要一个额外的Projection层，因为RNN的输出维度与vocab维度不同，所以需要经过一个矩阵进行映射（后面介绍代码的时候会讲到）。yt的计算会使用ht、yt-1、C三个向量。g函数往往是一个softmax函数，用于计算归一化的概率值。&/p&&figure&&img src=&https://pic1.zhimg.com/v2-5fd73ece54e16ffdbb05f25_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&405& data-rawheight=&50& class=&content_image& width=&405&&&/figure&&h2&&b&Seq-to-Seq框架2&/b&&/h2&&p&第二个要讲的Seq-to-Seq模型来自于“&a href=&https://link.zhihu.com/?target=https%3A//arxiv.org/pdf/.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Sequence to Sequence Learning with Neural Networks&/a&”，其模型结构图如下所示：&/p&&figure&&img src=&https://pic2.zhimg.com/v2-315cebe93c0e07e8b179b7_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&811& data-rawheight=&281& class=&origin_image zh-lightbox-thumb& width=&811& data-original=&https://pic2.zhimg.com/v2-315cebe93c0e07e8b179b7_r.jpg&&&/figure&&p&与上面模型最大的区别在于其source编码后的向量C直接作为Decoder阶段RNN的初始化state，而不是在每次decode时都作为RNN cell的输入。此外，decode时RNN的输入是目标值，而不是前一时刻的输出。首先看一下编码阶段：&/p&&figure&&img src=&https://pic4.zhimg.com/v2-dee1a0cd83eb0_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&464& data-rawheight=&385& class=&origin_image zh-lightbox-thumb& width=&464& data-original=&https://pic4.zhimg.com/v2-dee1a0cd83eb0_r.jpg&&&/figure&&p&就是简单的RNN模型，每个词经过RNN之后都会编码为hidden state（e0,e1,e2），并且source序列的编码向量e就是最终的hidden state e2。接下来再看一下解码阶段：&/p&&figure&&img src=&https://pic1.zhimg.com/v2-1ea2876ce5efe8a7fc8e4a6_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&672& data-rawheight=&474& class=&origin_image zh-lightbox-thumb& width=&672& data-original=&https://pic1.zhimg.com/v2-1ea2876ce5efe8a7fc8e4a6_r.jpg&&&/figure&&p&e向量仅作为RNN的初始化状态传入decode模型。接下来就是标准的循环神经网络，每一时刻输入都是前一时刻的正确label。直到最终输入&eos&符号截止滚动。&/p&&h2&&b&Seq-to-Seq with Attention（NMT）&/b&&/h2&&p&第三个要讲的是Attention based Seq-to-Seq模型，来自于“&a href=&https://link.zhihu.com/?target=https%3A//arxiv.org/pdf/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Neural Machine Translation by Jointly Learning to Align and Translate&/a&”这篇论文，模型框架如下图所示：&/p&&figure&&img src=&https://pic4.zhimg.com/v2-f3a9e2b1b97bedef4a0b93f4_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&340& data-rawheight=&559& class=&content_image& width=&340&&&/figure&&p&前面两个模型都是将source序列编码成一个固定维度的向量，但是这样做对于长序列将会丢失很多信息导致效果不好，所以作者提出将encoder阶段所有的隐层状态保存在一个列表当中，然后接下来decode的时候，根据前一时刻状态st-1去计算T个隐层状态与其相关程度，在进行加权求和得到编码信息ci，也就是说每个解码时刻的c向量都是不一样的，会根据target与source之间的相关程度进行权重调整和计算。编码过程就不再赘述了，主要看一下解码过程的流程：&/p&&p&1，计算h1~hT各个隐层向量与st-1之间的相关程度，并进行softmax归一化操作得到每个隐层向量的权重aij：&/p&&figure&&img src=&https://pic4.zhimg.com/v2-a610ae284e408d1e10a42a0b91a93fe2_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&355& data-rawheight=&88& class=&content_image& width=&355&&&/figure&&figure&&img src=&https://pic1.zhimg.com/v2-638a3a30aa2a4be0680728_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&308& data-rawheight=&90& class=&content_image& width=&308&&&/figure&&p&eij就表示第i个target与第j个隐层向量hj之间的相关性，可以通过一个MLP神经网络进行计算，在上面示意图中没有显示出来。得到eij之后，将其传入softmax函数我们就可以获得归一化的权重值aij。&/p&&p&2，对h1~hT进行加权求和得到此次解码所对应的source编码的向量ci：&/p&&figure&&img src=&https://pic2.zhimg.com/v2-eaeb38e03ca1c3fc81596_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&206& data-rawheight=&88& class=&content_image& width=&206&&&/figure&&p&到这里我们可以参考下图进行理解（其实这里有一点不同，因为下面这个图并未引入st-1这个向量，而是仅考虑了h1~hT），从图中可以看出T个隐层向量经过左上角的MLP+softmax神经网络之后就变成了T个权重值，然后对T个向量按照该权重值进行加权求和即可得到Ci：&/p&&figure&&img src=&https://pic2.zhimg.com/v2-ce8f63ecfa046c85b6dbc_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&808& data-rawheight=&589& class=&origin_image zh-lightbox-thumb& width=&808& data-original=&https://pic2.zhimg.com/v2-ce8f63ecfa046c85b6dbc_r.jpg&&&/figure&&p&针对这个模型我们也可以参考下图进行理解，每个aij都是用zi和hj之间计算得到的，这个图是分开来讲每个向量之间的计算，而上面那个图是将其整体作为一个矩阵进行考虑，直接传入MLP神经网络即可。&/p&&figure&&img src=&https://pic4.zhimg.com/v2-8a0ad64fef68b_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&669& data-rawheight=&513& class=&origin_image zh-lightbox-thumb& width=&669& data-original=&https://pic4.zhimg.com/v2-8a0ad64fef68b_r.jpg&&&/figure&&p&3，有了ci之后，就和前面两个Seq-to-Seq模型一样了，我们根据ci进行解码即可，同样是先计算st，在计算yt，两个公式如下所示：&/p&&figure&&img src=&https://pic1.zhimg.com/v2-12f0a2fd6e_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&757& data-rawheight=&174& class=&origin_image zh-lightbox-thumb& width=&757& data-original=&https://pic1.zhimg.com/v2-12f0a2fd6e_r.jpg&&&/figure&&p&这里的Attention机制采用的是Soft Attentin（也就是对所有的h向量都有分配权重），可以将其理解为对齐模型，作用是匹配target与source之间的对应关系。从这个角度上来讲aij可以理解为yi是由xj翻译过来的概率。所以这个权重值可以很好的对模型进行可视化，以了解模型工作的机理和效果。&/p&&h2&&b&Seq-to-Seq with Attention各种变形&/b&&/h2&&p&这是我们要介绍的第四个Seq-to-Seq模型，来自于论文“E&a href=&https://link.zhihu.com/?target=http%3A//aclweb.org/anthology/D15-1166& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&ffective Approaches to Attention-based Neural Machine Translation&/a&”，目前引用量530+。这篇论文提出了两种Seq-to-Seq模型分别是global Attention和local Attention，下面分别进行介绍：&/p&&p&1，global Attention，这种模型跟上面的思路差不多，也是采用soft Attention的机制，对上面模型进行了稍微的修改，模型结构图如下所示：&/p&&figure&&img src=&https://pic1.zhimg.com/v2-38c8bccf7a83842ac0bdc_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&318& data-rawheight=&248& class=&content_image& width=&318&&&/figure&&p&从上图可以看出，原理上与NMT区别不大，只是aij计算方法稍有区别，这里的score函数从上面的神经网络变成了下面三种选择，包括内积、general、concat。结果表明general效果比较好。如下图所示：&/p&&figure&&img src=&https://pic1.zhimg.com/v2-de5ac68af9ab2ba6a0e31_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&596& data-rawheight=&380& class=&origin_image zh-lightbox-thumb& width=&596& data-original=&https://pic1.zhimg.com/v2-de5ac68af9ab2ba6a0e31_r.jpg&&&/figure&&p&为了显示出aij的计算细节，我们可以参考下图进行理解，其中的f函数就是上面提到的score评分函数：&/p&&figure&&img src=&https://pic3.zhimg.com/v2-7ea5b9a12991bb45caeafc3_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&510& data-rawheight=&585& class=&origin_image zh-lightbox-thumb& width=&510& data-original=&https://pic3.zhimg.com/v2-7ea5b9a12991bb45caeafc3_r.jpg&&&/figure&&p&因为与NMT模型差别很小，所以不在扩展介绍。下面看看local Attention。&/p&&p&&br&&/p&&p&2，local Attention，目前存在两种Attention方式soft Attention和hard Attention。上面提到的global模型属于soft Attention，这种方法的缺点是每次decode时都要计算所有的向量，导致计算复杂度较高，而且很容易可以想到，其实有些source跟本次decode根本没有任何关系，所以计算他们之间的相似度有些多余；除此之外，当source序列较长时，这种方法的效果也会有所下降。而hard Attention，每次仅选择一个相关的source进行计算，这种方法的缺点是不可微，没有办法进行反向传播，只能借助强化学习等手段进行训练。这部分内容可以参考论文“&a href=&https://link.zhihu.com/?target=https%3A//arxiv.org/pdf/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Show, Attend and Tell: Neural Image Caption Generation with Visual Attention&/a&”。所以为了融合两种方法，作者提出了一种local Attention的机制，每次只选择一部分source进行计算。这样既可以减少计算量，又可微，效果也更好。接下来看一下其原理：&/p&&figure&&img src=&https://pic2.zhimg.com/v2-c5dacfaa5c19ba97da77_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&303& data-rawheight=&264& class=&content_image& width=&303&&&/figure&&p&思路就是先根据st找到source中所对应的窗口中心位置，然后取出该窗口内的source所对应的h隐层向量，在进行求aij并加权求和得到ci向量。这个过程中最重要的就是如何确定st所对应的source的中心位置，论文中提出了两种方法：&/p&&ul&&li&monotonic alignment：直接选择source序列中的第t个作为中心pt，然后向两侧取窗口大小个词；&/li&&li&predictive alignment：使用下面的公式决定pt值的大小，将ht经过一个激活函数tanh和sigmod两个函数之后变成0~1，再乘以S（source序列长度）就变成0~S，也就是我们想要的原序列所对应的中心位置pt，取出窗口大小个隐层，在进行加权求和。这里权重乘以了一个高斯分布，目的是让靠近中心pt的词的权重更大一点，让aij形成一种钟型分布，如下图所示，原本的aij再乘以高斯分布之后，相应的aij值发生变化，导致靠近中心的aij增加，两侧的减小。&/li&&/ul&&figure&&img src=&https://pic2.zhimg.com/v2-ccdda427e1037_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&465& data-rawheight=&69& class=&origin_image zh-lightbox-thumb& width=&465& data-original=&https://pic2.zhimg.com/v2-ccdda427e1037_r.jpg&&&/figure&&figure&&img src=&https://pic3.zhimg.com/v2-bcdd6d9d94bea8082c44_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&514& data-rawheight=&96& class=&origin_image zh-lightbox-thumb& width=&514& data-original=&https://pic3.zhimg.com/v2-bcdd6d9d94bea8082c44_r.jpg&&&/figure&&figure&&img src=&https://pic1.zhimg.com/v2-62cd41bf65feb3eb5e689_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&876& data-rawheight=&288& class=&origin_image zh-lightbox-thumb& width=&876& data-original=&https://pic1.zhimg.com/v2-62cd41bf65feb3eb5e689_r.jpg&&&/figure&&p&3，为了让模型能够学习到更多的信息，作者又提出Input-feeding的方法，也就是将计算出的ht传递到下一时刻的输入中，如下图所示：&/p&&figure&&img src=&https://pic4.zhimg.com/v2-578cd78d3ffd97f1bbeeb99_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&321& data-rawheight=&329& class=&content_image& width=&321&&&/figure&&h2&&b&Seq-to-Seq with Beam-Search&/b&&/h2&&p&上面讲的几种Seq-to-Seq模型都是从模型结构上进行的改进，也就说为了从训练的层面上改善模型的效果，但这里要介绍的beam-search是在测试的时候才用到的技术。我们先来说一下一般的方法，也就是&b&greedy search&/b&，在进行解码的时候，每一步都选择概率最大的那个词作为输出，然后再将这个词作为下一解码时刻的输入传递进去。以此类推，直到输出&EOS&符号为止，我们最终会获得一个概率最大的序列当做是解码的输出。但是这么做的缺点就是，某一步的错误输出可能会导致后面整个输出序列都发生错误，那么改进的方案就是&b&beam-search&/b&，思路也很简单，就是每次都选择概率最大的k个词（beam size）作为输出，并在下一时刻传入RNN进行解码，以此类推。&/p&&p&&br&&/p&&p&举个例子来说明一下，假设我们翻译时的vocab就是A,B,C三个单词，beam size取2,。然后第一次解码时对应概率分别是[0.2，0.5，0.3]，于是我们就选择概率最大的两个B,C作为候选分别传入下一个解码时刻，B的输出概率分别是[0.7, 0.2, 0.1]，C的输出概率分别是[0.3, 0.5, 0.2]，仍然分别去概率最大的两个输出，于是我们得到下面四个序列：BA:0.5&i&*0.7=0.35, BB:0.5*&/i&0.2=0.1, CB:0.3&i&*0.5=0.15, CA:0.3*&/i&0.3=0.09，取概率最大的两个序列就是BA和CB。再继续做下一步。。。接下来每次都会生成K^2个序列，取概率最大的K个最为候选进行下一轮解码输入即可。&/p&&p&&br&&/p&&p&这样做的好处是可以通过增加搜索范围来保证一定的正确率。比如说我们最终得到两个序列ABCCBA和BACBC，虽然第一个步骤中A的概率大于B，但最终BACBC的概率比ABCCBA要大，于是BACBC就作为最终输出序列而且也恰恰是正确答案。参考文献2中提到，beam size等于2时效果就已经不错了，到10以上就不会再有很大提升。&/p&&p&&br&&/p&&h2&&b&参考文献和博客&/b&&/h2&&p&1. &a href=&https://link.zhihu.com/?target=https%3A//arxiv.org/pdf/.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation&/a&&/p&&p&2. &a href=&https://link.zhihu.com/?target=https%3A//arxiv.org/pdf/.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Sequence to Sequence Learning with Neural Networks&/a&&/p&&p&3. &a href=&https://link.zhihu.com/?target=https%3A//arxiv.org/pdf/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Neural Machine Translation by Jointly Learning to Align and Translate&/a&&/p&&p&4. &a href=&https://link.zhihu.com/?target=https%3A//arxiv.org/pdf/.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Grammar as a Foreign Language&/a&&/p&&p&5. &a href=&https://link.zhihu.com/?target=https%3A//arxiv.org/pdf/.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&On Using Very Large Target Vocabulary for Neural Machine Translation&/a&&/p&&p&6.&a href=&https://link.zhihu.com/?target=https%3A//arxiv.org/pdf/.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&A Neural Conversational Model&/a&&/p&&p&7. &a href=&https://link.zhihu.com/?target=http%3A//aclweb.org/anthology/D15-1166& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Effective Approaches to Attention-based Neural Machine Translation&/a&&/p&&p&8. Addressing the Rare Word Problem in Neural Machine Translation&/p&&p&9. &a href=&https://link.zhihu.com/?target=https%3A//arxiv.org/pdf/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Show, Attend and Tell: Neural Image Caption Generation with Visual Attention&/a&&/p&&p&10. &a href=&https://link.zhihu.com/?target=https%3A//guillaumegenthial.github.io/sequence-to-sequence.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Seq2Seq with Attention and Beam Search&/a&&/p&&p&11. &a href=&https://link.zhihu.com/?target=http%3A//www.shuang0420.com//NLP%%25AC%%25AE%25B0%Machine%2520Translation-Neuron%2520models/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&NLP 笔记 - Neural Machine Translation&/a&&/p&&p&12. &a href=&https://link.zhihu.com/?target=http%3A//blog.csdn.net/u/article/details/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&神经网络机器翻译Neural Machine Translation(2): Attention Mechanism&/a&&/p&
上一篇文章已经介绍了几篇关于Seq-to-Seq模型的论文和应用，这里就主要从具体的模型细节、公式推导、结构图以及变形等几个方向详细介绍一下Seq-to-Seq模型。这里我们主要从下面几个层次来进行介绍：Seq-to-Seq框架1Seq-to-Seq框架2Seq-to-Seq with Attentio…
&figure&&img src=&https://pic3.zhimg.com/v2-da6e908fbff06e8e14c60d86d776d225_b.jpg& data-rawwidth=&768& data-rawheight=&576& class=&origin_image zh-lightbox-thumb& width=&768& data-original=&https://pic3.zhimg.com/v2-da6e908fbff06e8e14c60d86d776d225_r.jpg&&&/figure&&p&&/p&&figure&&img src=&https://pic1.zhimg.com/v2-abd42bbb61ee_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&558& data-rawheight=&315& class=&origin_image zh-lightbox-thumb& width=&558& data-original=&https://pic1.zhimg.com/v2-abd42bbb61ee_r.jpg&&&/figure&&p&作为一名久经片场的老司机，早就想写一些探讨驾驶技术的文章。这篇就介绍利用生成式对抗网络（GAN）的两个基本驾驶技能：&br&&/p&&p&1) 去除(爱情)动作片中的马赛克&/p&&p&2) 给(爱情)动作片中的女孩穿(tuo)衣服&/p&&p&&br&&/p&&h2&生成式模型&/h2&&p&上一篇《&a href=&https://zhuanlan.zhihu.com/p/& class=&internal&&用GAN生成二维样本的小例子&/a&》中已经简单介绍了GAN，这篇再简要回顾一下生成式模型，算是补全一个来龙去脉。&/p&&p&生成模型就是能够产生指定分布数据的模型，常见的生成式模型一般都会有一个用于产生样本的简单分布。例如一个均匀分布，根据要生成分布的概率密度函数，进行建模，让均匀分布中的样本经过变换得到指定分布的样本，这就可以算是最简单的生成式模型。比如下面例子：&/p&&figure&&img src=&https://pic1.zhimg.com/v2-d11b5fb26d3cc8e942f841bafe010cd8_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&1021& data-rawheight=&443& class=&origin_image zh-lightbox-thumb& width=&1021& data-original=&https://pic1.zhimg.com/v2-d11b5fb26d3cc8e942f841bafe010cd8_r.jpg&&&/figure&&p&图中左边是一个自定义的概率密度函数，右边是相应的1w个样本的直方图，自定义分布和生成这些样本的代码如下：&br&&/p&&div class=&highlight&&&pre&&code class=&language-python&&&span&&/span&&span class=&kn&&from&/span& &span class=&nn&&functools&/span& &span class=&kn&&import&/span& &span class=&n&&partial&/span&
&span class=&kn&&import&/span& &span class=&nn&&numpy&/span&
&span class=&kn&&from&/span& &span class=&nn&&matplotlib&/span& &span class=&kn&&import&/span& &span class=&n&&pyplot&/span&
&span class=&c1&&# Define a PDF&/span&
&span class=&n&&x_samples&/span& &span class=&o&&=&/span& &span class=&n&&numpy&/span&&span class=&o&&.&/span&&span class=&n&&arange&/span&&span class=&p&&(&/span&&span class=&o&&-&/span&&span class=&mi&&3&/span&&span class=&p&&,&/span& &span class=&mf&&3.01&/span&&span class=&p&&,&/span& &span class=&mf&&0.01&/span&&span class=&p&&)&/span&
&span class=&n&&PDF&/span& &span class=&o&&=&/span& &span class=&n&&numpy&/span&&span class=&o&&.&/span&&span class=&n&&empty&/span&&span class=&p&&(&/span&&span class=&n&&x_samples&/span&&span class=&o&&.&/span&&span class=&n&&shape&/span&&span class=&p&&)&/span&
&span class=&n&&PDF&/span&&span class=&p&&[&/span&&span class=&n&&x_samples&/span& &span class=&o&&&&/span& &span class=&mi&&0&/span&&span class=&p&&]&/span& &span class=&o&&=&/span& &span class=&n&&numpy&/span&&span class=&o&&.&/span&&span class=&n&&round&/span&&span class=&p&&(&/span&&span class=&n&&x_samples&/span&&span class=&p&&[&/span&&span class=&n&&x_samples&/span& &span class=&o&&&&/span& &span class=&mi&&0&/span&&span class=&p&&]&/span& &span class=&o&&+&/span& &span class=&mf&&3.5&/span&&span class=&p&&)&/span& &span class=&o&&/&/span& &span class=&mi&&3&/span&
&span class=&n&&PDF&/span&&span class=&p&&[&/span&&span class=&n&&x_samples&/span& &span class=&o&&&=&/span& &span class=&mi&&0&/span&&span class=&p&&]&/span& &span class=&o&&=&/span& &span class=&mf&&0.5&/span& &span class=&o&&*&/span& &span class=&n&&numpy&/span&&span class=&o&&.&/span&&span class=&n&&cos&/span&&span class=&p&&(&/span&&span class=&n&&numpy&/span&&span class=&o&&.&/span&&span class=&n&&pi&/span& &span class=&o&&*&/span& &span class=&n&&x_samples&/span&&span class=&p&&[&/span&&span class=&n&&x_samples&/span& &span class=&o&&&=&/span& &span class=&mi&&0&/span&&span class=&p&&])&/span& &span class=&o&&+&/span& &span class=&mf&&0.5&/span&
&span class=&n&&PDF&/span& &span class=&o&&/=&/span& &span class=&n&&numpy&/span&&span class=&o&&.&/span&&span class=&n&&sum&/span&&span class=&p&&(&/span&&span class=&n&&PDF&/span&&span class=&p&&)&/span&
&span class=&c1&&# Calculate approximated CDF&/span&
&span class=&n&&CDF&/span& &span class=&o&&=&/span& &span class=&n&&numpy&/span&&span class=&o&&.&/span&&span class=&n&&empty&/span&&span class=&p&&(&/span&&span class=&n&&PDF&/span&&span class=&o&&.&/span&&span class=&n&&shape&/span&&span class=&p&&)&/span&
&span class=&n&&cumulated&/span& &span class=&o&&=&/span& &span class=&mi&&0&/span&
&span class=&k&&for&/span& &span class=&n&&i&/span& &span class=&ow&&in&/span& &span class=&nb&&range&/span&&span class=&p&&(&/span&&span class=&n&&CDF&/span&&span class=&o&&.&/span&&span class=&n&&shape&/span&&span class=&p&&[&/span&&span class=&mi&&0&/span&&span class=&p&&]):&/span&
&span class=&n&&cumulated&/span& &span class=&o&&+=&/span& &span class=&n&&PDF&/span&&span class=&p&&[&/span&&span class=&n&&i&/span&&span class=&p&&]&/span&
&span class=&n&&CDF&/span&&span class=&p&&[&/span&&span class=&n&&i&/span&&span class=&p&&]&/span& &span class=&o&&=&/span& &span class=&n&&cumulated&/span&
&span class=&c1&&# Generate samples&/span&
&span class=&n&&generate&/span& &span class=&o&&=&/span& &span class=&n&&partial&/span&&span class=&p&&(&/span&&span class=&n&&numpy&/span&&span class=&o&&.&/span&&span class=&n&&interp&/span&&span class=&p&&,&/span& &span class=&n&&xp&/span&&span class=&o&&=&/span&&span class=&n&&CDF&/span&&span class=&p&&,&/span& &span class=&n&&fp&/span&&span class=&o&&=&/span&&span class=&n&&x_samples&/span&&span class=&p&&)&/span&
&span class=&n&&u_rv&/span& &span class=&o&&=&/span& &span class=&n&&numpy&/span&&span class=&o&&.&/span&&span class=&n&&random&/span&&span class=&o&&.&/span&&span class=&n&&random&/span&&span class=&p&&(&/span&&span class=&mi&&10000&/span&&span class=&p&&)&/span&
&span class=&n&&x&/span& &span class=&o&&=&/span& &span class=&n&&generate&/span&&span class=&p&&(&/span&&span class=&n&&u_rv&/span&&span class=&p&&)&/span&
&span class=&c1&&# Visualization&/span&
&span class=&n&&fig&/span&&span class=&p&&,&/span& &span class=&p&&(&/span&&span class=&n&&ax0&/span&&span class=&p&&,&/span& &span class=&n&&ax1&/span&&span class=&p&&)&/span& &span class=&o&&=&/span& &span class=&n&&pyplot&/span&&span class=&o&&.&/span&&span class=&n&&subplots&/span&&span class=&p&&(&/span&&span class=&n&&ncols&/span&&span class=&o&&=&/span&&span class=&mi&&2&/span&&span class=&p&&,&/span& &span class=&n&&figsize&/span&&span class=&o&&=&/span&&span class=&p&&(&/span&&span class=&mi&&9&/span&&span class=&p&&,&/span& &span class=&mi&&4&/span&&span class=&p&&))&/span&
&span class=&n&&ax0&/span&&span class=&o&&.&/span&&span class=&n&&plot&/span&&span class=&p&&(&/span&&span class=&n&&x_samples&/span&&span class=&p&&,&/span& &span class=&n&&PDF&/span&&span class=&p&&)&/span&
&span class=&n&&ax0&/span&&span class=&o&&.&/span&&span class=&n&&axis&/span&&span class=&p&&([&/span&&span class=&o&&-&/span&&span class=&mf&&3.5&/span&&span class=&p&&,&/span& &span class=&mf&&3.5&/span&&span class=&p&&,&/span& &span class=&mi&&0&/span&&span class=&p&&,&/span& &span class=&n&&numpy&/span&&span class=&o&&.&/span&&span class=&n&&max&/span&&span class=&p&&(&/span&&span class=&n&&PDF&/span&&span class=&p&&)&/span&&span class=&o&&*&/span&&span class=&mf&&1.1&/span&&span class=&p&&])&/span&
&span class=&n&&ax1&/span&&span class=&o&&.&/span&&span class=&n&&hist&/span&&span class=&p&&(&/span&&span class=&n&&x&/span&&span class=&p&&,&/span& &span class=&mi&&100&/span&&span class=&p&&)&/span&
&span class=&n&&pyplot&/span&&span class=&o&&.&/span&&span class=&n&&show&/span&&span class=&p&&()&/span&
&/code&&/pre&&/div&&p&对于一些简单的情况，我们会假设已知有模型可以很好的对分布进行建模，缺少的只是合适的参数。这时候很自然只要根据观测到的样本，学习参数让当前观测到的样本下的似然函数最大，这就是最大似然估计(&b&M&/b&aximum &b&L&/b&ikelihood &b&E&/b&stimation)：&br&&/p&&p&&img src=&https://www.zhihu.com/equation?tex=%5Chat%7B%5Ctheta%7D%3D%5Coperatorname%2A%7Bargmax%7D_%7B%5Ctheta%7D+P%28%5Cbm%7Bx%7D%7C%5Ctheta%29+%3D+%5Coperatorname%2A%7Bargmax%7D_%7B%5Ctheta%7D+%5Cprod_%7Bi%3D1%7D%5E%7Bn%7DP%28x_i%7C%5Ctheta%29+& alt=&\hat{\theta}=\operatorname*{argmax}_{\theta} P(\bm{x}|\theta) = \operatorname*{argmax}_{\theta} \prod_{i=1}^{n}P(x_i|\theta) & eeimg=&1&&&/p&&p&MLE是一个最基本的思路，实践中用得很多的还有KL散度(Kullback–Leibler divergence)，假设真实分布是P，采样分布是Q，则KL散度为：&/p&&p&&img src=&https://www.zhihu.com/equation?tex=D_%7BKL%7D%28P%7C%7CQ%29%3D%5Csum_%7Bx+%5Cin+%5COmega%7DP%28%7Bx%7D%29%5Clog%5Cfrac%7BP%28x%29%7D%7BQ%28x%29%7D+& alt=&D_{KL}(P||Q)=\sum_{x \in \Omega}P({x})\log\frac{P(x)}{Q(x)} & eeimg=&1&&&/p&&p&从公式也能看出来，KL散度描述的是两个分布的差异程度。换个角度来看，让产生的样本和原始分布接近，也就是要让这俩的差异减小，所以最小化KL散度就等同于MLE。从公式上来看的话，我们考虑把公式具体展开一下：&/p&&p&&br&&/p&&p&&img src=&https://www.zhihu.com/equation?tex=%5Cbegin%7Balign%7D+D_%7BKL%7D%28P%7C%7CQ%29+%26%3D%5Csum_%7Bx+%5Cin+%5COmega%7DP%28%7Bx%7D%29%5Clog%5Cfrac%7BP%28x%29%7D%7BQ%28x%29%7D+%5C%5C+%26+%3D-%5Csum_%7Bx%5Cin%5COmega%7DP%28%7Bx%7D%29%5Clog%7BQ%28x%29%7D+%2B%5Csum_%7Bx%5Cin%5COmega%7DP%28%7Bx%7D%29%5Clog%7BP%28x%29%7D+%5C%5C+%26+%3D-%5Csum_%7Bx%5Cin%5COmega%7DP%28%7Bx%7D%29%5Clog%7BQ%28x%29%7D+%2BH%28P%29+%5Cend%7Balign%7D& alt=&\begin{align} D_{KL}(P||Q) &=\sum_{x \in \Omega}P({x})\log\frac{P(x)}{Q(x)} \\ & =-\sum_{x\in\Omega}P({x})\log{Q(x)} +\sum_{x\in\Omega}P({x})\log{P(x)} \\ & =-\sum_{x\in\Omega}P({x})\log{Q(x)} +H(P) \end{align}& eeimg=&1&&&/p&&p&公式的第二项就是熵，先不管这项，用H(P)表示。接下来考虑一个小trick：从Q中抽样n个样本&img src=&https://www.zhihu.com/equation?tex=%7Bx_1%2Cx_2%2C...%2Cx_n%7D& alt=&{x_1,x_2,...,x_n}& eeimg=&1&&，来估算P(x)的经验值(empirical density function)：&br&&/p&&p&&img src=&https://www.zhihu.com/equation?tex=%5Chat%7BP%7D%28x%29%3D%5Cfrac+1+n+%5Csum_%7Bi%3D1%7D%5En+%5Cdelta%28x_i-x%29& alt=&\hat{P}(x)=\frac 1 n \sum_{i=1}^n \delta(x_i-x)& eeimg=&1&&&/p&&p&其中&img src=&https://www.zhihu.com/equation?tex=%5Cdelta%28%5Ccdot%29& alt=&\delta(\cdot)& eeimg=&1&&是狄拉克&img src=&https://www.zhihu.com/equation?tex=%5Cdelta& alt=&\delta& eeimg=&1&&函数，把这项替换到上面公式的P(x)：&/p&&p&&br&&/p&&p&&img src=&https://www.zhihu.com/equation?tex=%5Cbegin%7Balign%7D+D_%7BKL%7D%28P%7C%7CQ%29+%26%3D-%5Csum_%7Bx%5Cin%5COmega%7D%5Cfrac+1+n+%5Csum_%7Bi%3D1%7D%5En+%5Cdelta%28x_i-x%29%5Clog%7BQ%28x%29%7D+%2BH%28P%29+%5C%5C+%26+%3D-%5Cfrac+1+n+%5Csum_%7Bi%3D1%7D%5En+%5Csum_%7Bx%5Cin%5COmega%7D+%5Cdelta%28x_i-x%29%5Clog%7BQ%28x%29%7D+%2BH%28P%29+%5Cend%7Balign%7D& alt=&\begin{align} D_{KL}(P||Q) &=-\sum_{x\in\Omega}\frac 1 n \sum_{i=1}^n \delta(x_i-x)\log{Q(x)} +H(P) \\ & =-\frac 1 n \sum_{i=1}^n \sum_{x\in\Omega} \delta(x_i-x)\log{Q(x)} +H(P) \end{align}& eeimg=&1&&&/p&&p&因为是离散的采样值，所以&img src=&https://www.zhihu.com/equation?tex=%5Csum_%7Bx%5Cin%5COmega%7D+%5Cdelta%28x_i-x%29& alt=&\sum_{x\in\Omega} \delta(x_i-x)& eeimg=&1&&中只有&img src=&https://www.zhihu.com/equation?tex=x%3Dx_i& alt=&x=x_i& eeimg=&1&&的时候狄拉克&img src=&https://www.zhihu.com/equation?tex=%5Cdelta& alt=&\delta& eeimg=&1&&函数才为1，所以考虑&img src=&https://www.zhihu.com/equation?tex=x%3Dx_i& alt=&x=x_i& eeimg=&1&&时这项直接化为1：&/p&&p&&br&&/p&&p&&img src=&https://www.zhihu.com/equation?tex=D_%7BKL%7D%28P%7C%7CQ%29+%3D-%5Cfrac+1+n%5Csum_%7Bi%3D1%7D%5En+%5Clog%7BQ%28x_i%29%7D+%2BH%28P%29& alt=&D_{KL}(P||Q) =-\frac 1 n\sum_{i=1}^n \log{Q(x_i)} +H(P)& eeimg=&1&&&/p&&p&第一项正是似然的负对数形式。&/p&&p&说了些公式似乎跑得有点远了，其实要表达还是那个简单的意思：通过减小两个分布的差异可以让一个分布逼近另一个分布。仔细想想，这正是GAN里面adversarial loss的做法。&/p&&p&很多情况下我们面临的是更为复杂的分布，比如&a href=&https://zhuanlan.zhihu.com/p/& class=&internal&&上篇文章&/a&中的例子，又或是实际场景中更复杂的情况，比如生成不同人脸的图像。这时候，作为具有universal approximation性质的神经网络是一个看上去不错的选择[1]：&br&&/p&&figure&&img src=&https://pic4.zhimg.com/v2-6fee20494f50baae2c1dc5fc_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&1561& data-rawheight=&549& class=&origin_image zh-lightbox-thumb& width=&1561& data-original=&https://pic4.zhimg.com/v2-6fee20494f50baae2c1dc5fc_r.jpg&&&/figure&&p&所以虽然GAN里面同时包含了生成网络和判别网络，但本质来说GAN的目的还是生成模型。从生成式模型的角度，Ian Goodfellow总结过一个和神经网络相关生成式方法的“家谱”[1]：&/p&&figure&&img src=&https://pic1.zhimg.com/v2-8c6f1d8ee39dfbb4fcfb2_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&771& data-rawheight=&498& class=&origin_image zh-lightbox-thumb& width=&771& data-original=&https://pic1.zhimg.com/v2-8c6f1d8ee39dfbb4fcfb2_r.jpg&&&/figure&&p&在这其中，当下最流行的就是GAN和&b&V&/b&ariational &b&A&/b&uto&b&E&/b&ncoder(VAE)，两种方法的一个简明示意如下[3]：&/p&&figure&&img src=&https://pic1.zhimg.com/v2-380cde71a2f6ece28b4a97_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&568& data-rawheight=&274& class=&origin_image zh-lightbox-thumb& width=&568& data-original=&https://pic1.zhimg.com/v2-380cde71a2f6ece28b4a97_r.jpg&&&/figure&&p&本篇不打算展开讲什么是VAE，不过通过这个图，和名字中的autoencoder也大概能知道，VAE中生成的loss是基于重建误差的。而只基于重建误差的图像生成，都或多或少会有图像模糊的缺点，因为误差通常都是针对全局。比如基于MSE(Mean Squared Error)的方法用来生成超分辨率图像，容易出现下面的情况[4]：&/p&&p&&br&&/p&&p&&br&&/p&&figure&&img src=&https://pic1.zhimg.com/v2-78f53b142fab51b0c09a1_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&892& data-rawheight=&598& class=&origin_image zh-lightbox-thumb& width=&892& data-original=&https://pic1.zhimg.com/v2-78f53b142fab51b0c09a1_r.jpg&&&/figure&&p&在这个二维示意中，真实数据分布在一个U形的流形上，而MSE系的方法因为loss的形式往往会得到一个接近平均值所在的位置（蓝色框）。&/p&&p&GAN在这方面则完爆其他方法，因为目标分布在流形上。所以只要大概收敛了，就算生成的图像都看不出是个啥，清晰度常常是有保证的，而这正是去除女优身上马赛克的理想特性！&/p&&p&&br&&/p&&h2&马赛克-&清晰画面：超分辨率(Super Resolution)问题&/h2&&p&说了好些铺垫，终于要进入正题了。首先明确，去马赛克其实是个图像超分辨率问题，也就是如何在低分辨率图像基础上得到更高分辨率的图像：&/p&&figure&&img src=&https://pic2.