使用神经网络完成多分类任务（以MNIST手写数据集为例）

第一部分：案例描述

使用神经网络进行多分类问题（一个输入层1x784（28x28像素的图像展平后的维度），一个输出层784x10(对应于MNIST数据集中的10个类别（数字0到9)）

训练过程中使用的损失函数为交叉熵损失函数

优化器使用的是随机梯度下降优化器SGD

第二部分：代码实现

（1）导包

#第一部分：导包
import torch
import torchvision
from matplotlib import pyplot as plt

（2）导入数据集

#第二部分：导入数据集
transformation =torchvision.transforms.ToTensor()
train_dataset = torchvision.datasets.MNIST(root="/data/mnist", train=True, transform=transformation, download=True)
test_dataset = torchvision.datasets.MNIST(root="/data/mnist", train=False, transform=transformation, download=True)

#每次选取64条数据集训练
batch_size = 64
#因为我们不可能一次性将所有数据都喂给模型训练的，它吃不消也存不完
train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)#True代表随机打乱的意思
test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)
#输出查看加载的数据信息
for images, labels in train_dataloader:
    print(images.shape, labels.shape)
    plt.imshow(images[0][0], cmap='gray')
    plt.show()
    print(labels[0])

（3）设置网络结构

#第三部分：设置网络结构
import torch.nn as nn
class Model(nn.Module):
    def __init__(self, input_size, output_size):
        super().__init__()
        self.linear = nn.Linear(input_size, output_size)

    def forward(self, x):
        logits = self.linear(x)
        return logits
input_size = 28*28
output_size = 10
model = Model(input_size, output_size)

（4）定义交叉熵损失函数

#第四部分：定义交叉熵损失函数
criterion = nn.CrossEntropyLoss()

（5）定义优化器

#第五部分：定义优化器
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
#配置了PyTorch的optim模块中的随机梯度下降（SGD）优化器，指定它应该以0.01的学习率（lr）优化model的参数。这个优化器会调整模型参数以最小化训练过程中的损失函数。

（6）定义模型评估器

#第六部分：模型评估器
def evaluate(model, data_loader):
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for x, y in data_loader:
            x = x.view(-1, input_size)
            logits = model(x)
            _, predicted = torch.max(logits.data, 1)
            total += y.size(0)
            correct += (predicted == y).sum().item()
    return correct / total

（7）模型训练

#第七部分：模型训练
for epoch in range(10):
    for images, labels in train_dataloader:
        # 调整图像格式适应模型
        images = images.view(-1, 28*28)
        labels = labels.long()
        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)
        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    accuracy = evaluate(model, test_dataloader)
    print(f'Epoch {epoch+1}: test accuracy = {accuracy:.2f}')

（8）完整pycharm代码

#第一部分：导包
import torch
import torchvision
from matplotlib import pyplot as plt

#第二部分：导入数据集
transformation =torchvision.transforms.ToTensor()
train_dataset = torchvision.datasets.MNIST(root="/data/mnist", train=True, transform=transformation, download=True)
test_dataset = torchvision.datasets.MNIST(root="/data/mnist", train=False, transform=transformation, download=True)

#每次选取64条数据集训练
batch_size = 64
#因为我们不可能一次性将所有数据都喂给模型训练的，它吃不消也存不完
train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)#True代表随机打乱的意思
test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)
#输出查看加载的数据信息
for images, labels in train_dataloader:
    print(images.shape, labels.shape)
    plt.imshow(images[0][0], cmap='gray')
    plt.show()
    print(labels[0])
#第三部分：设置网络结构
import torch.nn as nn
class Model(nn.Module):
    def __init__(self, input_size, output_size):
        super().__init__()
        self.linear = nn.Linear(input_size, output_size)

    def forward(self, x):
        logits = self.linear(x)
        return logits
input_size = 28*28
output_size = 10
model = Model(input_size, output_size)
#第四部分：定义交叉熵损失函数
criterion = nn.CrossEntropyLoss()
#第五部分：定义优化器
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
#配置了PyTorch的optim模块中的随机梯度下降（SGD）优化器，指定它应该以0.01的学习率（lr）优化model的参数。这个优化器会调整模型参数以最小化训练过程中的损失函数。


#第六部分：模型评估器
def evaluate(model, data_loader):
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for x, y in data_loader:
            x = x.view(-1, input_size)
            logits = model(x)
            _, predicted = torch.max(logits.data, 1)
            total += y.size(0)
            correct += (predicted == y).sum().item()
    return correct / total

#第七部分：模型训练
for epoch in range(10):
    for images, labels in train_dataloader:
        # 调整图像格式适应模型
        images = images.view(-1, 28*28)
        labels = labels.long()
        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)
        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    accuracy = evaluate(model, test_dataloader)
    print(f'Epoch {epoch+1}: test accuracy = {accuracy:.2f}')