代码

从今天起每天的一个，虽然现在是模仿，但是很开心，谢谢

# 构建卷积神经网络
"""卷积网络中的输入层与传统神经网络有些区别，需重新设计，训练模块基本一致"""
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as f
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
import numpy as np

# 1、首先读取数据
"""
分别构建训练集和测试集（验证集）
DataLoader来迭代取数据
"""
# 1.1 定义超参数
input_size = 28  # 图像的总尺寸28*28*1
num_classes = 10  # 标签的种类数
num_epochs = 3  # 训练的总循环周期
batch_size = 64  # 一个撮（批次）的大小，64张图片

# 1.2 训练集
train_dataset = datasets.MNIST(root='./data',
                               train=True,
                               transform=transforms.ToTensor(),
                               download=True)
# 1.3 测试集
test_dataset = datasets.MNIST(root='./data',
                              train=False,
                              transform=transforms.ToTensor())
# 1.4 构建batch数据
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size,
                                          shuffle=True)
# 2、卷积神经网络该怎么构建模块呢？
"""
一般卷积层，relu层，池化层可以写成一个套餐
注意卷积最后结果还是一个特征图，需要把特征图转换成向量才能做分类或者回归任务
"""


class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # 1、第一个卷积模块（单元）
        self.conv1 = nn.Sequential(  # 输入大小（1，28，28）
            nn.Conv2d(
                in_channels=1,  # 当前输入的特征图的个数，因为输入图是灰度图，所以channel=1
                out_channels=16,  # 要得到多少个特征图【输出特征图的个数，这里是用16个卷积核对当前图片进行特征提取，就会得到16个特征图】
                kernel_size=5,  # 卷积核大小【每个多大的小区域进行特征提取】
                stride=1,  # 步长，每个多大进行滑动
                padding=2,
                # 如果希望卷积后大小跟原来一样，需要设置padding=(kernel_size-1)/2 if
                # stride=1【padding的意思，我们对图像做边缘填充，padding=1表示在图像周围加一圈0，写2就是加2圈o】
            ),
            nn.ReLU(),  # relu层
            nn.MaxPool2d(kernel_size=2),  # 进行池化操作（2*2区域),输出结果为：（16，14，14）
        )
        # 2、第二个卷积模块（单元）
        self.conv2 = nn.Sequential(  # 下一套餐的输入（16，14，14）
            nn.Conv2d(16, 32, 5, 1, 1),  # 输出（32，14，14）
            nn.ReLU(),  # Relu层
            nn.MaxPool2d(2),  # 输出（32，7，7）
        )
        self.out = nn.Linear(32 * 6 * 6, 10)  # 全连接层得到的结果

    # 3、前向传播：就是数据走一遍模型
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)  # 【因为下一层要做全连接了，我就把当前结果全部转换成向量的格式】flatten操作，结果为：(batch_size,32*7*7)
        output = self.out(x)  # 最后用向量(*)乘以w后+b
        return output


# 3、准确率作为评估标准
def accuracy(predictions, labels):
    pred = torch.max(predictions.data, 1)[1]
    rights = pred.eq(labels.data.view_as(pred)).sum()
    return rights, len(labels)


# 4、训练网络模型
'1、实例化'
net = CNN()
'2、损失函数'
criterion = nn.CrossEntropyLoss()
'3、定义优化器，普通的随机的梯度下降法'
optizer = optim.Adam(net.parameters(), lr=0.001)
'4、开始循环训练'
for epoch in range(num_epochs):
    '5、当前epoch的结果保存下来'
    train_rights = []
    for batch_idx, (data, target) in enumerate(train_loader):  # 针对容器中的每一个批次进行循环
        net.train()
        output = net(data)
        loss = criterion(output, target)
        loss.backward()
        optizer.step()
        right = accuracy(output, target)
        train_rights.append(right)

        if batch_idx % 100 == 0: # 每隔100次在验证集上看效果是多少
            net.eval()
            val_rights = []
            for (data, target) in test_loader:
                output = net(data)
                right = accuracy(output, target)
                val_rights.append(right)
            # 6、准确率计算
            train_r = (sum([tup[0] for tup in train_rights]), sum([tup[1] for tup in train_rights]))
            val_r = (sum([tup[0] for tup in val_rights]), sum([tup[1] for tup in val_rights]))
            print('当前epoch:{} [{} / {}  ({:.0f}%)]\t损失：{:.6f}\t训练集准确率：{:.2f}\t测试集准确率:{:.2f}'.format(epoch,
                                                                                                    batch_idx * batch_size,
                                                                                                    len(train_loader.dataset),
                                                                                                    100. * batch_idx / len(train_loader),
                                                                                                    loss.data,
                                                                                                    100. * train_r[0].numpy() / train_r[1],
                                                                                                    100. * val_r[0].numpy() / val_r[1]))