torch.nn快速参考手册

一.torch.nn简介
二.神经网络容器
三.线性层
四.卷积层
五.池化层
六.激活函数
七.损失函数
八.归一化层
九.循环神经网络层
十.嵌入层
十一.Dropout层
十二.实用函数
回到顶部

# torch.nn快速参考手册

## 一.torch.nn简介<a name="torch.nn简介"></a>

PyTorch的torch.nn模块是构建和训练神经网络的核心模块，它提供了丰富的类和函数来定义和操作神经网络。

以下是 torch.nn模块的一些关键组成部分及其功能：

1. **nn.Module 类**：nn.Module是所有自定义神经网络模型的基类。用户通常会从这个类派生自己的模型类，并在其中定义网络层结构以及前向传播函数（forward pass）。

2. **预定义层（Modules）**：包括各种类型的层组件，例如卷积层（nn.Conv1d、nn.Conv2d、nn.Conv3d）、全连接层（nn.Linear）、激活函数（nn.ReLU、nn.Sigmoid、nn.Tanh）等。

3. **容器类**：nn.Sequential：允许将多个层按顺序组合起来，形成简单的线性堆叠网络。nn.ModuleList和nn.ModuleDict：可以动态地存储和访问子模块，支持可变长度或命名的模块集合。

4. **损失函数（Loss Functions）**：torch.nn包含了一系列用于衡量模型预测与真实标签之间差异的损失函数，例如均方误差损失（nn.MSELoss）、交叉熵损失（nn.CrossEntropyLoss）等。

5. **实用函数接口（Functional Interface）**：nn.functional（通常简写为F），包含了许多可以直接作用于张量上的函数，它们实现了与层对象相同的功能，但不具有参数保存和更新的能力。例如，可以使用 F.relu() 直接进行ReLU操作，或者 F.conv2d()进行卷积操作。

6. **初始化方法**：torch.nn.init提供了一些常用的权重初始化策略，比如Xavier初始化 (nn.init.xavier_uniform_()) 和Kaiming初始化 (nn.init.kaiming_uniform_())，这些对于成功训练神经网络至关重要。

以下是基于torch.nn构建一个简单卷积神经网络的示例：

```python
import torch.nn as nn
# 构建一个CNN
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool2d(kernel_size=2)
        # 定义卷积层：输入1通道，输出32通道，卷积核大小3x3
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        # 定义卷积层：输入32通道，输出64通道，卷积核大小3x3
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        # 定义全连接层
        self.fc1 = nn.Linear(64 * 7 * 7, 128)  # 输入大小 = 特征图大小 * 通道数
        self.fc2 = nn.Linear(128, 10)  # 10 个类别

def forward(self, x):
        x = self.relu(self.conv1(x))  # 第一层卷积 + ReLU
        x = self.pool(x)     # 最大池化
        x = self.relu(self.conv2(x))  # 第二层卷积 + ReLU
        x = self.pool(x)     # 最大池化
        x = x.view(-1, 64 * 7 * 7) # 展平操作
        x = self.relu(self.fc1(x))    # 全连接层 + ReLU
        x = self.fc2(x)            # 全连接层输出
        return x
```

## 二.神经网络容器<a name="神经网络容器"></a>

| 类/函数                               | 描述                             |
| ---------------------------------- | ------------------------------ |
| torch.nn.Module                    | 所有神经网络模块的基类。自定义神经网络时通常需要继承这个类。 |
| torch.nn.Sequential(*args)         | 按顺序组合多个模块。                     |
| torch.nn.ModuleList(modules)       | 将子模块存储在列表中。                    |
| torch.nn.ModuleDict(modules)       | 将子模块存储在字典中。                    |
| torch.nn.ParameterList(parameters) | 将参数存储在列表中。                     |
| torch.nn.ParameterDict(parameters) | 将参数存储在字典中。                     |

nn.Sequential()里面的模块（通常是各种nn预定义层）按照顺序进行排列的，所以必须确保前一个模块的输出大小和下一个模块的输入大小是一致的。

