马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。
您需要 登录 才可以下载或查看，没有账号？立即注册
x
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() 方法中直接利用函数式接口来界说前向传播，镌汰代码量。
- 自界说层：封装特定的操作，形成可复用的模块，适用于需要自界说操作的场景。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。 |
