3 多层感知机模型与模型训练

import torch
from torch import nn

# import os
# os.environ["CUDA_VISIBLE_DEVICES"] = "3,4,6"  # 只使用空闲的 GPU

## 3.1.1 模型的建立
# 记得吗，上一讲，我们的train_dl的形状为torch.Size([64,1,28,28])
class Model(nn.Module): # 创建模型，继承自nn.Module
    def __init__(self):
        super().__init__()
        # 第一层输入展平后的特征长度28乘28,创建120个神经元
        self.liner_1=nn.Linear(28*28,120)
        # 第二层输入的是前一层的输出,创建84个神经元
        self.liner_2=nn.Linear(120,84)
        # 输出层接受第二层的输入84,输出分类个数10
        self.liner_3=nn.Linear(84,10)

    def forward(self,input):
        x=input.view(-1,28*28) # 将输入展平为二维(1,28,28)->(28*28)
        x=torch.relu(self.liner_1(x))
        x=torch.relu(self.liner_2(x))
        x=self.liner_3(x)
        return x

## 3.1.2 分类问题的损失函数
loss_fn=nn.CrossEntropyLoss() # 初始化交叉熵损失函数
# 可以认为它综合了softmax计算和交叉熵损失计算
'''
注意两个参数
1. weight
2. ignore_index
另外,它要求实际类别为数值编码,而不是独热编码
'''

## 3.1.3 初始化模型
device="cuda" if torch.cuda.is_available() else "cpu"
model=Model().to(device)
# print(device)

## 3.1.4 优化器 均在torch.optim模块下
# 随机梯度下降优化器
optimizer=torch.optim.SGD(model.parameters(),lr=0.005)

## 3.1.5 编写训练循环
### 3.1.5.1 训练函数
def train(dataloader,model,loss_fn,optimizer):
    size=len(dataloader.dataset) #获取当前数据集样本总数量
    num_batches=len(dataloader) #获取当前data loader总批次数
    
    # train_loss用于累计所有批次的损失之和, correct用于累计预测正确的样本总数
    train_loss,correct=0,0
    for X,y in dataloader:
        X,y=X.to(device),y.to(device)
        
        # 进行预测,并计算第一个批次的损失
        pred=model(X)
        loss=loss_fn(pred,y)
        # 利用反向传播算法,根据损失优化模型参数
        optimizer.zero_grad() #先将梯度清零
        loss.backward() # 损失反向传播,计算模型参数梯度
        optimizer.step() #根据梯度优化参数
        
        with torch.no_grad():
            # correct用于累计预测正确的样本总数
            correct+=(pred.argmax(1)==y).type(torch.float).sum().item()
            # train_loss用于累计所有批次的损失之和
            train_loss+=loss.item()
            
        # train_loss 是所有批次的损失之和,所以计算全部样本的平均损失时需要除以总的批次数
    train_loss/=num_batches
        # correct 是预测正确的样本总数,若计算整个apoch总体正确率,需要除以样本总数量
    correct/=size
    return train_loss,correct
        

### 3.1.5.2 测试函数
def test(dataloader,model):
    size=len(dataloader.dataset)
    num_batches=len(dataloader)
    test_loss,correct=0,0
    with torch.no_grad():
        for X,y in dataloader:
            X,y=X.to(device),y.to(device)
            pred=model(X)
            test_loss+=loss_fn(pred,y).item()
            correct+=(pred.argmax(1)==y).type(torch.float).sum().item()
    test_loss/=num_batches
    correct/=size
    return test_loss,correct

# 我们先把数据集加载进来
import torchvision
from torchvision.transforms import ToTensor
train_ds=torchvision.datasets.MNIST("data/",train=True,transform=ToTensor(),download=True)
test_ds=torchvision.datasets.MNIST("data/",train=False,transform=ToTensor(),download=True)

train_dl=torch.utils.data.DataLoader(train_ds,batch_size=64,shuffle=True)
test_dl=torch.utils.data.DataLoader(test_ds,batch_size=64)

    ### 3.1.5.3 正式编写训练循环
    # 我们对全部的数据集训练50个epoch(一个epoch表示对全部数据训练一遍)
    epochs=50 
    train_loss=[]
    train_acc=[]
    test_loss=[]
    test_acc=[]
    
    for epoch in range(epochs):
        # 调用train()函数训练
        epoch_loss,epoch_acc=train(train_dl,model,loss_fn,optimizer)
        # 调用test()函数测试
        epoch_test_loss,epoch_test_acc=test(test_dl,model)
    
        train_loss.append(epoch_loss)
        train_acc.append(epoch_acc)
        test_loss.append(epoch_test_loss)
        test_acc.append(epoch_test_acc)
    
        # 定义一个打印模板
        template=("epoch:{:2d},train_loss:{:5f},train_acc:{:.1f}%,""test_loss:{:.5f},test_acc:{:.1f}%")
    
        print(template.format(epoch,epoch_loss,epoch_acc*100,epoch_test_loss,epoch_test_acc*100))
    
    print("Done")

## 绘制图像
import matplotlib.pyplot as plt
plt.plot(range(1,epochs+1),train_loss,label="train_Loss")
plt.plot(range(1,epochs+1),test_loss,label="test_Loss",ls="--")
plt.xlabel("epoch")
plt.legend()
plt.show()

## 绘制图像
plt.plot(range(1,epochs+1),train_acc,label="train_acc")
plt.plot(range(1,epochs+1),test_acc,label="test_acc")
plt.xlabel("epoch")
plt.legend()
plt.show()