《动手学深度学习》6.6卷积神经网络（LeNet）

《动手学深度学习》6.6卷积神经网络（LeNet）

• 导入功能包

import torch
from torch import nn
# MyFunction为自己创建的包
import MyFunction as MF

• 参数设置

batch_size = 256
lr = 0.9
num_epochs = 10

• 读取数据

train_iter, test_iter = MF.load_data_fashion_mnist(batch_size=batch_size)
# 指定设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

• LeNet5模型

#定义LeNet5模型
net = nn.Sequential(nn.Conv2d(1,6,kernel_size=5,padding=2),
                    nn.Sigmoid(),
                    nn.AvgPool2d(kernel_size=2,stride=2),

                    nn.Conv2d(6,16,kernel_size=5),
                    nn.Sigmoid(),
                    nn.AvgPool2d(kernel_size=2,stride=2),

                    nn.Flatten(),
                    nn.Linear(16*5*5,120),
                    nn.Sigmoid(),

                    nn.Linear(120,84),
                    nn.Sigmoid(),
                    nn.Linear(84,10)
                    )

• 训练

MF.train_ch6_2(net, train_iter, test_iter, num_epochs, lr, device=device)

• 训练结果
  

MyFunction包里定义的相关函数

• 功能包

import torch
import torchvision
from torchvision import transforms
from torch.utils import data
import sys
import MyFunction as MF
from torch import nn
import numpy as np
import time
from tqdm import tqdm

• 定时器

# 定义一个计时器类
class Timer:
    """记录多次运行时间。"""
    def __init__(self):
        self.times = []
        self.start()

    def start(self):
        """启动计时器。"""
        self.tik = time.time()

    def stop(self):
        """停止计时器并将时间记录在列表中。"""
        self.times.append(time.time() - self.tik)
        return self.times[-1]

    def avg(self):
        """返回平均时间。"""
        return sum(self.times) / len(self.times)

    def sum(self):
        """返回时间总和。"""
        return sum(self.times)

    def cumsum(self):
        """返回累计时间。"""
        return np.array(self.times).cumsum().tolist()

• 获取Fashion_MNIST数据

# 定义获取Fashion_MNIST数据函数
def load_data_fashion_mnist(batch_size, resize=None):
    trans = [transforms.ToTensor()]
    if resize:
        trans.insert(0, transforms.Resize(resize))
    trans = transforms.Compose(trans)
    if sys.platform.startswith("win"):
        num_workers = 0
    else:
        num_workers = 4
    mnist_train = torchvision.datasets.FashionMNIST(root="./data", train=True, transform=trans, download=True)
    mnist_test = torchvision.datasets.FashionMNIST(root="./data", train=False, transform=trans, download=True)
    train_iter = data.DataLoader(mnist_train, batch_size, shuffle=True, num_workers=num_workers)
    test_iter = data.DataLoader(mnist_test, batch_size, shuffle=False, num_workers=num_workers)
    return train_iter, test_iter

• 模型评估

#预测正确个数
def accuracy(y_hat, y):
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)
    cmp = y_hat.type(y.dtype) == y
    return float(cmp.type(y.dtype).sum())
    
#准确度评估函数
def evaluate_accuracy_gpu_ch6(net, data_iter, device=None):
    """使用GPU计算模型在数据集上的精度。"""
    acc_sum, n = 0.0, 0
    if isinstance(net, torch.nn.Module):
        net.eval()  # 设置为评估模式
        if not device:  # 如果没指定device就使用net的device
            device = next(iter(net.parameters())).device
    # 正确预测的数量，总预测的数量
    for X, y in data_iter:
        if isinstance(X, list):
            # BERT微调所需的（之后将介绍）
            X = [x.to(device) for x in X]
        else:
            X = X.to(device)
        y = y.to(device)
        acc_sum += MF.accuracy(net(X), y)
        n += y.shape[0]
        result = acc_sum / n
    return result

• 训练

# 训练函数
def train_ch6_2(net, train_iter, test_iter, num_epochs, lr, device):
    """用GPU训练模型"""
    def init_weights(m):
        if type(m) == nn.Linear or type(m) == nn.Conv2d:
            nn.init.xavier_uniform_(m.weight)

    net.apply(init_weights)
    print(f'training on {device}:{torch.cuda.get_device_name()}')
    net.to(device)
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)
    loss = nn.CrossEntropyLoss()

    timer = MF.Timer()
    for epoch in range(num_epochs):
        train_l_sum, train_acc_sum, n = 0.0, 0.0, 0
        net.train()
        for X, y in train_iter:
            timer.start()
            optimizer.zero_grad()
            X, y = X.to(device), y.to(device)
            y_hat = net(X)
            l = loss(y_hat, y)
            l.backward()
            optimizer.step()
            train_l_sum += l.item() * X.shape[0]
            train_acc_sum += MF.accuracy(y_hat,y)
            n += y.shape[0]
            train_l = train_l_sum / n
            train_acc = train_acc_sum / n
            timer.stop()
		#保存训练的模型参数
        torch.save(net.state_dict(),"./data/%d.pth" %(epoch))
        test_acc = MF.evaluate_accuracy_gpu_ch6(net, test_iter)
        print(f'epoch:{epoch+1},loss {train_l:.3f}, train_acc {train_acc:.3f}, test_acc {test_acc:.3f}, {timer.stop()} sec')
    print(f'{n* num_epochs / timer.sum():.1f} examples/sec '
          f'on {str(device)}')