nn.ModuleList()，它是一个储存不同模块（通常是各种nn预定义层），并自动将每个模块的parameters添加到网络之中的列表容器（所有模块用[]包裹）。用户可以把任意nn.Module的子类 (比如 nn.Conv2d、nn.Linear之类的) 加到这个列表里面。但不同于一般的列表，加入到nn.ModuleList里面的模块是会自动注册到整个网络上的，同时模块的parameters也会自动添加到整个网络中。

nn.Sequential()与nn.ModuleList()都很常用，两者之间有两点不同：

1. nn.Sequential()里面的模块是按照顺序进行排列的，所以必须确保前一个模块的输出大小和下一个模块的输入大小是一致的。而nn.ModuleList()并没有定义一个网络，它只是将不同的模块储存在一起，这些模块之间并没有什么先后顺序可言。nn.ModuleList()里面的顺序不能决定什么，网络的执行顺序是根据forward函数来决定的。

2. nn.Sequential()内部实现了forward函数，因此可以不用写forward函数。而nn.ModuleList()则没有实现内部forward函数，用户需要自己实现forward函数，forward函数内部决定模块的先后执行顺序。

nn.Sequential()的示例用法：

```python
import torch.nn as nn
# 创建顺序模型，包含线性层、ReLU激活函数和Sigmoid激活函数
model = nn.Sequential(
   nn.Linear(n_in, n_h),  # 输入层到隐藏层的线性变换
   nn.ReLU(),             # 隐藏层的ReLU激活函数
   nn.Linear(n_h, n_out), # 隐藏层到输出层的线性变换
   nn.Sigmoid()           # 输出层的Sigmoid激活函数
)
```

## 三.线性层<a name="线性层"></a>

| 类/函数                                                        | 描述    |
| ----------------------------------------------------------- | ----- |
| torch.nn.Linear(in_features, out_features)                  | 全连接层。 |
| torch.nn.Bilinear(in1_features, in2_features, out_features) | 双线性层。 |

线性层负责对数据执行快速的仿射变换，参数in_features是输入特征数量，即输入的神经元个数，对于输入张量，in_features的值应与输入张量的最后一维相等，如果输入张量是整型，需要先转换为浮点型float。out_features是输出特征数量，即输出的神经元个数。

torch.nn.Linear()的示例用法：

```python
import torch.nn as nn
# 定义线性回归模型
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        # 定义一个线性层，输入为1个特征，输出为1个预测值
        self.linear = nn.Linear(1, 1)  # 输入维度1，输出维度1
    def forward(self, x):
        return self.linear(x)  # 前向传播，返回预测结果
# 创建模型实例
model = LinearRegressionModel()
```

## 四.卷积层<a name="卷积层"></a>

| 类/函数                                                             | 描述       |
| ---------------------------------------------------------------- | -------- |
| torch.nn.Conv1d(in_channels, out_channels, kernel_size)          | 一维卷积层。   |
| torch.nn.Conv2d(in_channels, out_channels, kernel_size)          | 二维卷积层。   |
| torch.nn.Conv3d(in_channels, out_channels, kernel_size)          | 三维卷积层。   |
| torch.nn.ConvTranspose1d(in_channels, out_channels, kernel_size) | 一维转置卷积层。 |
| torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size) | 二维转置卷积层。 |
| torch.nn.ConvTranspose3d(in_channels, out_channels, kernel_size) | 三维转置卷积层。 |

使用卷积函数时，至少需要3个参数，其余参数都是可选的，卷积函数的完整参数列表：

