pytorch进阶学习（一）：使用远程服务器在pycharm上运行简单的小型网络模型，使用fashion-minist数据集进行训练

参考视频和代码来源详见up主Leo在这的b站教学视频：

1、Pytorch的安装与环境配置【小学生都会的Pytorch】_哔哩哔哩_bilibili

如何在pycharm上连接远程服务器详见：

(7条消息) 如何使用租用的云服务器实现神经网络训练过程（超详细教程，新手小白适用）_好喜欢吃红柚子的博客-CSDN博客

一、服务器上下载conda

如果你的服务器上没有conda，需要下载。

(7条消息) 远端服务器安装anaconda并创建conda环境_头秃的和尚的博客-CSDN博客

期间可能会遇到无法识别conda的命令，此时需要使用vim命令手动添加conda的环境变量。

(7条消息) conda: command not found解决办法_奥特曼熬夜不睡觉的博客-CSDN博客

下载完之后服务器文件中会出现对应的conda文件夹。

二、创建和激活环境

1. 使用conda create -n xxx python = 3.8 创建虚拟环境，使用conda activate xxx激活该虚拟环境。

三、安装torch和对应包

进入虚拟环境后，使用pip install torch 和 pip install torchvision下载代码所需的pytorch框架、matplotlib和numpy

可以看到numpy之前以及下载好了，不用重新下载。耐心等待下载安装即可，最后可使用pip list命令查看一下现有的包，发现已经全部下载完毕

四、把程序上传到服务器中

1. 准备代码

服务器上的环境都下载完毕后，回到pycharm中，打开运行的文件，我这里名为main.py，是一个简单地训练模型，代码如下。

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda, Compose
import matplotlib.pyplot as plt

# 采用torchvision里面的datasets里面的FashionMNIST数据集，该数据集在第一次用时需要下载，
# 数据集分为训练集（用于模型训练）和测试集（验证模型性能）
# 下面是训练集
training_data = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),
)

# 下面是测试集，同样需要下载
test_data = datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor(),
)

batch_size = 64


# 给训练集和测试集分别创建一个数据集加载器
train_dataloader = DataLoader(training_data, batch_size=batch_size)
test_dataloader = DataLoader(test_data, batch_size=batch_size)

for X, y in test_dataloader:
    print("Shape of X [N, C, H, W]: ", X.shape)
    print("Shape of y: ", y.shape, y.dtype)
    break


# 如果显卡可用，则用显卡进行训练
device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))

# 定义网络模型
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        # 碾平，将数据碾平为一维
        self.flatten = nn.Flatten()
        # 定义linear_relu_stack，由以下众多层构成
        self.linear_relu_stack = nn.Sequential(
            # 全连接层
            nn.Linear(28*28, 512),
            # ReLU激活函数
            nn.ReLU(),
            # 全连接层
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
            nn.ReLU()
        )
    # x为传入数据
    def forward(self, x):
        # x先经过碾平变为1维
        x = self.flatten(x)
        # 随后x经过linear_relu_stack
        logits = self.linear_relu_stack(x)
        # 输出logits
        return logits

# 调用刚定义的模型，将模型转到GPU（如果可用）
model = NeuralNetwork().to(device)
print(model)

# 定义损失函数，计算相差多少
loss_fn = nn.CrossEntropyLoss()

# 定义优化器，用来训练时候优化模型参数
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)


# 定义训练函数，需要
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    # 从数据加载器中读取batch（一次读取多少张，即批次数），X(图片数据)，y（图片真实标签）。
    for batch, (X, y) in enumerate(dataloader):
        # 将数据存到显卡
        X, y = X.to(device), y.to(device)

        # 得到预测的结果pred
        pred = model(X)

        # 计算预测的误差
        loss = loss_fn(pred, y)

        # 反向传播，更新模型参数
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        # 每训练100次，输出一次当前信息
        if batch % 100 == 0:
            loss, current = loss.item(), batch * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")


