人工智能应用-实验7-胶囊网络分类minst手写数据集

文章目录

🧡🧡实验内容🧡🧡

编写胶囊网络分类软件(编程语言不限,如 Python 等),实现对 MNIST 数据集分类的操作。


🧡🧡代码🧡🧡

python 复制代码
import torch
from torch import nn
from torch.optim import Adam
import torch.nn.functional as F
from torchvision import transforms, datasets
import time
import matplotlib.pyplot as plt

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

train_set = datasets.MNIST('data', train=True, download=True, transform=transform)
test_set = datasets.MNIST('data', train=False, download=True, transform=transform)

train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=1000, shuffle=True)


# !nvidia - smi
# 检查GPU是否可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)


# @title 胶囊 net
def squash(inputs, axis=-1):
    inputs = inputs.to(device)
    norm = torch.norm(inputs, p=2, dim=axis, keepdim=True)
    scale = norm ** 2 / (1 + norm ** 2) / (norm + 1e-8)
    return scale * inputs


# 预胶囊层
class PrimaryCapsule(nn.Module):
    def __init__(self, in_channels, out_channels, dim_caps, kernel_size, stride=1, padding=0):
        super(PrimaryCapsule, self).__init__()
        self.dim_caps = dim_caps
        self.conv2d = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding)

    def forward(self, x):
        outputs = self.conv2d(x)
        outputs = outputs.view(x.size(0), -1, self.dim_caps)
        return squash(outputs)


# 胶囊层(重构层)
class DenseCapsule(nn.Module):
    def __init__(self, in_num_caps, in_dim_caps, out_num_caps, out_dim_caps, routings=3):
        super(DenseCapsule, self).__init__()
        self.in_num_caps = in_num_caps
        self.in_dim_caps = in_dim_caps
        self.out_num_caps = out_num_caps
        self.out_dim_caps = out_dim_caps
        self.routings = routings
        self.weight = nn.Parameter(0.01 * torch.randn(out_num_caps, in_num_caps, out_dim_caps, in_dim_caps))

    def forward(self, x):
        x_hat = torch.squeeze(torch.matmul(self.weight, x[:, None, :, :, None]), dim=-1)
        x_hat_detached = x_hat.detach()  # 通过detach()方法获得的张量不再具有梯度,即它是一个常量张量,不会对反向传播产生影响。
        # The prior for coupling coefficient, initialized as zeros.
        # b.size = [batch, out_num_caps, in_num_caps]
        b = torch.zeros(x.size(0), self.out_num_caps, self.in_num_caps)
        b = b.to(device)
        # print(f"b shape={b.shape}")
        assert self.routings > 0, 'The \'routings\' should be > 0.'
        for i in range(self.routings):
            # c.size = [batch, out_num_caps, in_num_caps]
            c = F.softmax(b, dim=1)
            c = c.to(device)
            # print(f"c shape={c.shape}")
            if i == self.routings - 1:
                # dim=-2:倒数第二个维度求和, keepdim=True:保持计算前后维度不变
                outputs = squash(torch.sum(c[:, :, :, None] * x_hat, dim=-2, keepdim=True))
            else:  # Otherwise, use `x_hat_detached` to update `b`. No gradients flow on this path.
                outputs = squash(torch.sum(c[:, :, :, None] * x_hat_detached, dim=-2, keepdim=True))
                b = b + torch.sum(outputs * x_hat_detached, dim=-1)
        # print(f"outputs shape={torch.squeeze(outputs, dim=-2).shape}")
        return torch.squeeze(outputs, dim=-2)  # 将倒数第二维去掉


# 组合以上
class CapsuleNet(nn.Module):
    def __init__(self, input_size, classes, routings):
        super(CapsuleNet, self).__init__()
        self.input_size = input_size
        self.classes = classes
        self.routings = routings

        # Layer 1: Just a conventional Conv2D layer
        self.conv1 = nn.Conv2d(
            input_size[0], 256, kernel_size=9, stride=1, padding=0)

        # Layer 2: Conv2D layer with `squash` activation, then reshape to [None, num_caps, dim_caps]
        self.primarycaps = PrimaryCapsule(
            256, 256, 8, kernel_size=9, stride=2, padding=0)

        # Layer 3: Capsule layer. Routing algorithm works here.
        self.digitcaps = DenseCapsule(in_num_caps=32 * 6 * 6, in_dim_caps=8,
                                      out_num_caps=classes, out_dim_caps=16, routings=routings)

        self.relu = nn.ReLU()

    def forward(self, x, y=None):
        x = self.relu(self.conv1(x))
        x = self.primarycaps(x)
        x = self.digitcaps(x)
        # 对(64,10,16),计算最后一维向量的长度,即对应10个分类类别的存在概率,16蕴含特征的空间、局部位置等信息
        length = x.norm(dim=-1)
        return length