| 参数           | 参数数据类型        | 参数描述                                                                |
| ------------ | ------------- | ------------------------------------------------------------------- |
| in_channels  | int           | 输入通道数。                                                              |
| out_channels | int           | 卷积产生的通道数。                                                           |
| kernel_size  | int或者tuple    | 卷积核尺寸，可以设为1个int型数或者一个(int, int)型的元组，例如3是高3款3的卷积核，(2,3)是高2宽3卷积核。     |
| stride       | int或者tuple，可选 | 卷积步长，默认为1。可以设为1个int型数或者一个(int, int)型的元组。                            |
| padding      | int或者tuple，可选 | 填充操作，控制padding_mode的数目，默认为0。                                        |
| padding_mode | string，可选     | 填充模式，可选‘zeros’, ‘reflect’, ‘replicate’或者 ‘circular’，默认为'zeros'即零填充。 |
| dilation     | int或者tuple，可选 | 扩张卷积（也叫空洞卷积）：控制kernel点（卷积核点）的间距，默认值：1。                              |
| groups       | int，可选        | groups参数的作用是控制分组卷积，默认不分组，为1组。                                       |
| bias         | bool，可选       | 如果为真，则在输出中添加一个可学习的偏差。默认：True。                                       |

一般来说，一维卷积用于文本数据，只对宽度进行卷积，对高度不卷积。在文本应用中，一维卷积参数in_channels为词向量的维度，参数out_channels为卷积产生的通道数，即卷积核的数量。

二维卷积用于图像数据，对宽度和高度都进行卷积。二维卷积层要求的输入张量形状为NCHW，N为批次大小，C为图像通道数（灰度图像1，RGB图像3），H为图像高度，W为图像高度。对于图像数据集，如果张量形状不符合NCHW排布要求，需要手动调整，张量调整形状可以使用PyTorch提供的x.permute()函数。

```python
c = torch.tensor([[1, 2, 3], [4, 5, 6]])
d = c.permute(1, 0)
print(c.shape)  # 打印torch.Size([2, 3])
print(d.shape)  # 打印torch.Size([3, 2])
e = d.permute(1, 0)
print(e)
```

在图像应用中，二维卷积参数in_channels为输入图像通道数，参数out_channels为卷积产生的通道数，即卷积核的数量。图像经过二维卷积之后，图像的宽度和高度可能发生变化，当卷积步长stride为1时，图像的输出（Hin是输入高度，Hout是输出高度，Win是输入宽度，Wout是输出宽度）：

Hout = Hin + 2×padding[0] - dilation[0]×(kernel_size[0]-1)

Wout = Win + 2×padding[1] - dilation[1]×(kernel_size[1]-1)

大部分情况下对宽高使用相同的参数，所以：

Sout = Sin + 2×padding - dilation×(kernel_size-1)

式中Sin是输入尺寸，Sout是输出尺寸。在使用二维卷积时，通过合理设置参数，比如kernel_size=3， padding=1，可以使得图像输出尺寸与输入尺寸不变。如果设置kernel_size=3， padding=1，stride=2，可以使得图像输出尺寸正好为输入尺寸的1/2（包括高度与宽度）。

## 五.池化层<a name="池化层"></a>

| 类/函数                                    | 描述          |
| --------------------------------------- | ----------- |
| torch.nn.MaxPool1d(kernel_size)         | 一维最大池化层。    |
| torch.nn.MaxPool2d(kernel_size)         | 二维最大池化层。    |
| torch.nn.MaxPool3d(kernel_size)         | 三维最大池化层。    |
| torch.nn.AvgPool1d(kernel_size)         | 一维平均池化层。    |
| torch.nn.AvgPool2d(kernel_size)         | 二维平均池化层。    |
| torch.nn.AvgPool3d(kernel_size)         | 三维平均池化层。    |
| torch.nn.AdaptiveMaxPool1d(output_size) | 一维自适应最大池化层。 |
| torch.nn.AdaptiveMaxPool2d(output_size) | 二维自适应最大池化层。 |
| torch.nn.AdaptiveMaxPool3d(output_size) | 三维自适应最大池化层。 |
| torch.nn.AdaptiveAvgPool1d(output_size) | 一维自适应平均池化层。 |
| torch.nn.AdaptiveAvgPool2d(output_size) | 二维自适应平均池化层。 |
| torch.nn.AdaptiveAvgPool3d(output_size) | 三维自适应平均池化层。 |

使用池化函数时，至少需要1个参数（kernel_size），其余参数都是可选的，池化函数的完整参数列表：

