现在位置: 首页 > PyTorch 教程 > 正文

PyTorch 神经网络基础

神经网络是一种模仿人脑处理信息方式的计算模型，它由许多相互连接的节点（神经元）组成，这些节点按层次排列。

神经网络的强大之处在于其能够自动从大量数据中学习复杂的模式和特征，无需人工设计特征提取器。

随着深度学习的发展，神经网络已经成为解决许多复杂问题的关键技术。

神经元（Neuron）

神经元是神经网络的基本单元，它接收输入信号，通过加权求和后与偏置（bias）相加，然后通过激活函数处理以产生输出。

神经元的权重和偏置是网络学习过程中需要调整的参数。

输入和输出:

  • 输入（Input）：输入是网络的起始点，可以是特征数据，如图像的像素值或文本的词向量。
  • 输出（Output）：输出是网络的终点，表示模型的预测结果，如分类任务中的类别标签。

神经元接收多个输入（例如x1, x2, ..., xn），如果输入的加权和大于激活阈值（activation potential），则产生二进制输出。

神经元的输出可以看作是输入的加权和加上偏置（bias），神经元的数学表示：

这里，wj 是权重，xj 是输入，而 Bias 是偏置项。

层（Layer）

输入层和输出层之间的层被称为隐藏层，层与层之间的连接密度和类型构成了网络的配置。

神经网络由多个层组成，包括：

  • 输入层（Input Layer）：接收原始输入数据。
  • 隐藏层（Hidden Layer）：对输入数据进行处理，可以有多个隐藏层。
  • 输出层（Output Layer）：产生最终的输出结果。

典型的神经网络架构:

前馈神经网络（Feedforward Neural Network，FNN）

前馈神经网络（Feedforward Neural Network，FNN）是神经网络家族中的基本单元。

前馈神经网络特点是数据从输入层开始，经过一个或多个隐藏层，最后到达输出层，全过程没有循环或反馈。

前馈神经网络的基本结构：

  • 输入层： 数据进入网络的入口点。输入层的每个节点代表一个输入特征。

  • 隐藏层：一个或多个层，用于捕获数据的非线性特征。每个隐藏层由多个神经元组成，每个神经元通过激活函数增加非线性能力。

  • 输出层：输出网络的预测结果。节点数和问题类型相关，例如分类问题的输出节点数等于类别数。

  • 连接权重与偏置：每个神经元的输入通过权重进行加权求和，并加上偏置值，然后通过激活函数传递。

循环神经网络（Recurrent Neural Network, RNN）

循环神经网络（Recurrent Neural Network, RNN）络是一类专门处理序列数据的神经网络，能够捕获输入数据中时间或顺序信息的依赖关系。

RNN 的特别之处在于它具有"记忆能力"，可以在网络的隐藏状态中保存之前时间步的信息。

循环神经网络用于处理随时间变化的数据模式。

在 RNN 中，相同的层被用来接收输入参数，并在指定的神经网络中显示输出参数。

PyTorch 提供了强大的工具来构建和训练神经网络。

神经网络在 PyTorch 中是通过 torch.nn 模块来实现的。

torch.nn 模块提供了各种网络层（如全连接层、卷积层等）、损失函数和优化器，让神经网络的构建和训练变得更加方便。

在 PyTorch 中，构建神经网络通常需要继承 nn.Module 类。

nn.Module 是所有神经网络模块的基类，你需要定义以下两个部分：

  • __init__()：定义网络层。
  • forward()：定义数据的前向传播过程。

简单的全连接神经网络（Fully Connected Network）：

实例

import torch
import torch.nn as nn

# 定义一个简单的神经网络模型
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        # 定义一个输入层到隐藏层的全连接层
        self.fc1 = nn.Linear(2, 2)  # 输入 2 个特征，输出 2 个特征
        # 定义一个隐藏层到输出层的全连接层
        self.fc2 = nn.Linear(2, 1)  # 输入 2 个特征，输出 1 个预测值
   
    def forward(self, x):
        # 前向传播过程
        x = torch.relu(self.fc1(x))  # 使用 ReLU 激活函数
        x = self.fc2(x)  # 输出层
        return x

