神经网络基础之模型构造

层和块

个人理解：模型的块就是一个类，我们可以在里面添加很多函数层之类的，写任何的东西，我们实例化一下就生成了模型

为了实现这些复杂的网络，我们引入了神经网络 块_的概念。 _块（block）可以描述单个层、由多个层组成的组件或整个模型本身。 使用块进行抽象的一个好处是可以将一些块组合成更大的组件，

继承Module类来构造模型

Module的子类

Module类是一个通用的部件，我们可以继承Module 类来创建其他类比如：Sequential、ModuleList、ModuleDict

1、可以通过继承Module类来构造模型。
2、Sequential、ModuleList、ModuleDict类都继承自Module类。
3、与Sequential不同，ModuleList和ModuleDict并没有定义一个完整的网络，它们只是将不同的模块存放在一起，需要自己定义forward函数。
4、虽然Sequential等类可以使模型构造更加简单，但直接继承Module类可以极大地拓展模型构造的灵活性。

代码：

import torch
from torch import nn#导入nn这个模型
from torch.nn import functional as F #从nn中导入functional这个模型 记作F,这个模块有一些函数

net = nn.Sequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))#由线性层，relu层，线性层构造一个net模型

X = torch.rand(2, 20)#生成一个随机的输入
net(X)#输出

自定义的块

class MLP(nn.Module):#MLP是nnmodule的子类
    # 用模型参数声明层。这里，我们声明两个全连接的层
    def __init__(self):
        # 调用MLP的父类Module的构造函数来执行必要的初始化。
        # 这样，在类实例化时也可以指定其他函数参数，例如模型参数params（稍后将介绍）
        super().__init__()
        self.hidden = nn.Linear(20, 256)  # 隐藏层#调用nnmodular模块中的层
        self.out = nn.Linear(256, 10)  # 输出层

    # 定义模型的前向传播，即如何根据输入X返回所需的模型输出
    def forward(self, X):
        # 注意，这里我们使用ReLU的函数版本，其在nn.functional模块中定义。
        return self.out(F.relu(self.hidden(X)))

#试一下这个函数
net = MLP()          #实例化模型，把我们自定义构造的module起个名字叫做net
net(X)               #把x输入到netmodule中去

顺序块

class MySequential(nn.Module):#定义一个nn模型的子类
    def __init__(self, *args):
        super().__init__()#初始化
        for idx, module in enumerate(args):
            # 这里，module是Module子类的一个实例。我们把它保存在'Module'类的成员
            # 变量_modules中。module的类型是OrderedDict
            self._modules[str(idx)] = module

    def forward(self, X):
        # OrderedDict保证了按照成员添加的顺序遍历它们
        for block in self._modules.values():
            X = block(X)
        return X
#测试一下函数
net = MySequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))#实例化我们sequential类的实例
net(X)

前向传播函数中执行代码

class FixedHiddenMLP(nn.Module):
    def __init__(self):
        super().__init__()
        # 不计算梯度的随机权重参数。因此其在训练期间保持不变
        self.rand_weight = torch.rand((20, 20), requires_grad=False)
        self.linear = nn.Linear(20, 20)

    def forward(self, X):
        X = self.linear(X)
        # 使用创建的常量参数以及relu和mm函数
        X = F.relu(torch.mm(X, self.rand_weight) + 1)
        # 复用全连接层。这相当于两个全连接层共享参数
        X = self.linear(X)
        # 控制流
        while X.abs().sum() > 1:
            X /= 2
        return X.sum()
#测试函数
net = FixedHiddenMLP()
net(X)

混合搭配各种组合块的方法

class NestMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(nn.Linear(20, 64), nn.ReLU(),
                                 nn.Linear(64, 32), nn.ReLU())
        self.linear = nn.Linear(32, 16)

    def forward(self, X):
        return self.linear(self.net(X))

chimera = nn.Sequential(NestMLP(), nn.Linear(16, 20), FixedHiddenMLP())
chimera(X)

Original: https://blog.csdn.net/qq_43448818/article/details/124190420
Author: (ノへ￣、)。
Title: 神经网络基础之模型构造