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

文章目录

- - 完整代码
  - 代码解析
  - - 设备配置
    - 超参数设置
    - 加载MNIST数据集
    - 创建数据加载器
    - 定义神经网络模型
    - 定义损失函数和优化器
    - 训练模型
    - 测试模型
    - 保存模型
  - 常用函数解析

完整代码

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

python 复制代码

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')

代码解析

设备配置

python 复制代码

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

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

超参数设置

python 复制代码

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

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

加载MNIST数据集

python 复制代码

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

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

创建数据加载器

python 复制代码

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

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

定义神经网络模型

python 复制代码

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：定义前向传播过程。
用法：创建一个具有一个隐藏层的全连接神经网络模型，并将其移动到配置的设备上。

定义损失函数和优化器

python 复制代码

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

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

训练模型

python 复制代码

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

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

测试模型

python 复制代码

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

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

保存模型

python 复制代码

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

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

常用函数解析

torch.device(device_type)
- 格式：torch.device(device_type)
- 参数：device_type ------ 字符串，指定设备类型（'cuda' 或 'cpu'）。
- 意义：根据设备类型返回相应的设备对象，用于指定模型和张量运行的设备。
- 用法：
  python 复制代码
```
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
```
torchvision.datasets.MNIST(...)
- 格式：torchvision.datasets.MNIST(root, train, transform, download)
- 参数：
  - root ------ 存放数据集的根目录。
  - train ------ 是否加载训练集。
  - transform ------ 对数据集进行预处理的变换。
  - download ------ 是否下载数据集。
- 意义：加载MNIST数据集。
- 用法：
  python 复制代码
```
train_dataset = torchvision.datasets.MNIST(root='../../data', train=True, transform=transforms.ToTensor(), download=True)
```
torch.utils.data.DataLoader(...)
- 格式：torch.utils.data.DataLoader(dataset, batch_size, shuffle)
- 参数：
  - dataset ------ 加载的数据集。
  - batch_size ------ 每个批次的样本数。
  - shuffle ------ 是否在每个epoch开始时打乱数据。
- 意义：创建一个数据加载器，用于批量加载数据。
- 用法：
  python 复制代码
```
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
```
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激活层。
- 用法：
  python 复制代码
```
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)
```
nn.CrossEntropyLoss()
- 格式：nn.CrossEntropyLoss()
- 参数：无默认参数。
- 意义：创建一个计算交叉熵损失的模块，适用于多分类问题。
- 用法：
  python 复制代码
```
criterion = nn.CrossEntropyLoss()
```
torch.optim.Adam(...)
- 格式：torch.optim.Adam(params, lr)
- 参数：
  - params ------ 模型参数的迭代器。
  - lr ------ 学习率。
- 意义：创建Adam优化器，用于模型的参数更新。
- 用法：
  python 复制代码
```
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
```
.to(device)
- 格式：.to(device)
- 参数：device ------ 设备对象。
- 意义：将模型或张量移动到指定的设备。
- 用法：
  python 复制代码
```
images = images.to(device)
labels = labels.to(device)
```
.reshape(-1, 28*28)
- 格式：reshape(shape)
- 参数：shape ------ 期望的新形状，-1表示自动计算该维度的大小。
- 意义：重塑张量的形状。
- 用法：
  python 复制代码
```
images = images.reshape(-1, 28*28)
```
torch.max(outputs.data, 1)
- 格式：torch.max(input, dim, keepdim=False)
- 参数：
  - input ------ 输入张量。
  - dim ------ 要计算最大值的维度。
- 意义：计算张量在指定维度上的最大值和索引。
- 用法：
  python 复制代码
```
_, predicted = torch.max(outputs.data, 1)
```
torch.no_grad()
- 格式：torch.no_grad()
- 参数：无。
- 意义：上下文管理器，用于在测试或推理阶段禁用梯度计算。
- 用法：
  python 复制代码
```
with torch.no_grad():
    # 测试模型的代码
```
.sum().item()
- 格式：.sum(dim, keepdim=False) 和 .item()
- 参数：dim ------ 求和的维度。
- 意义：计算张量在指定维度上的和，并转换为Python数值。
- 用法：
  python 复制代码
```
correct += (predicted == labels).sum().item()
```
torch.save(obj, f)
- 格式：torch.save(obj, f)
- 参数：
  - obj ------ 要保存的对象。
  - f ------ 文件路径或文件对象。
- 意义：将对象（如模型状态字典）保存到文件。
- 用法：
  python 复制代码
```
torch.save(model.state_dict(), 'model.ckpt')
```

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

the end