# 创建模型实例
model = SimpleNN()

# 打印模型
print(model)

输出结果如下：

SimpleNN(
  (fc1): Linear(in_features=2, out_features=2, bias=True)
  (fc2): Linear(in_features=2, out_features=1, bias=True)
)

PyTorch 提供了许多常见的神经网络层，以下是几个常见的：

  • nn.Linear(in_features, out_features)：全连接层，输入 in_features 个特征，输出 out_features 个特征。
  • nn.Conv2d(in_channels, out_channels, kernel_size)：2D 卷积层，用于图像处理。
  • nn.MaxPool2d(kernel_size)：2D 最大池化层，用于降维。
  • nn.ReLU()：ReLU 激活函数，常用于隐藏层。
  • nn.Softmax(dim)：Softmax 激活函数，通常用于输出层，适用于多类分类问题。

激活函数（Activation Function）

激活函数决定了神经元是否应该被激活。它们是非线性函数，使得神经网络能够学习和执行更复杂的任务。常见的激活函数包括：

  • Sigmoid：用于二分类问题，输出值在 0 和 1 之间。
  • Tanh：输出值在 -1 和 1 之间，常用于输出层之前。
  • ReLU（Rectified Linear Unit）：目前最流行的激活函数之一，定义为 f(x) = max(0, x)，有助于解决梯度消失问题。
  • Softmax：常用于多分类问题的输出层，将输出转换为概率分布。

实例

import torch.nn.functional as F

# ReLU 激活
output = F.relu(input_tensor)

# Sigmoid 激活
output = torch.sigmoid(input_tensor)

# Tanh 激活
output = torch.tanh(input_tensor)

损失函数（Loss Function）

损失函数用于衡量模型的预测值与真实值之间的差异。

常见的损失函数包括：

  • 均方误差（MSELoss）：回归问题常用，计算输出与目标值的平方差。
  • 交叉熵损失（CrossEntropyLoss）：分类问题常用，计算输出和真实标签之间的交叉熵。
  • BCEWithLogitsLoss：二分类问题，结合了 Sigmoid 激活和二元交叉熵损失。

实例

# 均方误差损失
criterion = nn.MSELoss()

# 交叉熵损失
criterion = nn.CrossEntropyLoss()

# 二分类交叉熵损失
criterion = nn.BCEWithLogitsLoss()

优化器（Optimizer）

优化器负责在训练过程中更新网络的权重和偏置。

常见的优化器包括：

  • SGD（随机梯度下降）
  • Adam（自适应矩估计）
  • RMSprop（均方根传播）

实例

import torch.optim as optim

# 使用 SGD 优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 使用 Adam 优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)

训练过程（Training Process）

训练神经网络涉及以下步骤：

  1. 准备数据：通过 DataLoader 加载数据。
  2. 定义损失函数和优化器。
  3. 前向传播：计算模型的输出。
  4. 计算损失：与目标进行比较，得到损失值。
  5. 反向传播：通过 loss.backward() 计算梯度。
  6. 更新参数：通过 optimizer.step() 更新模型的参数。
  7. 重复上述步骤，直到达到预定的训练轮数。

实例

# 假设已经定义好了模型、损失函数和优化器

# 训练数据示例
X = torch.randn(10, 2)  # 10 个样本，每个样本有 2 个特征
Y = torch.randn(10, 1)  # 10 个目标标签

# 训练过程
for epoch in range(100):  # 训练 100 轮
    model.train()  # 设置模型为训练模式
    optimizer.zero_grad()  # 清除梯度
    output = model(X)  # 前向传播
    loss = criterion(output, Y)  # 计算损失
    loss.backward()  # 反向传播
    optimizer.step()  # 更新权重
   
    if (epoch + 1) % 10 == 0:  # 每 10 轮输出一次损失
        print(f'Epoch [{epoch + 1}/100], Loss: {loss.item():.4f}')

测试与评估

训练完成后，需要对模型进行测试和评估。

