pytorch中神经网络的定义方法

1. 继承 torch.nn.Module 类（推荐方法）

最常见和推荐的方式是通过继承 torch.nn.Module 类来创建一个自定义的神经网络模型。在这种方式下，你需要定义 __init__() 方法来初始化网络层，并在 forward() 方法中定义前向传播逻辑。

示例：一个简单的全连接神经网络

import torch
import torch.nn as nn

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        # 定义网络层
        self.fc1 = nn.Linear(784, 128)  # 输入层：28x28 图像展平为 784
        self.fc2 = nn.Linear(128, 64)   # 隐藏层
        self.fc3 = nn.Linear(64, 10)    # 输出层：10 类分类

        # 激活函数
        self.relu = nn.ReLU()

    def forward(self, x):
        # 前向传播逻辑
        x = self.relu(self.fc1(x))  # 输入 -> 第一层 -> 激活
        x = self.relu(self.fc2(x))  # 第二层 -> 激活
        x = self.fc3(x)             # 输出层
        return x

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

解释：

• __init__() ：在这个方法中定义了神经网络的层（如 nn.Linear），并且可以定义激活函数（如 nn.ReLU()）。
• forward()：定义了数据从输入到输出的传播方式。

这种方式非常灵活，可以用于复杂的网络结构设计。

2. 使用 nn.Sequential（顺序模型）

如果你的网络是一个简单的按顺序排列的层，nn.Sequential 提供了一种更加简洁的方式来定义模型。nn.Sequential 允许你将多个层按顺序进行组合，自动处理前向传播的顺序。

示例：使用 nn.Sequential 定义一个简单的全连接神经网络

import torch
import torch.nn as nn

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        # 使用 nn.Sequential 顺序堆叠层
        self.model = nn.Sequential(
            nn.Linear(784, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 10)
        )

    def forward(self, x):
        return self.model(x)

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

解释：

• nn.Sequential：这种方式会将层按顺序堆叠在一起，并且自动处理前向传播。
• 适用于结构简单、每一层都执行相同操作（如全连接层 + 激活函数）的模型。

3. 使用 torch.nn.ModuleList 和 torch.nn.ModuleDict

如果你的网络包含多个层，但它们的顺序不是简单的顺序堆叠，或者你需要在网络中使用循环和条件语句，nn.ModuleList 和 nn.ModuleDict 提供了更大的灵活性。

• ModuleList：用于存储层的列表，可以通过索引访问这些层。
• ModuleDict：用于存储层的字典，可以通过键来访问层。

示例：使用 ModuleList 定义一个多层感知机（MLP）

import torch
import torch.nn as nn

class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        # 使用 ModuleList 来存储多个全连接层
        self.layers = nn.ModuleList([
            nn.Linear(784, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 10)
        ])

    def forward(self, x):
        for layer in self.layers:
            x = layer(x)  # 按顺序执行每一层
        return x

# 创建模型实例
model = MLP()
print(model)

解释：

• ModuleList ：ModuleList 可以存储多个层，这些层可以通过 for 循环逐一执行。
• 在 forward() 方法中，我们使用 for 循环按顺序执行每一层。

4. 使用 torch.nn.functional（函数式接口）

torch.nn.functional 包含了很多与神经网络相关的函数，这些函数不需要创建层实例，而是可以在 forward() 方法中直接调用。通过这种方式，你可以避免显式地使用 nn.Module 中的层类，减少代码量。

示例：使用 torch.nn.functional 定义一个简单的网络

import torch
import torch.nn.functional as F
import torch.nn as nn

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)
        # self.relu = nn.ReLU()

    def forward(self, x):
        # 使用 nn.functional 进行激活函数处理而不是在init中定义激活层
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

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

解释：

• torch.nn.functional ：在 forward() 中使用 F.relu() 等函数式接口，避免显式地调用 nn.ReLU() 层实例。这种方式适合你只需要用函数对数据进行操作的场景。

5. 自定义层

除了 nn.Module 和 nn.Sequential，你还可以通过继承 nn.Module 来定义自定义的层。这样你可以封装复杂的操作，形成可复用的模块。

示例：自定义一个激活函数层

import torch
import torch.nn as nn

class MyReLU(nn.Module):
    def __init__(self):
        super(MyReLU, self).__init__()

    def forward(self, x):
        return torch.maximum(x, torch.tensor(0.0))  # 自定义 ReLU 激活

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)
        self.relu = MyReLU()  # 使用自定义的激活函数层

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

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

解释：

• 自定义层 ：你可以继承 nn.Module 来定义自己的层，并在 forward() 方法中定义自定义的前向传播行为。这种方式适用于特殊的操作，如自定义的激活函数、正则化、特殊的损失函数等。

总结

在 PyTorch 中定义神经网络的常见方法有：

1. 继承 torch.nn.Module：适用于复杂的网络结构，最常用的方式。
2. 使用 nn.Sequential：适用于结构简单、按顺序堆叠的层。
3. 使用 ModuleList 和 ModuleDict：适用于网络中有循环或更复杂结构的场景。
4. 使用 torch.nn.functional ：在 forward() 方法中直接使用函数式接口来定义前向传播，减少代码量。
5. 自定义层：封装特定的操作，形成可复用的模块，适用于需要自定义操作的场景。