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