10 案例：搭建分类神经网络（基于CIFAR10） 小实战 及 sequential使用

 

CIFAR10模型结构

 

import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter


# class MyNN(nn.Module):
#     def __init__(self):
#         super(MyNN, self).__init__()
#         self.conv1 = Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2, stride=1)
#         self.maxpool1 = MaxPool2d(kernel_size=2)
#         self.conv2 = Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2, stride=1)
#         self.maxpool2 = MaxPool2d(kernel_size=2)
#         self.conv3 = Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2, stride=1)
#         self.maxpool3 = MaxPool2d(kernel_size=2)
#         self.flatten = Flatten()
#         self.linear1 = Linear(1024, 64)
#         self.linear2 = Linear(64, 10)  # 因为CIFAR10是分10个类别，所以最后线性层输出是10
#
#     def forward(self, x):
#         x = self.conv1(x)
#         x = self.maxpool1(x)
#         x = self.conv2(x)
#         x = self.maxpool2(x)
#         x = self.conv3(x)
#         x = self.maxpool3(x)
#         x = self.flatten(x)
#         x = self.linear1(x)
#         x = self.linear2(x)
#         return x


# sequential写法
class MyNN_seq(nn.Module):
    def __init__(self):
        super(MyNN_seq, self).__init__()
        self.model1 = Sequential(
            Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2, stride=1),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2, stride=1),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2, stride=1),
            MaxPool2d(kernel_size=2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)
        return x




# mynn = MyNN()
mynn = MyNN_seq()
print(mynn)

input = torch.ones(64, 3, 32, 32)
output = mynn(input)
print(output.shape)

writer = SummaryWriter("logs")
writer.add_graph(mynn, input)
writer.close()



dataset = torchvision.datasets.CIFAR10(root="D:/Learn/dataSet/Pytorch", train=False, transform=torchvision.transforms.ToTensor(), download=False)
dataloader = DataLoader(dataset, batch_size=1)
# writer = SummaryWriter("logs_NonLinearActivation")

mynn = MyNN_seq()

loss = nn.CrossEntropyLoss()

# 设置优化器
# 一般在学习刚开始时候用大的学习速度，到后期用小的学习速率
optim = torch.optim.SGD(mynn.parameters(), lr=0.01)  # SGD随机梯度下降

# 循环20次（实际，训练都是成百上千甚至上万次）
for epoch in range(20):
    running_loss = 0.0
    for data in dataloader:
        imgs, targets = data
        outputs = mynn(imgs)
        # print(outputs)
        # print(targets)

        # 计算损失函数
        result_loss = loss(outputs, targets)
        # 打印输出，计算得到的实际输出和目标之间的差距
        # print(result_loss)

        # 将网络参数中每一个可以调节参数的梯度调为0
        optim.zero_grad()

        # 反向传播，计算梯度
        result_loss.backward()

        # 调用优化器,进行调优
        optim.step()

        # print(result_loss)
        running_loss = running_loss + result_loss

    # 看每一次循环loss之和
    print(running_loss)

 

输出每次损失函数计算结果（这里没有计算完）

 

打开tensorboard可以看到创建的网络框架图