LeNet-5N 网络模型及对应代码自用已跑通

先来结构图

再上数据结果

# 三个列表对应代码中的三个print的结果
# 这个是epoch的loss 波动很大，所以再绘制时我用的另一个列表为train_loss_sum_batch_size_list，每一批次计算的损失保存下来
[0.0023519382812082767, 0.002893716562539339, 0.0008142628939822316, 0.00033718650229275227, 0.0007794988341629505, 0.00011357502080500126, 9.645754471421242e-05, 0.00014914851635694504, 0.00010467879474163055, 0.002407869789749384]  
[0.9323, 0.9628833333333333, 0.9711333333333333, 0.9767666666666667, 0.9803, 0.9858166666666667, 0.9861666666666666, 0.9883833333333333, 0.9885, 0.9888666666666667] # 训练损失
[0.9358, 0.9645, 0.9721, 0.978, 0.9787, 0.9826, 0.9842, 0.9853, 0.9845, 0.9858]  # 测试损失(应该是验证损失)

次之结果可视化

Loss图打印的结果很多可在train_loss_sum_batch_size_list这个列表中取用

自用，已跑通！ 部分细节仍需完善； 如下几个部分（也算是思路顺序吧）：

1. 数据下载
2. 数据加载
3. CPU or GPU
4. 模型搭建
5. 超参数选择
6. 开始训练
7. 结果可视化

最后代码压轴

# LeNet模型
import torch
from torch import nn
from torchvision import datasets,transforms

# 批量大小
batch_size = 64
# 下载mnist数据集及文件路径
train_dataset = datasets.MNIST(root=r'D:\pycharm\jupyter_notebook\data/mnist_book',
                               train=True,
                               transform=transforms.ToTensor(),download=True)
test_dataset = datasets.MNIST(root=r'D:\pycharm\jupyter_notebook\data/mnist_book',
                               train=False,
                               transform=transforms.ToTensor()) # 下载一次就够了
# 文件路径读取文件及打乱顺序
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=False)

##  选择CPU还是GPU
device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
# 定义模型
class LeNet(nn.Module):
    def __init__(self,in_dim,num_class):
        super().__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(in_channels=in_dim, out_channels=6 ,kernel_size=5,padding=2),
            nn.Sigmoid(),
            nn.MaxPool2d(kernel_size=2,stride=2))

        self.conv2 = nn.Sequential(
            nn.Conv2d(in_channels=6,out_channels=16,kernel_size=5),
            nn.Sigmoid(),
            nn.MaxPool2d(kernel_size=2,stride=2)) #池化与核步长默认为相同

        self.fc = nn.Sequential(
            # nn.Flatten(),
            nn.Linear(400,120),nn.Sigmoid(), #16*5*5 = 400
            nn.Linear(120,84),nn.Sigmoid(),
            nn.Linear(84,num_class))         # 最后的分类输出

        # 正向传播
    def forward(self,x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0),-1)  # 从卷积到Flatten层
        output = self.fc(x)
        return output

def train_or_evlauate_accuracy(data_iter,model):# 计算准确率 可用于训练和测试(通用的)
    total = 0
    correct = 0
    with torch.no_grad():
        for image,label in data_iter:
            model.eval()
            image = image.to(device)
            label = label.to(device)
            output = model(image)
            _,predict = torch.max(output,1)
            total += label.size(0)
            correct += (predict == label).sum().item()
    return correct/total

def init_weights(m):
    if type(m) == nn.Linear or type(m) == nn.Conv2d:
        nn.init.xavier_uniform_(m.weight)
# 实例化模型

model = LeNet(1,10)
model.apply(init_weights)
model.to(device)

## 开始训练
torch.manual_seed(1)   # 设置随机种子，确保结果可重复
learning_rate = 1e-3   # 学习率设置为0.001
num_epochs = 10
optimizer = torch.optim.Adam(model.parameters(),lr=learning_rate)  # 第一个传入的参数为模型的参数

criterion = nn.CrossEntropyLoss()  # 损失函数，在输出和标签之间计算值 交叉损失函数

# for i,(images,labels) in enumerate(train_loader):
#     print(images,labels)
# 训练模型代码
train_correct_list = []
test_acc_list = []
train_loss_sum_list = []
train_loss_sum_batch_size_list = []
for epoch in range(num_epochs):
    # print('Current epoch: %d' %epoch)
    for i ,(images,labels) in enumerate(train_loader):
        train_loss_sum = 0
        model.train()   # 开始训练
        images = images.to(device)
        labels = labels.to(device)
        outputs = model(images)  # 输入数据做前向计算
        # print(outputs.shape)
        loss = criterion(outputs,labels) # 计算损失值
        optimizer.zero_grad()  # 梯度清零
        loss.backward()       # 梯度反向
        optimizer.step()     # 参数更新

        # 需要打印的参数
        train_loss_sum += loss.item()           #一个batch_size的损失值，直到epoch的值累加完/64得到 完整的一个epoch的平均值
        train_loss_sum_batch_size_list.append(loss)
    # 应该用此时的网络 去预测整个训练集的准确度 ,在epoch的循环下计算
    train_correct = train_or_evlauate_accuracy(train_loader, model=model)
    test_acc = train_or_evlauate_accuracy(test_loader,model)
    train_correct_list.append(train_correct)
    test_acc_list.append(test_acc)
    print('Current epoch: %d, loss %.5f | trian_accuracy %.4f | test accuracy %.4f'%
          (epoch,train_loss_sum/batch_size,train_correct,test_acc))
    train_loss_sum_list.append(train_loss_sum/batch_size)
print(train_loss_sum_list)
print(train_correct_list)
print(test_acc_list)
print('Finish trianing!')

# 绘制图像
import matplotlib.pyplot as plt
plt.figure(figsize=(8,8), dpi=80)
plt.figure(1)
# plt.rcParams['font.sans-serif']=['SimHei'] # 用来正常显示中文标签
# plt.rcParams['axes.unicode_minus']=False # 用来正常显示负号
ax1 = plt.subplot(211)
ax1.plot(train_correct_list, color="r",linestyle = "--",label='train accuracy')
ax1.plot(test_acc_list,color="y",linestyle = "-",label='test accuracy')
ax1.set(ylabel='Accuracy', xlabel='epochs', title='Accuracy-Epochs')
ax1.legend()
ax3 = plt.subplot(212)
ax3.plot(train_loss_sum_batch_size_list,color="k",linestyle = "-")
ax3.set(ylabel='Loss', xlabel='batch-size(iterations)', title='Loss-batch-size(iterations)')
plt.show()