常见的步骤包括：

  • 计算测试集的损失：测试模型在未见过的数据上的表现。
  • 计算准确率（Accuracy）：对于分类问题，计算正确预测的比例。

实例

# 假设你有测试集 X_test 和 Y_test
model.eval()  # 设置模型为评估模式
with torch.no_grad():  # 在评估过程中禁用梯度计算
    output = model(X_test)
    loss = criterion(output, Y_test)
    print(f'Test Loss: {loss.item():.4f}')

神经网络类型

  1. 前馈神经网络（Feedforward Neural Networks）：数据单向流动，从输入层到输出层，无反馈连接。
  2. 卷积神经网络（Convolutional Neural Networks, CNNs）：适用于图像处理，使用卷积层提取空间特征。
  3. 循环神经网络（Recurrent Neural Networks, RNNs）：适用于序列数据，如时间序列分析和自然语言处理，允许信息反馈循环。
  4. 长短期记忆网络（Long Short-Term Memory, LSTM）：一种特殊的RNN，能够学习长期依赖关系。

torch.nn 参考

以下是 PyTorch 中最常用的 torch.nn 函数和类：

模型定义基础

函数 描述 示例
nn.Module 所有神经网络模块的基类 class Net(nn.Module): ...
nn.Sequential 顺序容器，按顺序执行各层 nn.Sequential(conv, relu, pool)
nn.ModuleList 将子模块存储在列表中 self.layers = nn.ModuleList([...])
nn.Parameter 创建可学习的参数张量 self.w = nn.Parameter(torch.randn(n))

卷积层

函数 描述 示例
nn.Conv1d 一维卷积（文本、音频） nn.Conv1d(3, 64, 3)
nn.Conv2d 二维卷积（图像） nn.Conv2d(3, 64, 3, padding=1)
nn.Conv3d 三维卷积（视频） nn.Conv3d(3, 64, 3)
nn.ConvTranspose2d 转置卷积（解码器、上采样） nn.ConvTranspose2d(64, 3, 2, stride=2)

池化层

函数 描述 示例
nn.MaxPool2d 二维最大池化 nn.MaxPool2d(2, 2)
nn.AvgPool2d 二维平均池化 nn.AvgPool2d(2, 2)
nn.AdaptiveAvgPool2d 自适应平均池化（固定输出尺寸） nn.AdaptiveAvgPool2d((1, 1))
nn.AdaptiveMaxPool2d 自适应最大池化（固定输出尺寸） nn.AdaptiveMaxPool2d((1, 1))

线性层

函数 描述 示例
nn.Linear 全连接层（线性变换） nn.Linear(128, 64)
nn.Bilinear 双线性层 nn.Bilinear(128, 64, 32)
函数 描述 示例
nn.ReLU ReLU 激活函数，f(x) = max(0, x) nn.ReLU()
nn.GELU 高斯误差线性单元（Transformer 默认） nn.GELU()
nn.SiLU Swish 激活函数 nn.SiLU()
nn.Tanh 双曲正切 nn.Tanh()
nn.Sigmoid Sigmoid 激活函数 nn.Sigmoid()
nn.Softmax Softmax 激活函数 nn.Softmax(dim=1)
nn.LogSoftmax Log Softmax（数值稳定） nn.LogSoftmax(dim=1)
nn.LeakyReLU LeakyReLU，允许负值有小幅梯度 nn.LeakyReLU(0.01)
nn.ELU 指数线性单元 nn.ELU()

归一化层

函数 描述 示例
nn.BatchNorm2d 二维批归一化（卷积网络常用） nn.BatchNorm2d(64)
nn.LayerNorm 层归一化（Transformer 常用） nn.LayerNorm(512)
nn.GroupNorm 组归一化（ResNet 等常用） nn.GroupNorm(4, 64)
nn.InstanceNorm2d 实例归一化（风格迁移常用） nn.InstanceNorm2d(64)

循环层

函数 描述 示例
nn.LSTM LSTM 长短期记忆层 nn.LSTM(256, 512, 2)
nn.GRU GRU 门控循环单元层 nn.GRU(256, 512, 2)
nn.RNN 简单 RNN 层 nn.RNN(256, 512, 2)