def test(dataloader, model):
    size = len(dataloader.dataset)
    # 将模型转为验证模式
    model.eval()
    # 初始化test_loss 和 correct， 用来统计每次的误差
    test_loss, correct = 0, 0
    # 测试时模型参数不用更新，所以no_gard()
    with torch.no_grad():
        # 加载数据加载器，得到里面的X（图片数据）和y(真实标签）
        for X, y in dataloader:
            # 将数据转到GPU
            X, y = X.to(device), y.to(device)
            # 将图片传入到模型当中就，得到预测的值pred
            pred = model(X)
            # 计算预测值pred和真实值y的差距
            test_loss += loss_fn(pred, y).item()
            # 统计预测正确的个数
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= size
    correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

# 一共训练5次
epochs = 5
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train(train_dataloader, model, loss_fn, optimizer)
    test(test_dataloader, model)
print("Done!")

# 保存训练好的模型
torch.save(model.state_dict(), "model.pth")
print("Saved PyTorch Model State to model.pth")



# 读取训练好的模型，加载训练好的参数
model = NeuralNetwork()
model.load_state_dict(torch.load("model.pth"))

# 定义所有类别
classes = [
    "T-shirt/top",
    "Trouser",
    "Pullover",
    "Dress",
    "Coat",
    "Sandal",
    "Shirt",
    "Sneaker",
    "Bag",
    "Ankle boot",
]

# 模型进入验证阶段
model.eval()

x, y = test_data[0][0], test_data[0][1]
with torch.no_grad():
    pred = model(x)
    predicted, actual = classes[pred[0].argmax(0)], classes[y]
    print(f'Predicted: "{predicted}", Actual: "{actual}"')

2. 上传到服务器

按照我前面说的方法配置服务器，可以看到我的Python解释器已经变成了服务器上的conda虚拟环境，pycharm右下角也对应改变成了该环境。

依次点击tools->deployment->upload to xxx，xxx为你连接的服务器的主机，即可完成对代码的上传。

五、在pycharm上运行代码

点击运行，模型开始训练。可以看到虽然我们的pycharm中代码有报错，torch等环境都无法识别，但是服务器中以及进行了环境的配置，因此代码还是可以正常运行，因为代码实际是在远程服务器上运行的，pycharm担任了可视化界面的作用。

自动下载数据集，数据集会下载到服务器中的data文件夹下，下载后模型开始训练5轮，5轮后训练完成。

耐心等待训练……

等待……

训练完成！！！

六、代码解析

1. fashion-minist数据集

灰度图像，channel=1，大小为28*28

2. 要点解析

2.1 dataloader

https://blog.csdn.net/weixin_45662399/article/details/127601983?spm=1001.2014.3001.5502

在dataloader中，每一个对象元组由batchsize张图片对象imgs和batchsize个标签targets组成。输入图片的batchsize=64，说明一次输入64张图

• 故X有64张，每张图片通道=1，大小=28*28。

• y为64张图像对应的标签，也为64个，为int型。

# 测试训练集数据加载器，X为输入图片，y为对应标签
for X, y in test_dataloader:
    print("Shape of X [N, C, H, W]: ", X.shape)
    print("Shape of y: ", y.shape, y.dtype)
    break

输出：

2.2 使用gpu/cpu训练

如果gpu可用，则使用gpu进行训练，否则使用cpu

# 如果显卡可用，则用显卡进行训练
device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))

2.3 定义神经网络

# 定义网络模型
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        # 碾平，将数据碾平为一维
        self.flatten = nn.Flatten()
        # 定义linear_relu_stack，由以下众多层构成
        self.linear_relu_stack = nn.Sequential(
            # 全连接层
            nn.Linear(28*28, 512),
            # ReLU激活函数
            nn.ReLU(),
            # 全连接层
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
            nn.ReLU()
        )
    # x为传入数据
    def forward(self, x):
        # x先经过碾平变为1维
        x = self.flatten(x)
        # 随后x经过linear_relu_stack
        logits = self.linear_relu_stack(x)
        # 输出logits
        return logits

1. 定义sequential

• flatten：先把二维矩阵展平为一维向量，输入网络

• 全连接层1：输入为28*28，输出为512

• 激活层1：relu函数激活

• 全连接层2：输入和输出都是512

• 激活层2

• 全连接层3：输入为512，输出变为10

把以上操作都放在sequential序列里，即可按顺序依次操作。

2. 前向传播forward

