《Pytorch 最全入门介绍，Pytorch入门看这一篇就够了》学习

Pytorch 最全入门介绍，Pytorch入门看这一篇就够了 
https://www.cnblogs.com/xfuture/p/17593872.html

# 5.1 数据加载和预处理
# 首先，我们需要加载数据并进行预处理。我们将使用torchvision包来下载CIFAR10数据集，并使用transforms模块来对数据进行预处理。
import torch
from torchvision import datasets, transforms
from matplotlib import pyplot as plt
import torchvision
# 定义数据预处理操作
transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),  # 数据增强：随机翻转图片
    transforms.RandomCrop(32, padding=4),  # 数据增强：随机裁剪图片
    transforms.ToTensor(),  # 将PIL.Image或者numpy.ndarray数据类型转化为torch.FloadTensor，并归一化到[0.0, 1.0]
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))  # 标准化（这里的均值和标准差是CIFAR10数据集的）
])

# 下载并加载训练数据集
trainset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True, num_workers=2)

# 下载并加载测试集
testset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=2)

# 5.2 定义网络模型
# 接下来，我们定义我们的卷积神经网络模型。在这个案例中，我们将使用两个卷积层和两个全连接层。
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)  # 输入通道数3，输出通道数6，卷积核大小5
        self.pool = nn.MaxPool2d(2, 2)  # 最大池化，核大小2，步长2
        self.conv2 = nn.Conv2d(6, 16, 5)  # 输入通道数6，输出通道数16，卷积核大小5
        self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 全连接层，输入维度16*5*5，输出维度120
        self.fc2 = nn.Linear(120, 84)  # 全连接层，输入维度120，输出维度84
        self.fc3 = nn.Linear(84, 10)  # 全连接层，输入维度84，输出维度10（CIFAR10有10类）

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))  # 第一层卷积+ReLU激活函数+池化
        x = self.pool(F.relu(self.conv2(x)))  # 第二层卷积+ReLU激活函数+池化
        x = x.view(-1, 16 * 5 * 5)  # 将特征图展平
        x = F.relu(self.fc1(x))  # 第一层全连接+ReLU激活函数
        x = F.relu(self.fc2(x))  # 第二层全连接+ReLU激活函数
        x = self.fc3(x)  # 第三层全连接
        return x

# 创建网络
net = Net()
print(net)
# 5.3 定义损失函数和优化器
# 现在我们已经有了数据和模型，下一步我们需要定义损失函数和优化器。损失函数用于衡量模型的预测与真实标签的差距，优化器则用于优化模型的参数以减少损失。
# 在这个案例中，我们将使用交叉熵损失函数（Cross Entropy Loss）和随机梯度下降优化器（Stochastic Gradient Descent，SGD）。
import torch.optim as optim

# 定义损失函数
criterion = nn.CrossEntropyLoss()

# 定义优化器
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

def train():

    # 5.4 训练网络
    # 一切准备就绪后，我们开始训练网络。在训练过程中，我们首先通过网络进行前向传播得到输出，然后计算输出与真实标签的损失，接着通过后向传播计算梯度，最后使用优化器更新模型参数。
    for epoch in range(2):  # 在数据集上训练两遍
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            # 获取输入数据
            inputs, labels = data

            # 梯度清零
            optimizer.zero_grad()

            # 前向传播
            outputs = net(inputs)

            # 计算损失
            loss = criterion(outputs, labels)

            # 反向传播
            loss.backward()

            # 更新参数
            optimizer.step()

            # 打印统计信息
            running_loss += loss.item()
            if i % 2000 == 1999:  # 每2000个批次打印一次
                print('[%d, %5d] loss: %.3f' %
                      (epoch + 1, i + 1, running_loss / 2000))
                running_loss = 0.0

    print('Finished Training')

def test_net():
# # 5.5 测试网络
# # 训练完成后，我们需要在测试集上测试网络的性能。这可以让我们了解模型在未见过的数据上的表现如何，以评估其泛化能力。
#
# # 加载一些测试图片
    dataiter = iter(testloader)
    images, labels = dataiter.__next__()
    print(images.size())
    # 打印图片
    #plt.imshow(torchvision.utils.make_grid(images))
    classes = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
    # 显示真实的标签
    print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

    # 让网络做出预测
    outputs = net(images)

    # 预测的标签是最大输出的标签
    _, predicted = torch.max(outputs, 1)

    # 显示预测的标签
    print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

    # 在整个测试集上测试网络
    correct = 0
    total = 0
    with torch.no_grad():
        for data in testloader:
            images, labels = data
            outputs = net(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    print('Accuracy of the network on the 10000 test images: %d %%' % (
        100 * correct / total))
#
#
#
def model_utilities():

    # 5.6 保存和加载模型
    # 在训练完网络并且对其进行了测试后，我们可能希望保存训练好的模型，以便于将来使用，或者继续训练。

    # 保存模型
    global net
    torch.save(net.state_dict(), './cifar_net.pth')

    # 在这段代码中，我们使用torch.save函数，将训练好的模型参数（通过net.state_dict()获得）保存到文件中。
    #
    # 当我们需要加载模型时，首先需要创建一个新的模型实例，然后使用load_state_dict方法将参数加载到模型中。

    # 加载模型
    net = Net()  # 创建新的网络实例
    net.load_state_dict(torch.load('./cifar_net.pth'))  # 加载模型参数
    print(net)
if __name__ == '__main__':
    train()
    test_net()
    #model_utilities()