Transformer 层

函数 描述 示例
nn.Transformer 完整 Transformer 模型 nn.Transformer(d_model=512, nhead=8)
nn.TransformerEncoder Transformer 编码器 nn.TransformerEncoder(layer, num_layers=6)
nn.TransformerDecoder Transformer 解码器 nn.TransformerDecoder(layer, num_layers=6)
nn.TransformerEncoderLayer Transformer 编码器层 nn.TransformerEncoderLayer(512, 8)
nn.MultiheadAttention 多头注意力机制 nn.MultiheadAttention(512, 8)

嵌入层

函数 描述 示例
nn.Embedding 嵌入层（词汇映射到向量） nn.Embedding(10000, 256)
nn.EmbeddingBag 嵌入袋（聚合多个嵌入） nn.EmbeddingBag(10000, 256)

Dropout 层

函数 描述 示例
nn.Dropout 随机丢弃（防止过拟合） nn.Dropout(0.5)
nn.Dropout2d 2D Dropout（按特征图丢弃） nn.Dropout2d(0.5)

损失函数

函数 描述 示例
nn.CrossEntropyLoss 交叉熵损失（多分类） nn.CrossEntropyLoss()
nn.MSELoss 均方误差损失（回归） nn.MSELoss()
nn.L1Loss L1 损失（MAE） nn.L1Loss()
nn.BCEWithLogitsLoss 带 Sigmoid 的二元交叉熵 nn.BCEWithLogitsLoss()
nn.HuberLoss Huber 损失（鲁棒回归） nn.HuberLoss()
nn.NLLLoss 负对数似然损失 nn.NLLLoss()

功能性函数（nn.functional）

函数 描述 示例
F.relu ReLU 激活 F.relu(x)
F.gelu GELU 激活 F.gelu(x)
F.sigmoid Sigmoid 激活 F.sigmoid(x)
F.softmax Softmax 激活 F.softmax(x, dim=1)
F.dropout Dropout 操作 F.dropout(x, 0.5, training)
F.conv2d 二维卷积 F.conv2d(x, weight, bias)
F.linear 线性变换 F.linear(x, weight, bias)
F.cross_entropy 交叉熵损失 F.cross_entropy(logits, targets)
F.mse_loss 均方误差损失 F.mse_loss(pred, target)
F.interpolate 插值（上/下采样） F.interpolate(x, scale_factor=2)
F.embedding 嵌入操作 F.embedding(indices, weight)

工具函数（nn.init）

函数 描述 示例
nn.init.xavier_uniform_ Xavier 均匀初始化 nn.init.xavier_uniform_(module.weight)
nn.init.xavier_normal_ Xavier 正态初始化 nn.init.xavier_normal_(module.weight)
nn.init.kaiming_uniform_ Kaiming 均匀初始化（适合 ReLU） nn.init.kaiming_uniform_(module.weight)
nn.init.kaiming_normal_ Kaiming 正态初始化（适合 ReLU） nn.init.kaiming_normal_(module.weight)
nn.init.zeros_ 零初始化 nn.init.zeros_(module.bias)
nn.init.normal_ 正态初始化 nn.init.normal_(module.weight, 0, 0.01)

工具函数（nn.utils）

函数 描述 示例
nn.utils.clip_grad_norm_ 裁剪梯度范数（防止梯度爆炸） nn.utils.clip_grad_norm_(model.parameters(), 1.0)
nn.utils.weight_norm 权重归一化 nn.utils.weight_norm(module, 'weight')
nn.utils.spectral_norm 谱归一化（GAN 常用） nn.utils.spectral_norm(module, 'weight')
nn.utils.rnn.pack_padded_sequence 打包变长序列 pack_padded_sequence(x, lengths)
nn.utils.rnn.pad_packed_sequence 解包序列 pad_packed_sequence(packed)
返回顶部
© 2026 菜鸟教程
备案号：闽ICP备15012807号-1

∧