| 参数             | 参数数据类型        | 参数描述                                                      |
| -------------- | ------------- | --------------------------------------------------------- |
| kernel_size    | int或者tuple    | 池化的窗口大小。                                                  |
| stride         | int或者tuple，可选 | 窗口滑动步长，默认为与kernel_size相同大小。可以设为1个int型数或者一个(int, int)型的元组。 |
| padding        | int或者tuple，可选 | 填充操作，默认为0。                                                |
| dilation       | int或者tuple，可选 | 扩张池化（也叫空洞池化）：控制kernel点（池化窗口点）的间距，默认值：1。                   |
| return_indices | bool，可选       | 返回最大值的位置索引，默认False。                                       |
| ceil_mode      | bool，可选       | 如果为True，则计算输出尺寸时向上取整，默认False，即计算输出尺寸时向下取整。                |

在处理图像数据时，通常使用二维池化，最大池化的方法是取池化窗口覆盖元素中的最大值，平均池化的方法是取池化窗口覆盖元素中的平均值。图像经过二维池化之后，图像的宽度和高度通常会发生变化，图像的输出（Hin是输入高度，Hout是输出高度，Win是输入宽度，Wout是输出宽度）：

Hout = ⌊(Hin + 2× padding[0] − dilation[0]×(kernel_size[0] − 1) − 1)/( stride[0]) + 1⌋

Wout = ⌊(Win + 2× padding[1] − dilation[1]×(kernel_size[1] − 1) − 1)/( stride[1]) + 1⌋

大部分情况下对宽高使用相同的参数，所以：

Sout = ⌊(Sin + 2×padding − dilation×(kernel_size − 1) − 1)/stride + 1⌋

式中Sin是输入尺寸，Sout是输出尺寸，符号⌊⌋是向下取整符号，如果ceil_mode设置为True则此处应使用向上取整符号。在使用池化时，通过合理设置参数，比如kernel_size=2，可以使得图像输出尺寸正好为输入尺寸的1/2（包括高度与宽度）。

## 六.激活函数<a name="激活函数"></a>

| 类/函数                               | 描述              |
| ---------------------------------- | --------------- |
| torch.nn.ReLU()                    | ReLU激活函数。       |
| torch.nn.Sigmoid()                 | Sigmoid激活函数。    |
| torch.nn.Tanh()                    | Tanh激活函数。       |
| torch.nn.Softmax(dim)              | Softmax激活函数。    |
| torch.nn.LogSoftmax(dim)           | LogSoftmax激活函数。 |
| torch.nn.LeakyReLU(negative_slope) | LeakyReLU激活函数。  |
| torch.nn.ELU(alpha)                | ELU激活函数。        |
| torch.nn.SELU()                    | SELU激活函数。       |
| torch.nn.GELU()                    | GELU激活函数。       |

ReLU激活函数是目前最常用的激活函数，ReLU(x) = max(0, x)。

Sigmoid函数，又称logistic函数，是最早使用的激活函数之一。但是由于其固有存在的一些缺点，如今很少将其作为激活函数，但是依然常用于二分类问题中的概率划分。

Tanh激活函数与Sigmoid激活函数类似，但Tanh的输出范围为 [-1, 1]，常用于对称性更强的场景。

Softmax激活函数可以将一个数值向量归一化为一个概率分布向量，且各个概率之和为1。

```python
def softmax(x):
    return np.exp(x) / np.sum(np.exp(x), axis=0)
```

Softmax可以用来作为神经网络的最后一层，用于多分类问题的输出。Softmax层常常和交叉熵损失函数一起结合使用。

实际上，Sigmod函数是Softmax函数的一个特例，Sigmod函数只能用于预测值为0或1的二元分类。

## 七.损失函数<a name="损失函数"></a>

