[论文理解] CapsuleNet

CapsuleNet

前言

找了很多资料，终于把整个流程搞懂了，其实要懂这个运算并不难，难的对我来说是怎么用代码实现，也找了github上的一些代码来看，对我来说都有点冗长，变量分布太远导致我脑袋炸了，所以我就在B站找视频看看有没有代码讲解，算是不负苦心吧，终于把实现部分解决了。

不写论文解读，因为原文实在太难读了，这个老外的英文我基本上每看一句都要取查翻译，很难受，而且网上的教程、解析非常非常之多，所以我留个代码，以后看一下就能想起来了。

Capsule是干什么的

capsule是换了一种神经元的表达方式，原来每个神经元我们是用一个scalar来表示的，现在在capsule中我们中vector来表示一个神经元。这样做的好处是可以多维度描述一个神经元，而在capsue中，我们用vector的模长来表示概率，其他每个维度可以表征神经元的属性。比如某个维度表征特征的朝向，当特征朝向改变时，神经元的模长并没有改变，而是该维度的值改变了，这是一个很好的理解。

这部分网上资料简直太多了，上面说的只是我个人的见解，可以看看别人的版本。

Capsule代码怎么写

网络的结构图还是得贴一张

整体网络分三层，第一层卷积层，将(3,28,28)的输入映射到(256,20,20),第二层称为primary_caps,拿32个filter分8次卷积，得到(32,6,6,8)的输出，然后reshape成(1152,1,8)这里就是为了后面vector in vector out做准备了。

这里表达的意思就是有1152个capsule，每个capsule里有1个8维的vector，老有意思了。

然后就是后面digit_caps层了，我们目标vector应该是(10,1,16)，输入是(1152,1,8)，所以我们在这里思考作者是如何得到这样的映射关系的。

利用动态路由算法，我们成功得到的v。

好，结束。重建的代码我就不写了。

附上总代码：

import torch
import torch.nn as nn
from torchsummary import summary
from torch.autograd import Variable
class CapsuleLayer(nn.Module):
    def __init__(self,routing = False):
        super(CapsuleLayer,self).__init__()
        self.routing = routing
        def create_conv(unit_idx):
            conv_unit = nn.Conv2d(256,32,kernel_size = 9,stride = 2)
            self.add_module("conv_unit_{}".format(unit_idx),conv_unit)
            return conv_unit
        self.conv_units = [create_conv(i) for i in range(8)]
        self.w = Variable(torch.randn(1,1152,10,16))
        self.fc = nn.Linear(8,16)
    def forward(self,x):
        if self.routing:
            return self.use_routing(x)
        else:
            return self.no_routing(x)
    @staticmethod
    def squash(x):
        f = torch.sum(x**2,dim =2,keepdim = True)
        return f / (1 + f) / (x / torch.sqrt(f))
    def use_routing(self,x):# (-1,8,32*6*6)
        x = x.transpose(1,2).view(-1,32*6*6,1,8)
        x = self.fc(x)
        w = torch.cat([self.w] * x.size(0), dim = 0)
        u = w * x # (b,1152,10,8)
        b = Variable(torch.zeros(x.size(0),x.size(1),10,1,1))
        for iter in range(3):
            c = torch.softmax(u,dim = -1)
            s = torch.sum(c,dim = 1,keepdim = True)
            v = self.squash(s).view(-1,1,10,16,1)
            b = b + u.view(x.size(0),1152,10,1,16) @ v.view(x.size(0),1,10,16,1)
        return v.view(x.size(0),10,16)
    def no_routing(self,x):
        u = [self.conv_units[i](x) for i in range(8)]
        # every u (-1,32,6,6)
        # (-1,8,32,6,6)
        u = torch.stack(u,dim =1)
        u = u.view(-1,8,32*6*6)
        return self.squash(u)
class CapsuleNet(nn.Module):
    def __init__(self):
        super(CapsuleNet,self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(1,256,kernel_size = 9,stride = 1),
            nn.ReLU()
        )
        self.pri_caps = CapsuleLayer()
        self.digit_caps = CapsuleLayer(routing = True)
    def forward(self,x):
        x = self.conv(x) # (-1,256,20,20)
        x = self.pri_caps(x)
        x = self.digit_caps(x)
        return x
if __name__ == "__main__":
    x = torch.randn(2,1,28,28)
    net = CapsuleNet()
    y = net(x)
    print(y.size())