PyTorch--前馈神经网络模型实现与函数介绍

完整代码

对于初学者而言，理解前馈神经网络的工作原理是进入深度学习世界的第一步。这些网络以其清晰的层级结构和简单的信息流动方式，为学习者提供了易于理解的框架。本文旨在以浅显易懂的语言介绍前馈神经网络的基本概念，帮助读者构建对这一领域的认知基础。接下来先给出完整代码，我们在一点点进行解析。

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms


# Device configuration
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# Hyper-parameters 
input_size = 784
hidden_size = 500
num_classes = 10
num_epochs = 5
batch_size = 100
learning_rate = 0.001

# MNIST dataset 
train_dataset = torchvision.datasets.MNIST(root='../../data', 
                                           train=True, 
                                           transform=transforms.ToTensor(),  
                                           download=True)

test_dataset = torchvision.datasets.MNIST(root='../../data', 
                                          train=False, 
                                          transform=transforms.ToTensor())

# Data loader
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)

# Fully connected neural network with one hidden layer
class NeuralNet(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(NeuralNet, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size) 
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, num_classes)  
    
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

model = NeuralNet(input_size, hidden_size, num_classes).to(device)

# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)  

# Train the model
total_step = len(train_loader)
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):  
        # Move tensors to the configured device
        images = images.reshape(-1, 28*28).to(device)
        labels = labels.to(device)
        
        # Forward pass
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # Backward and optimize
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        if (i+1) % 100 == 0:
            print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' 
                   .format(epoch+1, num_epochs, i+1, total_step, loss.item()))

# Test the model
# In test phase, we don't need to compute gradients (for memory efficiency)
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        images = images.reshape(-1, 28*28).to(device)
        labels = labels.to(device)
        outputs = model(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: {} %'.format(100 * correct / total))

# Save the model checkpoint
torch.save(model.state_dict(), 'model.ckpt')

代码解析

设备配置

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

• 函数：torch.device
• 参数：设备类型字符串（‘cuda’ 或 ‘cpu’）
• 意义：配置模型运行的设备，优先使用GPU，如果GPU不可用则使用CPU。
• 用法：将模型和数据移动到指定的设备上。

超参数设置

# Hyper-parameters 
input_size = 784
hidden_size = 500
num_classes = 10
num_epochs = 5
batch_size = 100
learning_rate = 0.001

• 定义了网络结构和训练过程的参数。

加载MNIST数据集

# MNIST dataset 
# torchvision.datasets.MNIST(...)

• 加载MNIST训练集和测试集，使用transforms.ToTensor()将图像转换为张量。

创建数据加载器

# Data loader
# torch.utils.data.DataLoader(...)

• 创建用于批量加载数据的DataLoader。

定义神经网络模型

class NeuralNet(nn.Module):
    # 类定义和初始化方法
    def __init__(self, input_size, hidden_size, num_classes):
        super(NeuralNet, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size) 
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, num_classes)  
    
    # 前向传播
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

model = NeuralNet(input_size, hidden_size, num_classes).to(device)

• 类：NeuralNet
• 方法：
  • __init__：初始化网络层。
  • forward：定义前向传播过程。
• 用法：创建一个具有一个隐藏层的全连接神经网络模型，并将其移动到配置的设备上。

定义损失函数和优化器

# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)  

• 函数：nn.CrossEntropyLoss 和 torch.optim.Adam
• 参数：模型参数、学习率。
• 意义：定义了模型的损失函数和优化器。

训练模型

# Train the model
# 循环、优化步骤、打印训练进度

• 训练循环，包括数据预处理、前向传播、损失计算、反向传播和参数更新。

测试模型

# Test the model
# torch.no_grad() 上下文管理器、模型预测、计算准确率

• 测试循环，计算模型在测试集上的准确率。

保存模型

# Save the model checkpoint
torch.save(model.state_dict(), 'model.ckpt')

• 函数：torch.save
• 参数：模型的状态字典、文件名。
• 意义：保存训练后的模型参数。

常用函数解析

1. torch.device(device_type)

   • 格式：torch.device(device_type)
   • 参数：device_type —— 字符串，指定设备类型（‘cuda’ 或 ‘cpu’）。
   • 意义：根据设备类型返回相应的设备对象，用于指定模型和张量运行的设备。
   • 用法：

     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
     model.to(device)
     