| 类/函数                          | 描述                   |
| ----------------------------- | -------------------- |
| torch.nn.MSELoss()            | 均方误差损失，也称为L2范数损失。    |
| torch.nn.L1Loss()             | L1范数损失，即绝对值误差损失。     |
| torch.nn.CrossEntropyLoss()   | 交叉熵损失。               |
| torch.nn.NLLLoss()            | 负对数似然损失。             |
| torch.nn.BCELoss()            | 二分类交叉熵损失。            |
| torch.nn.BCEWithLogitsLoss()  | 带 Sigmoid 的二分类交叉熵损失。 |
| torch.nn.KLDivLoss()          | KL 散度损失。             |
| torch.nn.HingeEmbeddingLoss() | 铰链嵌入损失。              |
| torch.nn.MultiMarginLoss()    | 多分类间隔损失。             |
| torch.nn.SmoothL1Loss()       | 平滑 L1 损失。            |

MSELoss()均方误差损失主要用于回归问题，即预测一个连续数值（例如房价、温度、股票价格等）。MSELoss()要求预测张量与目标张量数据类型一致，张量形状一致，否则会报错。

L1Loss()绝对值范数损失的使用场合、使用方式均与均方误差损失类似。

L1范数损失与L2范数损失都有一个可选参数reduction（默认值为'mean'），参数设置为'mean'时输出的和除以输出的元素总数，此时返回的是1个0维张量；参数设置为'sum'时输出的元素求和，此时返回的是1个0维张量；参数设置为'none'时不对输出进行归约，此时返回的张量形状与输入张量形状一致。

CrossEntropyLoss()交叉熵损失一般用于多分类问题，有一个可选参数reduction（默认值为'mean'）。大部分情况下，多分类问题的预测张量与目标张量的张量形状不同，因此CrossEntropyLoss()并不要求预测张量与目标张量的张量形状一致，目标张量输入既可以是类别index的单列2维张量，也可以是one-hot形式的多列2维张量。交叉熵损失函数会自动对输入模型的预测值进行softmax。因此在多分类问题中，如果使用nn.CrossEntropyLoss()，则预测模型的输出层无需添加softmax层。nn.CrossEntropyLoss() = nn.LogSoftmax() + nn.NLLLoss()。

torch.nn.NLLLOSS()通常不被独立当作损失函数，而需要和softmax、log等运算组合当作损失函数。即上述等式：nn.CrossEntropyLoss() = nn.LogSoftmax() + nn.NLLLoss()。

## 八.归一化层<a name="归一化层"></a>

| 类/函数                                         | 描述        |
| -------------------------------------------- | --------- |
| torch.nn.BatchNorm1d(num_features)           | 一维批归一化层。  |
| torch.nn.BatchNorm2d(num_features)           | 二维批归一化层。  |
| torch.nn.BatchNorm3d(num_features)           | 三维批归一化层。  |
| torch.nn.LayerNorm(normalized_shape)         | 层归一化。     |
| torch.nn.InstanceNorm1d(num_features)        | 一维实例归一化层。 |
| torch.nn.InstanceNorm2d(num_features)        | 二维实例归一化层。 |
| torch.nn.InstanceNorm3d(num_features)        | 三维实例归一化层。 |
| torch.nn.GroupNorm(num_groups, num_channels) | 组归一化。     |

BatchNorm1d()是PyTorch中的一个用于一维数据（例如序列或时间序列）的批标准化（Batch Normalization）层。 批标准化是一种常用的神经网络正则化技术，旨在加速训练过程并提高模型的收敛性和稳定性。它通过对每个输入小批次的特征进行归一化处理来规范化输入数据的分布。在一维数据上使用nn.BatchNorm1d()层时，它会对每个特征维度上的数据进行标准化处理。具体而言，它会计算每个特征维度的均值和方差，并将输入数据进行中心化和缩放，以使其分布接近均值为0、方差为1的标准正态分布。使用nn.BatchNorm1d()层可以有效地解决神经网络训练过程中出现的内部协变量偏移问题，加速训练收敛，并提高模型的泛化能力。参数num_features (int) – 表述为number of features or channels C of the input（输入的数据的通道数或者是特征数）。对2维张量(N, C)，参数使用C特征数（另一维N是批次大小）。对3维张量(N, C, L)，参数使用C特征数（另一维L是序列长度）。BatchNorm1d()的示例用法：