把x进行输入，然后经过sequential定义的神经网络结构后输出logits，即为训练后对x图片的预测结果y'。

3. 损失函数

计算预测值和真实值的差值，使用交叉熵损失。

loss_fn = nn.CrossEntropyLoss()

4. 优化器

随机梯度下降SSD

# 定义优化器，用来训练时候优化模型参数
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)

2.4 网络训练train

获取到图标真实标签y和预测后的标签pred，使用loss_fn计算两者差距并保存在loss中，使用反向传播更新参数。

每训练100张，输出一次loss，可以看到loss值是越来越小的，说明模型训练越来越成功。

Epoch 1
-------------------------------
loss: 2.302158 [ 0/60000]
loss: 2.293674 [ 6400/60000]
loss: 2.289693 [12800/60000]
loss: 2.289169 [19200/60000]
loss: 2.281888 [25600/60000]
loss: 2.273417 [32000/60000]
loss: 2.272296 [38400/60000]
loss: 2.256825 [44800/60000]
loss: 2.247419 [51200/60000]
loss: 2.276489 [57600/60000]

def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    # 从数据加载器中读取batch（一次读取多少张，即批次数），X(图片数据)，y（图片真实标签）。
    for batch, (X, y) in enumerate(dataloader):
        # 将数据存到显卡
        X, y = X.to(device), y.to(device)

        # 得到预测的结果pred
        pred = model(X)

        # 计算预测的误差
        loss = loss_fn(pred, y)

        # 反向传播，更新模型参数
        #梯度置零
        optimizer.zero_grad()
        #调整参数，反向传播，训练
        loss.backward()
        #更新参数
        optimizer.step()

        # 每训练100次，输出一次当前信息
        if batch % 100 == 0:
            loss, current = loss.item(), batch * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")

2.5 网络测试test

模型在结束训练进行测试时，无需再进行参数的反向传播来调整参数，因此使用torch.no_grad( )。

def test(dataloader, model):
    size = len(dataloader.dataset)
    # 将模型转为验证模式
    model.eval()
    # 初始化test_loss 和 correct， 用来统计每次的误差
    test_loss, correct = 0, 0
    # 测试时模型参数不用更新，所以no_gard()
    with torch.no_grad():
        # 加载数据加载器，得到里面的X（图片数据）和y(真实标签）
        for X, y in dataloader:
            # 将数据转到GPU
            X, y = X.to(device), y.to(device)
            # 将图片传入到模型当中就，得到预测的值pred
            pred = model(X)
            # 计算预测值pred和真实值y的差距
            test_loss += loss_fn(pred, y).item()
            # 统计预测正确的个数
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= size
    correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

2.6 epoch次数

# 一共训练5次
epochs = 5
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train(train_dataloader, model, loss_fn, optimizer)
    test(test_dataloader, model)
print("Done!")

设置epoch=5，一共训练5轮，每一次训练完后都会进行一次测试

2.7 model.pth

把训练好的模型文件保存在model.pth中，等到需要使用模型进行验证时，直接读取该模型文件即可。

# 保存训练好的模型
torch.save(model.state_dict(), "model.pth")
print("Saved PyTorch Model State to model.pth")

# 读取训练好的模型，加载训练好的参数
model = NeuralNetwork()
model.load_state_dict(torch.load("model.pth"))

2.8 网络验证validation

• 验证阶段和测试阶段一样，不进行梯度更新调整参数。

• 取测试集中的第一张图片和其对应标签，pred保存模型的预测类别，pred[0].argmax[0]得到所有预测类别得分最高的一类，然后找到classes中对应的具体类别，即可与真实类别比较判断预测结果。

# 定义所有类别
classes = [
    "T-shirt/top",
    "Trouser",
    "Pullover",
    "Dress",
    "Coat",
    "Sandal",
    "Shirt",
    "Sneaker",
    "Bag",
    "Ankle boot",
]

# 模型进入验证阶段
model.eval()

x, y = test_data[0][0], test_data[0][1]
with torch.no_grad():
    pred = model(x)
    predicted, actual = classes[pred[0].argmax(0)], classes[y]
    print(f'Predicted: "{predicted}", Actual: "{actual}"')

预测结果：可以看到模型预测的类别和真正类别一样，都是ankle boot。