2. torchvision.datasets.MNIST(...)

   • 格式：torchvision.datasets.MNIST(root, train, transform, download)
   • 参数：
     • root —— 存放数据集的根目录。
     • train —— 是否加载训练集。
     • transform —— 对数据集进行预处理的变换。
     • download —— 是否下载数据集。
   • 意义：加载MNIST数据集。
   • 用法：

     train_dataset = torchvision.datasets.MNIST(root='../../data', train=True, transform=transforms.ToTensor(), download=True)
     

3. torch.utils.data.DataLoader(...)

   • 格式：torch.utils.data.DataLoader(dataset, batch_size, shuffle)
   • 参数：
     • dataset —— 加载的数据集。
     • batch_size —— 每个批次的样本数。
     • shuffle —— 是否在每个epoch开始时打乱数据。
   • 意义：创建一个数据加载器，用于批量加载数据。
   • 用法：

     train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
     

4. nn.Module, nn.Linear(...), nn.ReLU(...)

   • 格式：
     • class nn.Module
     • nn.Linear(in_features, out_features)
     • nn.ReLU()
   • 参数：
     • 对于Linear：in_features —— 输入特征数，out_features —— 输出特征数。
     • 对于ReLU：无默认参数。
   • 意义：Module是所有神经网络模块的基类，Linear创建一个线性层，ReLU创建一个ReLU激活层。
   • 用法：

     class NeuralNet(nn.Module):
         def __init__(self, input_size, hidden_size, num_classes):
             super(NeuralNet, self).__init__()
             self.fc1 = nn.Linear(input_size, hidden_size)
             self.relu = nn.ReLU()
             self.fc2 = nn.Linear(hidden_size, num_classes)
     

5. nn.CrossEntropyLoss()

   • 格式：nn.CrossEntropyLoss()
   • 参数：无默认参数。
   • 意义：创建一个计算交叉熵损失的模块，适用于多分类问题。
   • 用法：

     criterion = nn.CrossEntropyLoss()
     

6. torch.optim.Adam(...)

   • 格式：torch.optim.Adam(params, lr)
   • 参数：
     • params —— 模型参数的迭代器。
     • lr —— 学习率。
   • 意义：创建Adam优化器，用于模型的参数更新。
   • 用法：

     optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
     

7. .to(device)

   • 格式：.to(device)
   • 参数：device —— 设备对象。
   • 意义：将模型或张量移动到指定的设备。
   • 用法：

     images = images.to(device)
     labels = labels.to(device)
     

8. .reshape(-1, 28*28)

   • 格式：reshape(shape)
   • 参数：shape —— 期望的新形状，-1表示自动计算该维度的大小。
   • 意义：重塑张量的形状。
   • 用法：

     images = images.reshape(-1, 28*28)
     

9. torch.max(outputs.data, 1)

   • 格式：torch.max(input, dim, keepdim=False)
   • 参数：
     • input —— 输入张量。
     • dim —— 要计算最大值的维度。
   • 意义：计算张量在指定维度上的最大值和索引。
   • 用法：

     _, predicted = torch.max(outputs.data, 1)
     

10. torch.no_grad()

    • 格式：torch.no_grad()
    • 参数：无。
    • 意义：上下文管理器，用于在测试或推理阶段禁用梯度计算。
    • 用法：

      with torch.no_grad():
          # 测试模型的代码
      

11. .sum().item()

    • 格式：.sum(dim, keepdim=False) 和 .item()
    • 参数：dim —— 求和的维度。
    • 意义：计算张量在指定维度上的和，并转换为Python数值。
    • 用法：

      correct += (predicted == labels).sum().item()
      

12. torch.save(obj, f)

    • 格式：torch.save(obj, f)
    • 参数：
      • obj —— 要保存的对象。
      • f —— 文件路径或文件对象。
    • 意义：将对象（如模型状态字典）保存到文件。
    • 用法：

      torch.save(model.state_dict(), 'model.ckpt')
      

这些函数和类是构建、训练和测试PyTorch模型的基础，涵盖了设备配置、数据加载、模型定义、训练过程、测试评估和模型保存等关键步骤。

the end