```python
import torch
import torch.nn as nn
x = torch.tensor([[0, 1, 2],
                  [3, 4, 5]],
                   dtype=torch.float)
m = nn.BatchNorm1d(3)   #  num_features的值必须为形状的最后一数3
y = m(x)
print(y)
```

BatchNorm2d()是专为4D输入（即二维卷积层的输出）设计的批归一化操作。其计算流程如下：

1. **输入维度：** 假设输入的维度为 (N, C, H, W)，其中：N是batch size批次大小；C是通道数即特征数；H、W是特征图的高度和宽度。
2. **统计均值和方差：** 对每个通道C分别计算均值和方差，统计维度为 [0, 2, 3]（即对batch size和空间维度进行平均）。
3. **标准化和仿射变换：** 按标准化公式计算输出。

参数num_features (int) – 表述为number of features or channels C of the input（输入的数据的通道数或者是特征数）。

BatchNorm2d()的示例用法：

```python
# 设置随机种子，保证结果可复现
torch.manual_seed(1107)
# 创建一个4D张量，形状为 (2, 3, 4, 4)
x = torch.rand(2, 3, 4, 4)
# 实例化BatchNorm2d，通道数为3，momentum设置为1
m = nn.BatchNorm2d(3, momentum=1)
y = m(x)
print(y)
```

## 九.循环神经网络层<a name="循环神经网络层"></a>

| 类/函数                                       | 描述       |
| ------------------------------------------ | -------- |
| torch.nn.RNN(input_size, hidden_size)      | 简单RNN层。  |
| torch.nn.LSTM(input_size, hidden_size)     | LSTM层。   |
| torch.nn.GRU(input_size, hidden_size)      | GRU层。    |
| torch.nn.RNNCell(input_size, hidden_size)  | 简单RNN单元。 |
| torch.nn.LSTMCell(input_size, hidden_size) | LSTM单元。  |
| torch.nn.GRUCell(input_size, hidden_size)  | GRU单元。   |

循环神经网络（Recurrent Neural Networks, RNN）是一类专门用于处理序列数据的神经网络。它们具有记忆性，可以捕捉序列数据中的时间依赖关系。在PyTorch中，torch.nn.RNN类是实现RNN的核心模块之一。

使用循环神经网络层时，至少需要2个参数，其余参数都是可选的，循环神经网络层的完整参数列表：

| 参数            | 参数数据类型    | 参数描述                                                                                                                                            |
| ------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| input_size    | int       | 输入特征的数量。例如，如果输入数据是形状为(batch_size, sequence_length, input_size)的张量，那么input_size就是输入特征数。                                                          |
| hidden_size   | int       | 隐藏层的特征数量。隐藏层是RNN中用于存储和传递信息的部分。                                                                                                                  |
| num_layers    | int，可选    | RNN的层数。多层RNN可以增加模型的深度，提高模型的表达能力，默认值为1。                                                                                                          |
| nonlinearity  | string，可选 | 激活函数类型。可以是’relu’、’tanh’或’sigmoid’等。默认为’tanh’。                                                                                                   |
| bias          | bool，可选   | 是否添加偏置项。默认为True。                                                                                                                                |
| batch_first   | bool，可选   | 输入和输出的张量形状中是否将batch_size放在第一位。默认为False，即形状为(sequence_length, batch_size, feature_size)。如果为True，则形状为(batch_size, sequence_length, feature_size)。 |
| dropout       | float，可选  | 每一层之后应用dropout的概率，默认为0.0。dropout是一种正则化技术，可以防止模型过拟合。                                                                                             |
| bidirectional | bool，可选   | 是否使用双向RNN，默认为False。如果为True，则输出将是双向RNN的结果，隐藏层的大小将是hidden_size的两倍。                                                                                |

定义简单的循环神经网络只需要1层nn.RNN加1层全连接层即可。

## 十.嵌入层<a name="嵌入层"></a>

| 类/函数                                              | 描述   |
| ------------------------------------------------- | ---- |
| torch.nn.Embedding(num_embeddings, embedding_dim) | 嵌入层。 |