# @title Train and Test
def test(data_iter, net):
    acc_sum, n = 0.0, 0
    with torch.no_grad():
        for X, y in data_iter:
            X = X.to(device)
            y = y.to(device)
            if isinstance(net, torch.nn.Module):
                net.eval()  # 评估模式, 这会关闭dropout
                acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
                net.train()  # 改回训练模式
            else:
                if ('is_training' in net.__code__.co_varnames):  # 如果有is_training这个参数
                    # 将is_training设置成False
                    acc_sum += (net(X, is_training=False).argmax(dim=1) == y).float().sum().item()
                else:
                    acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
            n += y.shape[0]
    return acc_sum / n


def train(train_iter, test_iter, net, loss, optimizer, epochs):
    batch_count = 0
    loss_list = []
    test_acc_list = []

    for epoch in range(epochs):
        train_loss_sum, train_acc_sum, n, start = 0.0, 0.0, 0, time.time()
        for X, y in train_iter:
            X = X.to(device)
            y = y.to(device)
            y_hat = net(X)
            l = loss(y_hat, y)
            optimizer.zero_grad()
            l.backward()
            optimizer.step()
            train_loss_sum += l.item()
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
            n += y.shape[0]
            batch_count += 1
            # print(f"batch_count: {batch_count}")
        test_acc = test(test_iter, net)
        loss_list.append(train_loss_sum / batch_count)
        test_acc_list.append(test_acc)
        print('==========Epoch=%d========== \nloss=%.4f, train_acc=%.5f, test_acc=%.5f, time %f min'
              % (epoch + 1, train_loss_sum / batch_count, train_acc_sum / n,
                 test_acc, (time.time() - start) / 60))
    # 绘制损失函数随训练轮数的变化图
    plt.plot(range(1, epochs + 1), loss_list)
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.title('Training Loss')
    plt.show()
    # 绘制准确率随训练轮数的变化图
    plt.plot(range(1, epochs + 1), test_acc_list)
    plt.xlabel('Epochs')
    plt.ylabel('acc')
    plt.title('Test acc')
    plt.show()


batch_size, lr, epochs = 100, 0.001, 4
net = CapsuleNet(input_size=[1, 28, 28], classes=10, routings=8)
net = net.to(device)
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
loss = nn.CrossEntropyLoss()
loss = loss.to(device)
train(train_loader, test_loader, net, loss, optimizer, epochs)

🧡🧡分析结果🧡🧡

数据预处理:

加载数据集:

加载torch库中自带的minst数据集

转换数据:

转为tensor变量(相当于直接除255归一化到值域为(0,1)),再设置mean和st

d标准化到(-1,1)区间。
设置基本参数:

构建胶囊网络:

  • 第一层:(64,28,28,1) => (64,20,20,256)
    • 卷积核大小为9,步长为1,故图片由28×28缩小为20×20,输出特征数设为256
  • 第二层:(64, 20, 20, 256) => (64,6,6,256) => (64, 1152, 8)
    • 先进行一层卷积操作,卷积核大小为9,步长为2,故图片由20×20缩小为6×6,输出特征数仍然为256。
    • 将输出通道数256分割成32×8的向量,合并中间维度(64, 6×6×32, 8) =>(64, 1152, 8),即有1152个胶囊,每个胶囊维度为8。
      进行squash激活。
  • 第三层:(64, 1152, 8) => (64, 10, 16)
    • 输入的胶囊个数为1152,维度为8,目标是转为胶囊个数为10,维度为16。
    • 对输入向量扩维:(64, 1152, 8) =>(64, 1, 1152, 8, 1),然后使用维度为 (1, 10, 1152, 16, 8)的权重w与其进行矩阵乘法,得到x_hat ,其维度为(64, 10, 1152, 16, 1),去除最后一维,维度变成 (64, 10, 1152, 16)。
    • 设置初始权重b,其维度为(64, 10, 1152, 1),使用动态路由算法将归一化后的b与x_hat多次相乘并累加,得到维度为(64, 10, 1, 16)的向量,去除倒数第二个维度,最后变为(64, 10, 16)的输出向量。
  • 输出结果:(64, 10, 16) => (64, 10)
    • 64代表batch_size,10代表10个图片分类标签,16代表这10个向量所具有的空间、相对位置等相关信息(CNN则没有),通过计算这10个向量的长度,即可得到分类概率。

      模型训练与评估:

可以看到,设置了4个epoch,准确率即达到了98.7%, 高于CNN和BP。



