完整的 PyTorch 模型训练的过程：

1、数据预处理：首先，需要加载和准备数据。这可以通过使用 torchvision 和 torch.utils.data 中的数据加载器来完成。同时要进行数据预处理，例如缩放、裁剪、旋转、填充等。

2、构建模型：接下来，需要定义神经网络模型。PyTorch 提供了一个 nn 模块来快速构建神经网络。该模块包括各种层（例如全连接层、卷积层、池化层等），可以使用它们来构建自己的神经网络。

3、定义损失函数：在训练过程中，需要定义一个损失函数，该函数将比较预测输出和实际输出之间的差异。例如，对于分类问题，可使用交叉熵损失函数。

4、定义优化器：接下来，需要定义一个优化器，它将用于优化神经网络模型的参数。PyTorch 提供了一些优化器，例如随机梯度下降（SGD）、Adam 等。

5、训练模型：现在，可以开始训练模型了。训练模型需要进行多个迭代。在每个迭代中，输入数据将被馈送到神经网络中，输出将被计算并与实际输出进行比较，然后将计算出的损失反向传播回神经网络，以便更新参数。重复此过程，直到模型达到足够的准确性。

6、测试模型：完成模型的训练后，可以对模型进行测试。在测试过程中，可以输入新的数据，该数据模型没有使用过。模型将为该数据生成一个预测输出。可以比较预测输出和实际输出，以评估模型的性能。

7、保存和加载模型：最后，可以将完全训练的模型保存到本地磁盘上。这样，可以随时加载和使用该模型，而无需重新训练。使用 torch.save() 函数可以将 PyTorch 模型保存到磁盘，使用 torch.load() 函数可以将模型加载回来。

完整示例代码：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms

#此代码将使用 MNIST 数据集训练一个简单的卷积神经网络
# 设置随机数种子，以便结果可以重复
torch.manual_seed(0)

# 加载数据集
train_dataset = datasets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transforms.ToTensor(), download=True)

# 定义数据加载器
batch_size = 64
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 定义神经网络模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64*7*7, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 64*7*7)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = Net()

# 定义损失函数和优化器，使用交叉熵损失和 Adam 优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

# 训练模型
epochs = 10
for epoch in range(epochs):
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(train_loader, 0):
        # 将输入数据和标签转换为 PyTorch 变量
        inputs, labels = torch.autograd.Variable(inputs), torch.autograd.Variable(labels)

        # 领导模型前向以及反向传播
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # 输出损失的统计信息
        running_loss += loss.item()
        if i % 200 == 199:
            print('[%d, %5d] loss: %.3f' % (epoch+1, i+1, running_loss/200))
            running_loss = 0.0

# 测试模型
correct = 0
total = 0
with torch.no_grad():
    for (images, labels) in test_loader:
        images, labels = torch.autograd.Variable(images), torch.autograd.Variable(labels)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy on the test set: %d %%' % (100 * correct / total))

# 保存模型
torch.save(model.state_dict(), 'model.pth')

# 加载模型
model = Net()
model.load_state_dict(torch.load('model.pth'))