pytorch学习10之模型构建

顺序块
# 顺序块nn.sequential
# 一种将块逐个追加到列表中的函数；
# 一种前向传播函数，用于将输入按追加块的顺序传递给块组成的“链条”。
# 简单依赖预定义的神经网络，不需要自己定义新的类

import torch
from torch import nn


class MySequential(nn.Module):
    # *args相当于收集参数,把若干个参数打包成一个进行传入
    def __init__(self, *args):
        super().__init__()
        # 将所有传进来的层（参数）。按顺序放到_modules函数中，将每层作为一个字典
        for idx, module in enumerate(args):
            #
            self._modules[str(idx)] = module
        # for block in args:
            # 这里，module是Module子类的一个实例。我们把它保存在'Module'类的成员
            # 变量_modules中。_module的类型是OrderedDict
            # self.__module__[block] = block

    def forward(self, X):
        # OrderedDict保证了按照成员添加的顺序遍历它们
        # 按顺序一层层调z用
        for block in self._modules.values():
            X = block(X)
        return X


net = MySequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
X = torch.rand(2, 20)
print(net(X))

FixedHiddenMLP在前向传播函数中执行代码

FixedHiddenMLP相对于MySequential具有一定的灵活性，可以进行自定义的运算，即执行任意的数学运算

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

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

    # 任意参数传入
    def forward(self, X):
        X = self.linear(X)
        # 使用创建的常量参数以及relu和mm函数
        # 手写rand_weight和X做乘法mm，然后偏移1
        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()
X = torch.rand(2, 20)
print(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())
# X = torch.rand(2, 20)
print(chimera(X))

小结

• 一个块可以由许多层组成；一个块可以由许多块组成。

• 块可以包含代码。

• 块负责大量的内部处理，包括参数初始化和反向传播。

• 层和块的顺序连接由Sequential块处理。