0. Containers

Module：所有神经网络模块的基类
Sequential：一个顺序容器

# Using Sequential to create a small model.
model = nn.Sequential(
          nn.Conv2d(1,20,5),
          nn.ReLU(),
          nn.Conv2d(20,64,5),
          nn.ReLU()
        )
# Using Sequential with OrderedDict. This is functionally the
# same as the above code
model = nn.Sequential(OrderedDict([
          ('conv1', nn.Conv2d(1,20,5)),
          ('relu1', nn.ReLU()),
          ('conv2', nn.Conv2d(20,64,5)),
          ('relu2', nn.ReLU())
        ]))

ModuleList：在列表中保存子模块

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(10)])
    def forward(self, x):
        # ModuleList can act as an iterable, or be indexed using ints
        for i, l in enumerate(self.linears):
            x = self.linears[i // 2](x) + l(x)
        return x

ModuleDict：在字典中保存子模块

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.choices = nn.ModuleDict({
                'conv': nn.Conv2d(10, 10, 3),
                'pool': nn.MaxPool2d(3)
        })
        self.activations = nn.ModuleDict([
                ['lrelu', nn.LeakyReLU()],
                ['prelu', nn.PReLU()]
        ])
    def forward(self, x, choice, act):
        x = self.choices[choice](x)
        x = self.activations[act](x)
        return x

ParameterList：将参数保存在列表中

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.params = nn.ParameterList([nn.Parameter(torch.randn(10, 10)) for i in range(10)])
    def forward(self, x):
        # ParameterList can act as an iterable, or be indexed using ints
        for i, p in enumerate(self.params):
            x = self.params[i // 2].mm(x) + p.mm(x)
        return x

ParameterDict：将参数保存在字典中

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.params = nn.ParameterDict({
                'left': nn.Parameter(torch.randn(5, 10)),
                'right': nn.Parameter(torch.randn(5, 10))
        })
    def forward(self, x, choice):
        x = self.params[choice].mm(x)
        return x

1. Convolution Layers

nn.Conv1d：普通一维卷积，常用于文本。参数个数 = 输入通道数×卷积核尺寸(如3)×卷积核个数 + 卷积核尺寸(如3）
nn.Conv2d：普通二维卷积，常用于图像。参数个数 = 输入通道数×卷积核尺寸(如3乘3)×卷积核个数 + 卷积核尺寸(如3乘3)

通过调整dilation参数大于1，可以变成空洞卷积，增大卷积核感受野。

通过调整groups参数不为1，可以变成分组卷积。分组卷积中不同分组使用相同的卷积核，显著减少参数数量。

通过调整groups参数等于通道数(channels)，可以变成DW卷积，相当于tensorflow中的二维深度卷积层tf.keras.layers.DepthwiseConv2D

利用分组卷积和1乘1卷积的组合操作，可以变成可分离卷积，可以构造相当于Keras中的二维深度可分离卷积层tf.keras.layers.SeparableConv2D

nn.Conv3d：普通三维卷积，常用于视频。参数个数 = 输入通道数×卷积核尺寸(如3乘3乘3)×卷积核个数 + 卷积核尺寸(如3乘3乘3) 。
nn.ConvTranspose1d：一维卷积转置层，数值不可逆，只是维度变换，转置卷积也是卷积
nn.ConvTranspose2d：二维卷积转置层，俗称反卷积层。并非卷积的逆操作，但在卷积核相同的情况下，当其输入尺寸是卷积操作输出尺寸的情况下，卷积转置的输出尺寸恰好是卷积操作的输入尺寸。在语义分割中可用于上采样。其实反卷积层也是卷积，数值是不可逆的，只是对维度进行了改变而已。
nn.ConvTranspose3d：三维卷积转置层，数值不可逆，只是维度变化，转置卷积也是卷积
nn.Unfold：滑动窗口提取层。其参数和卷积操作nn.Conv2d相同。

实际上，卷积操作可以等价于nn.Unfold和nn.Linear以及nn.Fold的一个组合。

其中nn.Unfold操作可以从输入中提取各个滑动窗口的数值矩阵，并将其压平成一维。利用nn.Linear将nn.Unfold的输出和卷积核做乘法后，再使用nn.Fold操作将结果转换成输出图片形状。

nn.Fold：逆滑动窗口提取层。

2. Pooling layers

nn.MaxPool1d: 一维最大池化。
nn.MaxPool2d：二维最大池化。一种下采样方式。没有需要训练的参数。
nn.MaxPool3d：三维最大池化。
nn.MaxUnpool1d：一维最大逆池化。
nn.MaxUnpool2d：二维最大逆池化，将包含最大值索引的输出作为输入，其中所有非最大值都设置为零。

>>> pool = nn.MaxPool2d(2, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool2d(2, stride=2)
>>> input = torch.tensor([[[[ 1.,  2,  3,  4],
                            [ 5,  6,  7,  8],
                            [ 9, 10, 11, 12],
                            [13, 14, 15, 16]]]])
>>> output, indices = pool(input)
>>> unpool(output, indices)
tensor([[[[  0.,   0.,   0.,   0.],
          [  0.,   6.,   0.,   8.],
          [  0.,   0.,   0.,   0.],
          [  0.,  14.,   0.,  16.]]]])

nn.MaxUnpool3d：三维最大逆池化。
nn.AvgPool1d：一维平均池化。
nn.AvgPool2d：二维平均池化。
nn.AvgPool3d：三维平均池化。
nn.FractionalMaxPool2d：二维分数最大池化。普通最大池化通常输入尺寸是输出的整数倍。而分数最大池化则可以不必是整数。分数最大池化使用了一些随机采样策略，有一定的正则效果，可以用它来代替普通最大池化和Dropout层。
nn.FractionalMaxPool3d：三维分数最大池化。
nn.LPPool1d：一维功率平均池化。
nn.LPPool2d：二维功率平均池化。

在每个窗口上，计算的函数是：

1）在 p =∞, 一个得到 Max Pooling

2）在 p = 1 时，得到 Sum Pooling（与平均池化成正比）

nn.AdaptiveMaxPool1d：一维自适应最大池化。
nn.AdaptiveMaxPool2d：二维自适应最大池化。无论输入图像的尺寸如何变化，输出的图像尺寸是固定的。

该函数的实现原理，大概是通过输入图像的尺寸和要得到的输出图像的尺寸来反向推算池化算子的padding,stride等参数。

nn.AdaptiveMaxPool3d：三维自适应最大池化。
nn.AdaptiveAvgPool1d：一维自适应平均池化。
nn.AdaptiveAvgPool2d：二维自适应平均池化。无论输入的维度如何变化，输出的维度是固定的。
nn.AdaptiveAvgPool3d：三维自适应平均池化。

3. Padding Layers

nn.ReflectionPad2d：使用输入边界的反射填充输入张量。

>>> m = nn.ReflectionPad2d(2)
>>> input = torch.arange(9, dtype=torch.float).reshape(1, 1, 3, 3)
>>> input
tensor([[[[0., 1., 2.],
          [3., 4., 5.],
          [6., 7., 8.]]]])
>>> m(input)
tensor([[[[8., 7., 6., 7., 8., 7., 6.],
          [5., 4., 3., 4., 5., 4., 3.],
          [2., 1., 0., 1., 2., 1., 0.],
          [5., 4., 3., 4., 5., 4., 3.],
          [8., 7., 6., 7., 8., 7., 6.],
          [5., 4., 3., 4., 5., 4., 3.],
          [2., 1., 0., 1., 2., 1., 0.]]]])
>>> # using different paddings for different sides
>>> m = nn.ReflectionPad2d((1, 1, 2, 0))
>>> m(input)
tensor([[[[7., 6., 7., 8., 7.],
          [4., 3., 4., 5., 4.],
          [1., 0., 1., 2., 1.],
          [4., 3., 4., 5., 4.],
          [7., 6., 7., 8., 7.]]]])

nn.ReplicationPad1d：一维复制填充层。对一维张量样本通过复制边缘值填充扩展长度。
nn.ZeroPad2d：二维零值填充层。对二维张量样本在边缘填充0值.
nn.ConstantPad2d：二维常数填充层。对二维张量样本填充常数扩展长度。

4. Non-linear Activations (other)

nn.Softmin ：将 Softmin 函数应用于 n 维输入 Tensor
nn.Softmax ：将 Softmax 函数应用于 n 维输入张量
nn.Softmax2d ：将 SoftMax 应用于每个空间位置的特征。
nn.LogSoftmax：应用公式log(Softmax(x))
nn.AdaptiveLogSoftmaxWithLoss：应该是分布式训练的时候使用

5. Normalization Layers

nn.BatchNorm1d：一维批标准化层。通过线性变换将输入批次缩放平移到稳定的均值和标准差。可以增强模型对输入不同分布的适应性，加快模型训练速度，有轻微正则化效果。一般在激活函数之前使用。可以用afine参数设置该层是否含有可以训练的参数。
nn.BatchNorm2d：二维批标准化层。
nn.BatchNorm3d：三维批标准化层。
nn.GroupNorm：组归一化。一种替代批归一化的方法，将通道分成若干组进行归一。不受batch大小限制，据称性能和效果都优于BatchNorm。

>>> input = torch.randn(20, 6, 10, 10)
>>> # Separate 6 channels into 3 groups
>>> m = nn.GroupNorm(3, 6)
>>> # Separate 6 channels into 6 groups (equivalent with InstanceNorm)
>>> m = nn.GroupNorm(6, 6)
>>> # Put all 6 channels into a single group (equivalent with LayerNorm)
>>> m = nn.GroupNorm(1, 6)
>>> # Activating the module
>>> output = m(input)

nn.InstanceNorm2d: 样本归一化。较少使用。
nn.LayerNorm：层归一化。较少使用。
nn.LocalResponseNorm：由多个输入平面组成的输入信号进行局部响应归一化，其中通道占据第二维。LRN层是AlexNet网络中提出来的对局部神经元的活动创建竞争机制，使得其中响应比较大的值变得相对更大，并抑制其他反馈较小的神经元，能够增强模型的泛化能力。但是后来有了BN层之后，LRN层基本不用。

6. Recurrent Layers

nn.Embedding：嵌入层。一种比Onehot更加有效的对离散特征进行编码的方法。一般用于将输入中的单词映射为稠密向量。嵌入层的参数需要学习。
nn.LSTM：长短记忆循环网络层【支持多层】。最普遍使用的循环网络层。具有携带轨道，遗忘门，更新门，输出门。可以较为有效地缓解梯度消失问题，从而能够适用长期依赖问题。设置bidirectional = True时可以得到双向LSTM。需要注意的时，默认的输入和输出形状是(seq,batch,feature), 如果需要将batch维度放在第0维，则要设置batch_first参数设置为True。
nn.GRU：门控循环网络层【支持多层】。LSTM的低配版，不具有携带轨道，参数数量少于LSTM，训练速度更快。
nn.RNN：简单循环网络层【支持多层】。容易存在梯度消失，不能够适用长期依赖问题。一般较少使用。
nn.LSTMCell：长短记忆循环网络单元。和nn.LSTM在整个序列上迭代相比，它仅在序列上迭代一步。一般较少使用。
nn.GRUCell：门控循环网络单元。和nn.GRU在整个序列上迭代相比，它仅在序列上迭代一步。一般较少使用。
nn.RNNCell：简单循环网络单元。和nn.RNN在整个序列上迭代相比，它仅在序列上迭代一步。一般较少使用。

7. Transformer Layers

nn.Transformer：Transformer网络结构。Transformer网络结构是替代循环网络的一种结构，解决了循环网络难以并行，难以捕捉长期依赖的缺陷。它是目前NLP任务的主流模型的主要构成部分。Transformer网络结构由TransformerEncoder编码器和TransformerDecoder解码器组成。编码器和解码器的核心是MultiheadAttention多头注意力层。
nn.TransformerEncoder：Transformer编码器结构。由多个 nn.TransformerEncoderLayer编码器层组成。
nn.TransformerDecoder：Transformer解码器结构。由多个 nn.TransformerDecoderLayer解码器层组成。
nn.TransformerEncoderLayer：Transformer的编码器层。
nn.TransformerDecoderLayer：Transformer的解码器层。
nn.MultiheadAttention：多头注意力层。

8. Dropout Layers

nn.Dropout：一维随机丢弃层。一种正则化手段。
nn.Dropout2d：二维随机丢弃层。
nn.Dropout3d：三维随机丢弃层。
nn.Threshold：限幅层。当输入大于或小于阈值范围时，截断之。
nn.AlphaDropout：在输入上应用 Alpha Dropout
nn.FeatureAlphaDropout：随机屏蔽整个通道

9. Utils

clip_grad_norm_ 裁剪参数迭代的梯度范数。

clip_grad_value_ 在指定值处剪辑可迭代参数的梯度。

parameters_to_vector 将参数转换为一个向量

vector_to_parameters 将一个向量转换为参数

prune.BasePruningMethod 用于创建新修剪技术的抽象基类。

prune.PruningContainer 容器包含一系列用于迭代剪枝的剪枝方法。

prune.Identity 实用剪枝方法，不剪枝任何单元，但生成带有掩码的剪枝参数化。

prune.RandomUnstructured 随机修剪（当前未修剪的）张量中的单元。

prune.L1Unstructured 通过将具有最低 L1 范数的单元归零来修剪（当前未修剪）张量中的单元。

prune.RandomStructured 随机修剪张量中的整个（当前未修剪的）通道。

prune.LnStructured 根据 Ln范数在张量中修剪整个（当前未修剪的）通道。

prune.CustomFromMask

prune.identity 将修剪重新参数化应用于与调用的参数对应的张量name，module而不实际修剪任何单位。

prune.random_unstructured 通过删除随机选择的指定的（当前未修剪的）单元来修剪与调用name的参数相对应的张量。

prune.l1_unstructured 通过删除具有最低 L1 范数的指定数量的（当前未修剪的）单元来修剪与调用name的参数相对应的张量。

prune.random_structured 通过沿随机选择的指定删除指定的（当前未修剪的）通道来修剪与调用name的参数相对应的张量。

prune.ln_structured 通过沿着具有最低 L范数的指定通道移除指定的（当前未修剪的）通道，修剪与调用name的参数相对应的张量。

prune.global_unstructured parameters通过应用指定的来全局修剪与所有参数对应的张量pruning_method。

prune.custom_from_mask name通过在中module应用预先计算的掩码来修剪与调用的参数相对应的张量mask。

prune.remove 从模块中删除修剪重新参数化，从前向钩子中删除修剪方法。

prune.is_pruned module通过forward_pre_hooks在其继承自BasePruningMethod.

weight_norm 将权重归一化应用于给定模块中的参数。

remove_weight_norm 从模块中删除权重归一化重新参数化。

spectral_norm 将光谱归一化应用于给定模块中的参数。

remove_spectral_norm 从模块中删除光谱归一化重新参数化。

skip_init 给定一个模块类对象和 args / kwargs，在不初始化参数 / 缓冲区的情况下实例化模块。

parametrizations.orthogonal 将正交或酉参数化应用于矩阵或一组矩阵。

parametrizations.spectral_norm 将光谱归一化应用于给定模块中的参数。

parametrize.register_parametrization 向模块中的张量添加参数化。

parametrize.remove_parametrizations 删除模块中张量的参数化。

parametrize.cached 上下文管理器，在注册的参数化中启用缓存系统register_parametrization()。

parametrize.is_parametrized True如果模块具有活动参数化，则返回。

parametrize.ParametrizationList original保存和管理or original0、、的顺序容器original1。

nn.utils.rnn.PackedSequence batch_sizes保存打包序列的数据和列表。

nn.utils.rnn.pack_padded_sequence 打包一个包含可变长度填充序列的张量。

nn.utils.rnn.pad_packed_sequence 填充一组打包的可变长度序列。

nn.utils.rnn.pad_sequence 填充可变长度张量列表padding_value

nn.utils.rnn.pack_sequence 打包可变长度张量列表

nn.Flatten 将连续的暗淡范围展平为张量。

nn.Unflatten 将张量变平展开为所需的形状。

参考资料：

pytorch学习文档~主要涉及神经网络各个层的调用

模型层layers总结

【40】torch.nn汇总（各类与函数接口的解释说明）

0. Containers

1. Convolution Layers

2. Pooling layers

3. Padding Layers

4. Non-linear Activations (other)

5. Normalization Layers

6. Recurrent Layers

7. Transformer Layers

8. Dropout Layers

9. Utils

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【40】torch.nn汇总（各类与函数接口的解释说明）

0. Containers

1. Convolution Layers

2. Pooling layers

3. Padding Layers

4. Non-linear Activations (other)

5. Normalization Layers

6. Recurrent Layers

7. Transformer Layers

8. Dropout Layers

9. Utils

热门文章

最新文章

相关电子书