分析胶囊参数对分类准确率的影响

更改胶囊参数原则:

在卷积核参数不变的情况下,主要第二层预胶囊层中的输出胶囊维度,然后自己手算第二层预胶囊层的输出个数;之后第三层胶囊层的输入胶囊个数和维度同第二层的胶囊输出维度,第三层胶囊层个数为10固定不变(因为有10个类别),胶囊层维度可以更改。

被对照实验:

输入胶囊个数=1152、输入胶囊维度=8、输出胶囊个数=10、输出胶囊维度=16

参照问题1,准确率为98.70%,运行时间为4.931 minutes
对照实验1:

输入胶囊个数=512、输入胶囊维度=16、输出胶囊个数=10、输出胶囊维度=16


对照实验2:

输入胶囊个数=512、输入胶囊维度=16、输出胶囊个数=10、输出胶囊维度=32


对照实验3:

输入胶囊个数=512、输入胶囊维度=16、输出胶囊个数=10、输出胶囊维度=8

总结以上结果如下表(epoch=4):

(表格中的"输入输出"指的是第三层胶囊层的输入输出胶囊)

由此分析可知:

  • 输入胶囊个数和维度:
    在第一行和第二行中,更改第三层的输入胶囊个数和维度,一方面增加了输入胶囊的维度,使得每个胶囊能够表示更多的特征信息,从而提高了分类准确率;另一方面胶囊个数减少,从而减少了运行时间。
  • 输出胶囊个数和维度:
    观察第二、三行、四行,可以看到随着输出胶囊维度减小,分类准确率得到提高,且模型运行时间相应减少。据此判断胶囊维度小,浓缩了对判断分类最为有利的特征信息,减少了冗余无用的干扰信息,因此使得准确率得到提高。

🧡🧡实验总结🧡🧡

理论理解方面:

胶囊网络与CNN卷积网络的主要区别:

  • CNN擅长提取图像中的局部特征,其中,池化层可以降低采样数,将一个邻域的重要特征提取出来以代表区域特征,但是,也正因为此,池化层的计算过程中会损失空间特征,即特征组合的相对信息位置。例如对于一张人脸图像,CNN很容易提取出眼睛、嘴巴、鼻子这些局部的重要的特征,但是眼睛、嘴巴、鼻子之间的相对位置关系却无法获得。

  • 基于以上CNN存在的问题,而提出了胶囊网络的概念,胶囊网络中的胶囊单元(包含许多神经元)能够捕捉图像中的层次结构和空间关系,并且设计了动态路由算法来实现胶囊之间的信息传递和姿态估计。
    代码实操方面:

  • 首先是运行时间问题,前两次CNN和BP实验中,用CPU跑,分别设计epoch=5和epoch=15,运行时间在3-4min左右,而本次实验,我首先用的CPU跑,但是跑了半个小时仍然没有完成一个epoch,于是感叹它的复杂性。好在Google colab自带免费的GPU,才解决了我的燃眉之急。本实验中,一开始设置为epoch=5时,超过了Google colab自带的GPU算力,运行不下去,只好统一设计为epoch=4。

  • 其次是复杂的矩阵运算。二维矩阵与二维矩阵相乘我还会,但是在重构胶囊信息时,要进行五维矩阵与五维矩阵的乘法,例如维度(64, 10, 1152, 16, 8)的矩阵与维度(64, 1, 1152, 8, 1)进行矩阵乘法,就比较懵了。通过网上学习,了解到:只要看最后两维度相乘,前面的维度通过"维度广播"一般取最大值即可,所以相乘之后的矩阵的维度为(64, 10, 1152, 16, 1)。

相关推荐
一点媛艺2 小时前
Kotlin函数由易到难
开发语言·python·kotlin
魔道不误砍柴功3 小时前
Java 中如何巧妙应用 Function 让方法复用性更强
java·开发语言·python
_.Switch3 小时前
高级Python自动化运维:容器安全与网络策略的深度解析
运维·网络·python·安全·自动化·devops
测开小菜鸟4 小时前
使用python向钉钉群聊发送消息
java·python·钉钉
萧鼎6 小时前
Python并发编程库:Asyncio的异步编程实战
开发语言·数据库·python·异步
学地理的小胖砸6 小时前
【一些关于Python的信息和帮助】
开发语言·python
疯一样的码农6 小时前
Python 继承、多态、封装、抽象
开发语言·python
Python大数据分析@6 小时前
python操作CSV和excel,如何来做?
开发语言·python·excel
黑叶白树6 小时前
简单的签到程序 python笔记
笔记·python
Shy9604186 小时前
Bert完形填空
python·深度学习·bert