学习笔记 （卷积神经网络）

import torch

'''
卷积神经网络
    卷积神经网络尝试解决两个问题
        卷积神经网络保留了输入形状，使图形的像素在高和宽两个方向上的相关性均可能被有效识别
        卷积层通过滑动窗口将同一卷积核与不同位置的输入重复计算，从而避免参数尺寸过大
    卷积神经网络就是含有卷积层的网络
    手写数字图像的卷积神经网络
        LeNet展示了通过梯度下降训练，卷积神经⽹络可以达到⼿写数字识别在当时最先进的结果
    LENET模型
        LENET模型分为卷积层块和全连接层块两个部分。
            卷积层块里的基本单位是卷积层后接最大池化层：卷积层用来识别图像里面的空间模式，比如线条或者物体
            局部，之后的最大池化层则用来降低卷积层对位置的敏感性。卷积层块由两个这样的基本单位重复堆叠构成。
            在卷积层块中，每个卷积层都使用5*5的窗口，并在输出上使用sigmoid激活函数。第一个卷积层通道输出数
            为6，第二个卷积层输出通道数则增加到16。这是因为第二个卷积层比第一个卷积层的输入的高和宽要小，所以
            要增加输出通道使两个卷积层的参数尺寸类似。卷积层块的两个最大池化层的窗口形状均为2*2，且步幅为2
            由于池化窗口跟步幅形状相同   ，池化窗口在输入上每次滑动所覆盖的区域互不重叠
            
        卷积层块的输出形状为(批量大小,通道,高,宽)。当卷积层块的输出传入全连接层时，全连接层块会将小批量中每个
        样本变平。也就是说，全连接层的输入形状将变成二维，其中一维是小批量样本，另外一个是每个样本变平后的向量
        表示向量长度为通道，高和宽的乘积。全连接层块包括3个全连接层，他们的输出个数分别是120,84，10，其中10位
        输出类别的个数。
            
'''
import time
from torch import nn, optim

import sys

sys.path.append('..')
import d2lzh_pytorch as d2l

device = torch.device('cpu')


class LENET(nn.Module):
    def __init__(self):
        super(LENET, self).__init__()
        '''
        nn.Conv2d(1, 6, 5) in_channels, out_channels,kernel_size
        nn.MaxPool2d(2, 2) kernel_size, stride
        '''
        self.conv = nn.Sequential(
            nn.Conv2d(1, 6, 5),
            nn.Sigmoid(),
            nn.MaxPool2d(2, 2),
            nn.Conv2d(6, 16, 5),
            nn.Sigmoid(),
            nn.MaxPool2d(2, 2),
        )
        self.fc = nn.Sequential(
            nn.Linear(16 * 4 * 4, 120),
            nn.Sigmoid(),
            nn.Linear(120, 84),
            nn.Sigmoid(),
            nn.Linear(84, 10),
        )

    def forward(self, img):
        feature = self.conv(img)
        output = self.fc(feature.view(img.shape[0], -1))
        return output


net = LENET()
print(net)

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)


def evaluate_accuracy(data_iter, net, device = torch.device('cuda' if torch.cuda.is_available()else 'cpu')):
    acc_sum, n = 0.0, 0
    with torch.no_grad():
        for x, y in data_iter:
            if isinstance(net, torch.nn.Module):
                net.eval()
                '''评估模式,这个会关闭dropout'''
                acc_sum += (net(x.to(device)).argmax(dim=1) == y.to(device)).float().sum().cpu().item()
                net.train()
                '''改回训练模式'''
            else:
                if ('is_training' in net.__code__.co_varnames):
                    '''# 如果有is_training这个参数'''
                    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_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs):
    net = net.to(device)
    print("training on ", device)
    loss = torch.nn.CrossEntropyLoss()
    batch_count = 0
    for epoch in range(num_epochs):
        train_l_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() # 将参数更新值施加到 net 的 parameters 上
            train_l_sum += l.cpu().item()
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().cpu().item()
            n += y.shape[0]
            batch_count += 1
        test_acc = evaluate_accuracy(test_iter, net)
        print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f, time %.1f sec' % (epoch + 1, train_l_sum / batch_count, train_acc_sum / n, test_acc, time.time() - start))


lr, num_epochs = 0.001, 10
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
train_ch5(net, train_iter, test_iter, batch_size, optimizer, device,
          num_epochs)