InceptionV2网络详解

需要运用到的库

import numpy as np
import torch
import torchvision
from matplotlib import pyplot as plt
from torch import nn
from torch.utils.data import dataloader
from torch.functional import F

数据的预处理

1. RandomHorizontalFlip：随机水平翻转图像。（增加数据量，降低模型的过拟合）
2. RandomGrayscale：随机将图像转换为灰度图像。（提高运算速度）
3. ToTensor：将图像转换为张量。（numpy图像转化为Tensor图像，包含通道数值和梯度信息）
4. Normalize：对张量进行归一化操作，将张量的数值从 [0, 1] 范围映射到 [-1, 1] 范围。

transform = transforms.Compose([transforms.RandomHorizontalFlip(),
                                transforms.RandomGrayscale(),
                                transforms.ToTensor(),
                                transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
                                ])
transform1 = transforms.Compose([transforms.ToTensor(),
                                 transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
                                 ])

归一化

将每个每个颜色通道的数值范围缩放到0，1之间，这个过程有助于提高图像处理的稳定性和收敛速度

说明：假设第一张图片的数值为（2，230，145），权重会根据这张图片来更新参数，第二张图片为（210，20，58）权重又会根据这张图片的数值更新参数，第三张（110，170，225）再次依据这张图片更新参数，三张图片的参数之间差距过大，会导致权重的更新幅度更新幅度大，图像处理的稳定性变低，反复横跳，收敛速度降低，因此归一化有助于提高图像处理的稳定性和收敛速度

超参数设置

mini_batch_size = 256
iters_num = 50  
lr = 0.0015

数据集下载和打包

train_dataset = torchvision.datasets.CIFAR10(root='dataset', train=True, download=True,
                                             transform=transform)
test_dataset = torchvision.datasets.CIFAR10(root='dataset', train=False, download=True,
                                            transform=transform1)  # 读取数据集，并将数据集由numpy类型转化为Tensor
train_dataloader = dataloader.DataLoader(train_dataset, batch_size=mini_batch_size, shuffle=True)
test_dataloader = dataloader.DataLoader(test_dataset, batch_size=mini_batch_size, shuffle=True)

InceptionV2模块

Inception就是将多个卷积或池化操作放在一起组装成一个网络模块，设计神经网络时，以模块为单位去组装整个网络结构。Inception结构设计了一个稀疏网络结构，但是能够产生稠密的数据，既能增加神经网络表现，又能保证计算资源的使用效率。

我们希望网络代替人手工自己决定到底使用1×1，3×3，5×5以及是否需要max_pooling层，由网络自动去寻找适合的结构。并且节省计算提取更为丰富的特征，Inception结构正好满足了这样的需求，因而获得了更好的表现。

在构建模型时，常常不知道哪种神经网络的效果会更好，Inception结构将不同的神经网络统筹到一起，选择时由各个网络对模型影响力不同自己去决定。

左下图为V1，右下图为V2

class Inception(nn.Module):  # inception模块
    def __init__(self, in_channels):
        super(Inception, self).__init__()
        self.module1 = nn.Sequential(
            nn.Conv2d(in_channels, 16, kernel_size=1)
        )
        self.module2 = nn.Sequential(
            nn.Conv2d(in_channels, 16, kernel_size=1),
            nn.Conv2d(16, 24, kernel_size=5, padding=2)
        )
        self.module3 = nn.Sequential(
            nn.Conv2d(in_channels, 16, kernel_size=1),
            nn.Conv2d(16, 24, kernel_size=3, padding=1),
            nn.Conv2d(24, 24, kernel_size=3, padding=1)
        )
        self.module4 = nn.Sequential(
            nn.AvgPool2d(kernel_size=3, stride=1, padding=1),
            nn.Conv2d(in_channels, 24, kernel_size=1)
        )

    def forward(self, x):
        module1 = self.module1(x)
        module2 = self.module2(x)
        module3 = self.module3(x)
        module4 = self.module4(x)

        outputs = [module1, module2, module3, module4]

        return torch.cat(outputs, dim=1)  # cat拼接

InceptionV2模块的使用

padding = Kernel_size/2

class Net(nn.Module):  # 搭建网络
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 10, kernel_size=5, padding=2)
        self.conv2 = nn.Conv2d(112, 20, kernel_size=5, padding = 2)

        self.incep1 = Inception(in_channels=10)
        self.incep2 = Inception(in_channels=20)

        self.mp = nn.MaxPool2d(2)

        self.fc1 = nn.Linear(7168, 64)  #
        self.fc2 = nn.Linear(64, 10)

    def forward(self, x):
        in_size = x.size(0)
        x = F.relu(self.mp(self.conv1(x)))  # 输出为10通道
        x = self.incep1(x)  # 输出为24x3+16=88通道
        x = F.relu((self.mp(self.conv2(x))))  # 输出为20通道
        x = self.incep2(x)  # 输出为88通道
        x = x.view(in_size, -1)  # 将数据展成一维
        x = self.fc1(x)
        x = self.fc2(x)

        return x