nn.Embedding是一个非常重要的模块，用于将离散型的数据（通常是整数）映射为连续型的向量表示。这在自然语言处理、推荐系统等领域中非常常见。

nn.Embedding的基本思想是将每个整数索引映射到一个固定大小的向量。这些向量在训练过程中是可学习的，因此可以捕获数据的潜在结构和语义信息。在内部实现上，nn.Embedding使用一个二维张量（tensor）来存储这些向量。张量的第一维是索引（整数）的数量，第二维是每个向量的维度。当给定一个整数索引时，nn.Embedding会通过索引来查找对应的向量并返回。

使用Embedding时，至少需要2个参数，其余参数都是可选的，Embedding的完整参数列表：

| 参数                 | 参数数据类型   | 参数描述                                                                                                    |
| ------------------ | -------- | ------------------------------------------------------------------------------------------------------- |
| num_embeddings     | int      | 嵌入词典的大小尺寸，比如该词典共有5000词，则num_embeddings=5000，此时index的取值范围为0-4999。                                        |
| embedding_dim      | int      | 每个词嵌入向量的维度，即用多少维度表示一个符号/词。                                                                              |
| padding_idx        | int，可选   | 填充id，比如，输入的句子的长度为100，但是每次的句子长度并不一定是相同的，后面就需要统一用数字填充，这里就是相当于指定填充的数字。这样，网络在遇到填充id时，就不会计算其与其他符号的相关性。默认值为0。 |
| max_norm           | float，可选 | 最大范数，通常不用。                                                                                              |
| norm_type          | float，可选 | 范数类型，通常不用。                                                                                              |
| scale_grad_by_freq | bool，可选  | 是否根据单词在mini-batch中出现的频率，对梯度进行放缩。默认为False。                                                               |
| sparse             | bool，可选  | 是否稀疏，通常不用。                                                                                              |

使用Embedding返回形状为输入+1维度的张量：比如当输入2维时，返回形状维行×列×embedding_dim的张量。

通常使用Embedding时只需要指定num_embeddings与embedding_dim即可，num_embeddings设置为数据集中最大的整数索引加1，embedding_dim是1个超参数，可以根据具体任务和数据集来选择。较小的嵌入维度可能会导致信息丢失，而较大的嵌入维度可能会增加计算量和过拟合的风险。通常，可以通过实验来找到一个合适的嵌入维度。

## 十一.Dropout层<a name="Dropout层"></a>

| 类/函数                  | 描述           |
| --------------------- | ------------ |
| torch.nn.Dropout(p)   | Dropout层。    |
| torch.nn.Dropout2d(p) | 2D Dropout层。 |
| torch.nn.Dropout3d(p) | 3D Dropout层。 |

Dropout是一种常用的正则化方法，通过随机将部分神经元的输出置为0来减少过拟合。

Dropout在训练时随机将某些张量的值设为0，从而减少模型对训练数据的依赖程度，提高泛化能力；同时在测试时需要关闭Dropout，具体来说，如果处于model.eval模式时，并不会使用Dropout。

可选参数p用于设置输出置0的概率，默认值为0.5。另一个可选参数inplace可以节省内存（或显存），默认值为False。

在实际使用时，Dropout层通常位于隐藏层之间的节点上，具体来说，就是在全连接层之间放置Dropout来避免过拟合。

## 十二.实用函数<a name="实用函数"></a>

| 函数                                               | 描述               |
| ------------------------------------------------ | ---------------- |
| torch.nn.functional.relu(input)                  | 应用 ReLU 激活函数。    |
| torch.nn.functional.sigmoid(input)               | 应用 Sigmoid 激活函数。 |
| torch.nn.functional.softmax(input, dim)          | 应用 Softmax 激活函数。 |
| torch.nn.functional.cross_entropy(input, target) | 计算交叉熵损失。         |
| torch.nn.functional.mse_loss(input, target)      | 计算均方误差损失。        |

上述函数可用于神经网络的forward()函数中，由于torch.nn提供了模块化API覆盖了上述函数提供的功能，因此上述函数化API仅在确有必要的时候（比如推理时减少内存占用）使用。