paddle05-paddle.nn(paddle.nn* & paddle.nn.functional*) 【暂不更新】

🌟🌟🌟 paddle.nn paddle支持的神经网络层和相关函数的API

paddle.nn.* 与 paddle.nn.functional.* 之间的关系:
- PyTorch 中，nn 与 nn.functional 有什么区别？
- nn.XXX 和 nn.functional.xxx 的实际功能相同，运行效率也近乎相同。
- nn.functional.** 是函数接口, 而 nn.xxx 是 nn.funct.** 函数的封装，并且nn.xxx 都继承于一个共同祖先 nn.Module. 这导致: nn.XXX 除了具有 nn.functional.xxx 功能之外附带了 nn.Module 相关的属性和方法，例如: trian() eval() 等
- 两者差别之处:
  - 两者调用方式不同:
  - nn.XXX 继承于 nn.Module, 能够很好的与 nn.Sequentail 结合使用,而 nn,functional.xxx 无法与 nn.Sequential 结合使用
  - nn.XXX 不需要自己定义和管理 weight; 而 nn.functional.xxx 需要自己定义 weight, 每次调用时候都需要手动传入 weight,不利于代码复用。
```
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.cnn1 = nn.Conv2D(1,16,5)
        self.relu1 = nn.ReLU()

    def forward(self, x):
        x = self.relu(self.cnn1(x))
class CNN(nn.Module):
    def __init__(self):
        super()
        self.cnn1_weight = nn.Parameter()
        self.cnn1_bias = nn.Parameter()
    def forward(self, x):
        x = F.conv2d(x. self.cnn1_weight, self.cnn_bias)
```
  上述两种定义方式功能相同，喜欢哪种个人选择。但是官方推荐: 具有学习参数的采用 nn.XXX 方式, 没有学习参数的根据个人选择使用。
  但是关于 dropout，建议使用nn.XXX 方式,因为一般情况下只有训练阶段才会 dropout,在 eval 阶段不会使用，model所有的dropout都会关闭,但是nn.functional.dropout定义的dropout在调用model.eval() 之后并不能都关闭。
  建议在能使用 nn.xxx 情况下尽量使用，不行再换 nn.functional.xxx，这样更能显示出网络的层次关系，也更加的纯粹(所有layer和model本身都是Module,统一和谐)
共享参数场景下: paddle.nn 和 paddle.nn.func实现
- paddle.nn.* 直接多次调用预订的layer就行。 pytorch中模型参数的访问、初始化和共享
- paddle.nn.func: 自定义的参数多次插入到函数中
共享编码器: 各自计算梯度, 然后梯度累加更新。
层之间共享: 各自计算梯度, 然后多层梯度累加更新。
Back Propagation（梯度反向传播）实例讲解

概述:

|功能|	API名称|  
|:---:|:---:|   
|Conv |Conv1D、Conv2D、Conv3D|
|Pool|			AvgPool1D、MaxPool1D、AdaptiveAvgPool1D
|Padding |		Pad1D、Pad2D
|Activation |		Sigmod、Softmax、Tanh、LogSoftmax、ReLU...
|Normlization | BatchNorm、GroupNorm、InstanceNorm、LayerNorm、SpectraNorm、SyncNorm
|Recurrent NN | BiRNN、GRU、LSTM、RNN   GRUCell、LSTMCell、RNNCell、SimpleRNN
|Transformer | Transformer、TransformerEncoder、TransformerEncoderLayer、TransformerDecoder、TransforDecoderLayer
|Dropout | AlphaDropout、Dropout、Dropout2d...
|Loss | BCELoss(二分类)、BCEWithLogitsLoss、CrossEntropyLoss、CTCLoss、KLDivLoss、L1Loss、MarginRankingLoss、MSELoss、NLLLoss、SmoothL1Loss

* 一、容器相关
  * 1) class paddle.nn.Layer()
  * 2) class paddle.nn.LayerList(sublauers=None) 用于保存子层列表
  * 3) paddle.nn.ParameterList(parameters= None) 参数列表容器
  * 4) paddle.nn.Sequential(*layers) 顺序容器: 子Layer将按照构造函数参数的顺序添加到此容器中      ⭐

* 二、卷积层
  * paddle.nn.Conv1D() 一维卷积层
  * paddle.nn.Conv1DTranspose() 一维转置卷积层
  * paddle.nn.Conv2D(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, padding_mode="zero", weight_attr=None, bias_attr=None, data_format="NCHW") 二维卷积层    ⭐
  * paddle.nn.Conv2DTranspose() 二维转置卷积层
  * paddle.nn.Conv3D() 二维卷积层
  * paddle.nn.Conv3DTranspose() 三维转置卷积层

* 三、pooling层
  * paddle.nn.AdaptiveAvgPool1D 一维自适应平均池化层
  * paddle.nn.AdaptiveAvgPool2D 二维自适应平均池化层
  * paddle.nn.AdaptiveAvgPool3D 三维自适应平均池化层
  * paddle.nn.AdaptiveMaxPool1D 一维自适应最大池化层
  * paddle.nn.AdaptiveMaxPool2D 二维自适应最大池化层
  * paddle.nn.AdaptiveMaxPool3D 三维自适应最大池化层
  * paddle.nn.AvgPool1D(kernel_size, stride=None, padding=0, exclusice=True, ceil_mode=False) 一维平均池化层      ⭐
  * paddle.nn.AvgPool2D 二维平均池化层
  * paddle.nn.AvgPool2D 二维平均池化层
  * paddle.nn.AvgPool3D 三维平均池化层
  * paddle.nn.MaxPool1D 一维最大池化层
  * paddle.nn.MaxPool2D 二维最大池化层
  * paddle.nn.MaxPool3D 三维最大池化层

* 四、padding层
  * paddle.nn.Pad1D() 一维填充层      ⭐
  * paddle.nn.Pad2D() 二维填充层
  * paddle.nn.Pad3D() 三维填充层

* 五、激活层
  * class paddle.nn.ReLU() ReLU激活层            ⭐
  * paddle.nn.Softmax(axis = -1) Softmax激活层    ⭐
  * paddle.nn.Sigmoid() Sigmoid激活层          ⭐

* 六、Normalization层
  * paddle.nn.LayerNorm(normalized_shape, epsilon=1e-05, weight_attr=None, bias_attr=None,) 用于保存Normalization层列表    ⭐
  * paddle.nn.BatchNorm(num_channels, ...) Batch Normalization层      ⭐

* 七、循环神经网络层
  * class paddle.nn.RNN(cell, is_reverse=False, time_major=False) 循环神经网络      ⭐
  * paddle.nn.LSTMCell(input_size, hidden_size, weight_ih_attr=None, weight_hh_attr= None, bias_ih_attr=None, bias_hh_attr= None) LSTM网络单元基类      ⭐
  * class paddle.nn.LSTM(input_size, hidden_size, num_layers=1, direction="forward", dropout=0.,time_major=False, weight_ih_attr=None, weight_hh_attr=None, bias_ih_attr=None, bias_hh_attr=None) LSTM      ⭐

* 八、Transformer 相关
  * class paddle.nn.MultiHeadAttention(embed_dim, num_heads, dropout=0.0, kdim=None, vdim=None, need_weights=False, weight_attr=None, bias_attr= None) 多头注意力机制 ,attention_mask？ 输入输出形状? 学习到的参数? 4*dim *dim q,k,v,out    ⭐
  * paddle.nn.Transformer(d_model=512, nhead=8, num_encoder_layers=6, num_decoder_layers=6, dim_feedforward=2048....) Transformer模型:编码器+解码器      ⭐
  * paddle.nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout=0.1, activation="relu", attn_dropout=None, act_dropout=None, normalize_before=False, weight_attr=None, bias_attr= None) Transformer编码器层    ⭐

* 九、线性层
  * paddle.nn.Linear(in_features, out_features, weight_attr=None, bias_attr= None) 线性变换层        ⭐
  * paddle.nn.Bilinnear(in_1_features, in_2_features, out_features, weight_attr= None, bias_attr = None) 对两个输入执行双线性张量积      ⭐

* 十、Dropout层
  * paddle.nn.Dropout(p= 0.5, axis= None, mode="upscale_in_train") Dropout      ⭐
  * paddle.nn.Dropout2D() 二维Dropout
  * paddle.nn.Dropout3D() 三维Dropout

* 十一、Embedding层
class paddle.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, sparse= False, weight_attr= None) 嵌入层(Embedding Layer)    ⭐

* 十二、Loss层
  * class paddle.nn.BCELoss(weight=None, reduction="mean") BCELoss层    ⭐
  * paddle.nn.BCEWithLogitsLoss(weight=None, reduction="mean", pos_weight=None) BCEWithLogitsLoss层    ⭐
  * paddle.nn.CrossEntropyLoss(weight=None, ignore_index=-100, reduction="mean", soft_label=False, axis=-1) 交叉熵Loss    ⭐
  * paddle.nn.NLLLoss(weight=None, ignore_index=-100, reduction="mean") NLLLoss层    ⭐
  * paddle.nn.L1Loss(reduction="mean") L1 loss      ⭐
  * paddle.nn.SmoothL1Loss() 平滑L1损失层        ⭐
  * paddle.nn.MSELoss() 均方误差损失层              ⭐
  * KLDivLoss(reduction="mean") Kullback-Leibler 散度损失层        ⭐
  * paddle.nn.MarginRankingLoss(margin=0.0, reduction="mean") MarginRankingLoss层      ⭐

* 二十六、初始化相关

一、容器相关

不懂 class paddle.nn.Layer(name_scope=None, dtype="float32") 基于OOD实现的动态图Layer
```
基于OOD实现的动态图Layer, 包含该 Layer 的参数、前序运行的结构等信息。   
参数: 
    1.name_scope: str,可选, 为 Layer内部参数命名而采用的名称前缀。   
```
- 方法: train()
```
将此层 及其 所有子层设置为 训练模式。这只会影响某些模块, 如: Dropout, BatchNorm
返回: 无  
```
- 方法:eval()
```
设置为 预测模式
```
- 方法:full_name() Layer的全名
- 方法:register_forward_pre_hook()
- 方法:register_forward_post_hook()
- 方法:create_parameter() 为Layer 创建参数【🐯】
- 方法: creat_variable() 为Layer 创建变量【🐯】
- 方法: create_tensor()
- 方法: chidren()
- 方法: sublayers()
- 方法: clear_giadients() 【🐯】
- 方法: named_parameters() 【🐯】
- 方法: named_sublayers()
- 方法: register_buffer()
- 方法: buffers()
- 方法: named_buffers()
- 方法: forward() 【🐯】
- 方法: add_sublayer()
- 方法: add_parameter()
- state_dict() 【🐯】
- set_state_dict() 【🐯】
- parameters() 仅仅是参数【🐯】

paddle.nn.LayerList(sublauers=None) 用于保存子层列表

LayerList 用于保存 子层列表，它包含的子层将被正确的注册和添加，可以用列表索引。  
参数: sublayers: iterable, 可选， 要保存的子层  
返回: 无  

class MyLayer(paddle.nn.Layer):
    def __init__(self):
        super(MyLayer, self).__init__()
        self.linears = paddle.nn.LayerList(
            [paddle.nn.Linear(10, 10) for i in range(10)])

    def forward(self, x):
        # LayerList 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

方法: append() 添加一个子层到整个list的最后

参数: sunlayer(Layer), 要添加的子层  

linears = paddle.nn.LayerList([paddle.nn.Linear(10, 10) for i in range(10)])
another = paddle.nn.Linear(10, 10)
linears.append(another)
print(len(linears))  # 11

方法: insert(index, sublayers) 向List中插入一个子层，到给定的index前面

linears = paddle.nn.LayerList([paddle.nn.Linear(10, 10) for i in range(10)])
another = paddle.nn.Linear(10, 10)
linears.insert(3, another)
print(linears[3] is another)  # True

方法: extend(sunlayers(iterable of Layer)) 添加多个子层到整个list的最后

linears = paddle.nn.LayerList([paddle.nn.Linear(10, 10) for i in range(10)])
another_list = paddle.nn.LayerList([paddle.nn.Linear(10, 10) for i in range(5)])
linears.extend(another_list)
print(len(linears))  # 15
print(another_list[0] is linears[10])  # True

paddle.nn.ParameterList(parameters= None) 参数列表容器

paddle.nn.Sequential(*layers) 顺序容器: 子Layer将按照构造函数参数的顺序添加到此容器中。

顺序容器: 子Layer将按照构造函数参数的顺序添加到此容器中，传递给构造函数的参数可以是: layers 或 可迭代的 name Lyaer 元组  

参数: layers: tuple, Layers 或 可迭代的 name layer对 
返回: 无  

model1 = paddle.nn.Sequential(
        paddle.nn.Linear(10, 1),
        paddle.nn.Linear(1, 2))

model2 = paddle.nn.Sequential(
        ("l1", paddle.nn.Linear(10, 2)),
        ("l2", paddle.nn.Linear(2, 3)))
model2.add_sublayer("l3", paddle.nn.Linear(3, 3))

二、卷积层

paddle.nn.Conv1D() 一维卷积层
paddle.nn.Conv1DTranspose() 一维转置卷积层

paddle.nn.Conv2D(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, padding_mode="zero", weight_attr=None, bias_attr=None, data_format="NCHW") 二维卷积层

根据输入、卷积核、步长(stride)、填充(padding)、空洞大小(dilations)一组参数计算输出特整层大小。 输入和输出是 NCHW 或 NHWC 格式， N:batch_size, C:通道数, H:特征高度, W:特征宽度， 卷积核: MCHW格式， M:输出图像通道数, C:输入图像通道数、H,W

参数: 
    1.in_channels: int, 输入图像通道数  
    2.out_channels: int,由卷积操作差生的输入通道数(不同卷积核数量) 
    3.kernel_size: int/list/tuple, 卷积核大小。int:H=W 
    4.stride: int/list/tuple, 可选, 步长大小，int:H=W, 默认=1
    5.padding: int/list/tuple/str, 可选，填充大小
    6.dilation: int/list/tuple, 可选 
    7.groups: int
    8.padding_mode: str, 可选，指定权重参数属性的对象。  
    9.weight_attr:ParamAttr, 可选 
    10.bias_attr: ParamAttr/nool, 可选  
    11.data_format: 指定输入的数据格式, 输出的数据格式将与输入保持一致,NCHW 或 NHWC, N:batch_size, C:通道数, H:特征高度, W:特征宽度。  

属性: 
    1.weight:本层的可学习参数，类型为 Paramter  
    2.bias:本层的可学习偏置,类型为 Paramter

data = paddle.uniform([2, 4, 8, 8], dtype="float32", min=-1, max=1)
conv = paddle.nn.Conv2D(4, 6, (3, 3)) 
y = conv(data)
y.shape     # [2, 6, 6, 6]

paddle.nn.Conv2DTranspose() 二维转置卷积层
paddle.nn.Conv3D() 二维卷积层
paddle.nn.Conv3DTranspose() 三维转置卷积层

三、pooling层

paddle.nn.AdaptiveAvgPool1D 一维自适应平均池化层
paddle.nn.AdaptiveAvgPool2D 二维自适应平均池化层
paddle.nn.AdaptiveAvgPool3D 三维自适应平均池化层
paddle.nn.AdaptiveMaxPool1D 一维自适应最大池化层
paddle.nn.AdaptiveMaxPool2D 二维自适应最大池化层
paddle.nn.AdaptiveMaxPool3D 三维自适应最大池化层

paddle.nn.AvgPool1D(kernel_size, stride=None, padding=0, exclusice=True, ceil_mode=False) 一维平均池化层

输入、输出都是 3-D tensor, NCL格式: N:batch_size, C:通道数, L:输入特征的长度  

参数: 
    1.kernel_size: int/list/tuple
    2.stride: int/list/tuple
    3.padding: str/int/list/tuple
    4.exclusive: bool, 可选, 是否用额外padding的值计算平均池化结果，默认True
    5.ceil_mode: bool, 可选, 是否用 ceil函数计算输出的 H，w值， 默认False,采用:floor

data = paddle.uniform(shape=[1,2,32], dtype="float32", min=-1, max=1)
AvgPool1D = nn.AvgPool1D(2, 2, pading=0)
res = AvgPool1D(data)       # [1, 3, 16]

paddle.nn.AvgPool2D 二维平均池化层
paddle.nn.AvgPool2D 二维平均池化层
paddle.nn.AvgPool3D 三维平均池化层
paddle.nn.MaxPool1D 一维最大池化层
paddle.nn.MaxPool2D 二维最大池化层
paddle.nn.MaxPool3D 三维最大池化层

四、padding层

paddle.nn.Pad1D() 一维填充层
paddle.nn.Pad2D() 二维填充层
paddle.nn.Pad3D() 三维填充层

五、激活层: paddle.nn.ReLU()/paddle.nn.Softmax()/paddle.nn.Sigmod()

class paddle.nn.ReLU() ReLU激活层

返回ReLU 的可调用对象
ReLU(x) = max(0, x)
形状: 
    1.input: 任意形状 tensor
    2.output: 和input具有相同形状的 tensor
x = paddle.to_tensor([-2., 0., 1.])
m = paddle.nn.ReLU()
out = m(x) # [0., 0., 1.]

paddle.nn.LeakyReLU() LeakyReLU 层
paddle.nn.PReLU() PReLU激活层
paddle.nn.ReLU6() ReLU6激活层
paddle.nn.SELU() SELU激活层
paddle.nn.GELU() GELU激活层
paddle.nn.ELU() ELU激活层

paddle.nn.Softmax(axis = -1) Softmax激活层

计算过程: 
    1.输入x的axis维 会被置换到 最后一维。 
    2.将输入X逻辑上转换为二维矩阵
    3.恢复X形状
参数: 
    1.input: 任意形状的 tensor
    2.output: 和Input相同形状的 tensor

x = np.array([[[-2.0, 3.0, -4.0, 5.0],
                [3.0, -4.0, 5.0, -6.0],
                [-7.0, -8.0, 8.0, 9.0]],
                [[1.0, -2.0, -3.0, 4.0],
                [-5.0, 6.0, 7.0, -8.0],
                [6.0, 7.0, 8.0, 9.0]]], 'float32')
x = paddle.to_tensor(x)
m = paddle.nn.Softmax()
out = m(x)
# [[[0.0320586 , 0.08714432, 0.23688282, 0.64391426],
#   [0.0320586 , 0.08714432, 0.23688282, 0.64391426],
#   [0.07232949, 0.19661193, 0.19661193, 0.53444665]],
# [[0.0320586 , 0.08714432, 0.23688282, 0.64391426],
#   [0.0320586 , 0.08714432, 0.23688282, 0.64391426],
#   [0.0320586 , 0.08714432, 0.23688282, 0.64391426]]]

paddle.nn.LogSoftmax() LogSoftmax激活层
paddle.nn.Softplus() Softplus激活层
paddle.nn.Softshrink Softshrink激活层
paddle.nn.Softsign() Softsign激活层

paddle.nn.Sigmoid() Sigmoid激活层

创建一个 Sigmoid 的可调用对象。  
形状:
    x: N-D tensor, float16、float32、float64  

m = paddle.nn.Sigmoid()
data = paddle.to_tensor([1.0, 2.0, 3.0, 4.0])
res = m(data)       # [0.7310586, 0.880797, 0.95257413, 0.98201376]

paddle.nn.LogSigmoid() LogSigmoid激活层
paddle.nn.Hardsigmoid() Hardsigmoid激活层
paddle.nn.Tanh() Tanh激活层
paddle.nn.Hardtanh() Hardtanh激活层
paddle.nn.Tanhshrink() Tanhshrink激活层
paddle.nn.Swish Swish激活层
paddle.nn.Hardshrink Hardshrink激活层
paddle.nn.Hardswish Hardswish激活层
paddle.nn.Maxout Maxout激活层
paddle.nn.ThresholdedReLU Thresholded ReLU激活层

六、Normalization层

paddle.nn.LayerNorm(normalized_shape, epsilon=1e-05, weight_attr=None, bias_attr=None,) 用于保存Normalization层列表

参数: 
    1.normalized_shape:(int 或 list 或 tuple) – 需规范化的shape，期望的输入shape为 [*, normalized_shape[0], normalized_shape[1], ..., normalized_shape[-1]] 。如果是单个整数，则此模块将在最后一个维度上规范化（此时最后一维的维度需与该参数相同）
    2.epsilon (float, 可选) - 指明在计算过程中是否添加较小的值到方差中以防止除零。默认值：1e-05
    3. weight_attr (ParamAttr|bool, 可选) - 指定权重参数属性的对象。如果为False固定为1，不进行学习。默认值为None, 表示使用默认的权重参数属性
    4.bias_attr (ParamAttr, 可选) - 指定偏置参数属性的对象。如果为False固定为0，不进行学习。默认值为None，表示使用默认的偏置参数属性

形状:
    1.input: 2-D, 3-D ... 的tensor 
    2.output: 和输入形状一样 

np.random.seed(123)
x_data = np.random.random(size=(2, 2, 2, 3)).astype('float32')
x = paddle.to_tensor(x_data)
layer_norm = paddle.nn.LayerNorm(x_data.shape[1:])
layer_norm_out = layer_norm(x)

paddle.nn.BatchNorm(num_channels, ...) Batch Normalization层

参数: 
    1.num_channels (int) - 指明输入 Tensor 的通道数量  
    2.act (str, 可选) - 应用于输出上的激活函数，如tanh、softmax、sigmoid，relu等
    3.is_test (bool, 可选) - 指示是否在测试阶段，非训练阶段使用训练过程中统计到的全局均值和全局方差
    4.momentum (float, 可选) - 此值用于计算 moving_mean 和 moving_var 。默认值：0.9
    5.....

不懂在哪里几个维度计算 均值和方差?  
输入格式? 
x_data = np.random.random(size=(3, 10, 3, 7)).astype('float32')
x = paddle.to_tensor(x_data)
batch_norm = paddle.nn.BatchNorm(10)
batch_norm_out = batch_norm(x)

print(batch_norm_out.shape)
# [3, 10, 3, 7]

paddle.nn.BatchNorm1D() 一维Batch Normalization层
paddle.nn.BatchNorm2D() 二维Batch Normalization层
paddle.nn.BatchNorm3D() 三维Batch Normalization层
paddle.nn.GroupNorm() Group Normalization层
paddle.nn.InstanceNorm1D() 一维Instance Normalization层
paddle.nn.InstanceNorm2D() 二维Instance Normalization层
paddle.nn.InstanceNorm3D() 三维Instance Normalization层
paddle.nn.LocalResponseNorm() Local Response Normalization层
paddle.nn.SpectralNorm() Spectral Normalization层
paddle.nn.SyncBatchNorm() Synchronized Batch Normalization层

七、循环神经网络层

class paddle.nn.RNNCellBase(name_scope=None, dtype="float32") 循环神经网络单元基类
```
一个抽象表示根据输入和隐藏状态来计算输出和新状态的基本类。 
```
- 方法: get_initial_states(batch_red, shape=None, dtype=None, init_value=0, batch_dim_idx=0) 根据输入的形状,数据类型和值生成初始状态

class paddle.nn.RNN(cell, is_reverse=False, time_major=False) 循环神经网络

循环神经网络,将输入的cell封装成一个循环神经网络,它能够重复执行 cell.forward() 直到遍历完 input 中所有的 tensor.   
参数: 
    1.cell(RNNCellBase), RNNCellBase 类的一个实例。  
    2.is_reverse: bool, 可选, 指定遍历 input的方向，默认为False
    3.time_major: bool, 可选, 指定 input 的第一个维度是否是 time_steps, 默认为: False  
输入: 
    1.inputs: tensor, 输入, time_major=False, 形状:[batch_size, time_steps, input_size], time_major= True,形状:[time_steps, batch_size, input_size]    
    2. init_states: tensor/list/tuple, 可选,输入cell的初始状态，如果没有给出则调用 cell.get_initial_states 生成初始状态, 默认:None  
    3. sequence_length: tensor, 可选，指定输入序列的长度，形状为[batch],数据类型为int32/64.  
输出: 
    1.outputs: tensor/list/tuple, 输出, 如果 time_major 为False, 则tensor形状为:[batch_size, time_steps, hidden_size], 如果time_major为 True,则tensor的形状为: [time_steps, batch_size, hidden_size]  
    2. final_states: tensor/list/tuple, cell最终的状态  
注意: 该类是一个封装 rnn_cell 的低级api，在使用 forward() 函数时，必须确保 initial_states 满足 cell 的要求。  

inputs = paddle.rand([4, 23, 16])
prev_h = paddle.randn([4, 32])

cell = paddle.nn.SimpleRNNCell(16, 32)
rnn = paddle.nn.RNN(cell)  
outputs, final_states = rnn(inputs, prev_h) 

outputs.shape       # [4, 23, 32]   [batch, time_step, hidden_size]
final_state.shape   # [4, 32]       [batch, hidden_size]

paddle.nn.BiRNN() 双向循环神经网络
paddle.nn.SimpleRNNCell() 简单RNN单元基类
paddle.nn.SimpleRNN() RNN

paddle.nn.LSTMCell(input_size, hidden_size, weight_ih_attr=None, weight_hh_attr= None, bias_ih_attr=None, bias_hh_attr= None) LSTM网络单元基类

LSTM单元
参数: 
    * 1.input_size: int, 输入的大小  input_dim
    * 2.hidden_size: int,隐藏状态大小  
    * 3.weight_ih_attr: ParamAttr, 可选, weight_ih 的参数  
    * 4.weight_hh_attr: ParamAttr, 可选, weight_hh 的参数 
    * 5.bias_ih_attr: ParamAttr, 可选, bias_ih 的参数
    * 6.bias_hh_attr: ParamAttr, 可选, bias_hh 的参数  
变量: 
    * 1.weight_ih:Parameter, input到hidden的变换矩阵权重,形状为:[4*hidden_size, input_size], 对应公式中的 Wii, Wif, Wig, Wio. 
    * 2.weight_hh:Parameter, hidden到hidden的变换矩阵权重,形状为:
    [4*hidden_size, hidden_size], 对应公式中的 Whi, Whf, Whg, Who. 
    * bias_ih 
    * bias_hh  
输入: 
    1.inputs: tensor, 输入，形状:[batch_size, input_size]
    2.states: tuple,可选,包含 h_t-1, c_t-1 两个tensor的元组，每个tensor形状都是[batch_size, hidden_size],上一轮的隐藏状态，当state=None,全0矩阵。   
输出: 
    1.outputs:tensor，输出,形状:[batch_size, hidden_size], 对应公式中的 h_t 
    2.mew_state: tuple, 两个tensor的元组,每个形状:[batch_size, hidden_size]

    x = paddle.randn([4, 16])
    prev_h = paddle.randn([4, 32])
    prev_c = paddle.randn([4, 32])

    cell = paddle.nn.LSTMCell(16, 32)
    y, (h, c) = cell(x, (prev_h, prev_c))
    y.shape     # [4, 32]
    h.shape     # [4, 32]
    c.shape     # [4, 32]

class paddle.nn.LSTM(input_size, hidden_size, num_layers=1, direction="forward", dropout=0.,time_major=False, weight_ih_attr=None, weight_hh_attr=None, bias_ih_attr=None, bias_hh_attr=None) LSTM

长短期记忆网络,根据输入序列和给定的初始状态计算返回输出序列和最终状态。在该网络中的每一层对应输入的step,每个step根据当前时刻输入 xt, 和 上一时刻状态 h_t-1, c_t-1,计算出当前时候输出y_t,并更新状态: h_t, c_t.  

参数: 
    * input_size: int, 输入的大小(维度,神经元数量)
    * hidden_size: int, 隐藏状态大小  
    * num_layers: int,可选，网络层数,默认: 1
    * direction: str,可选,网络迭代方向, forward/bidirect/bidirectional
    * time_major: bool, 可选, 指定 input 的第一个维度是否是 time_steps， 默认False   
    * dropout: float,可选, dropout概率,指的是除第一层外 每层输入时的dropout概率。 默认为: 0
    * ? weight_ih_attr: ParamAttr, 可选, weight_ih的参数, 默认为: None 
    * ? weight_hh_attr: ParamAttr, 可选, weight_hh的参数, 默认为: None
    * bias_ih_attr: ParamAttr, 可选
    * bias_hh_attr: ParamAttr, 可选  
输入: 
    * 1.inputs: Tensor, 网络输入, 如果time_major=True, 则tensor的形状为[time_steps, batch_size, input_size], 如果time_major=False,则tensor的形状为[batch_size, time_steps, input_size].   

    * 2.initial_states: tuple, 可选, 网络的初始状态, 一个包含:h,c的元组,形状为:[num_layers * num_directions, batch_size, hiidden_size]。如果没有给出则会以 全0初始化。   

    * 3.sequence_length: tensor,可选,指定输入序列的长度,形状为[batch_size], 数据类型为 int64/32. 在输入序列中所有 time_step 不小于 sequence_length 的元素会被当做填充元素处理(状态不再更新)  
输出:
    * 1.outputs:tensor,输出,由前向和后向cell的输出拼接得到,如果time_major 为 True,则 tensor的形状为:[time_steps, batch_size, num_directions*hidden_size], 如果time_major= False,则tensor的形状为:[batch_size, time_steps, num_directions_hidden_size]. 当dirention设置为 bidirectional 时, num_directions=2，否则=1.  
    * 2.final_states:tuple, 最终状态,一个包含 h 和 c 的元组。形状为: [num_layers * num_directions , batch_size, hidden_size], 当direction 设置为 bidirectional 时,num_directions 等于2，返回值的前向和后向状态的索引分别是: 0,2,4,6... 和 1，3，5，7, 否则等于1  

lstm = paddle.nn.LSTM(16, 32, 2)    # input_size, hidden_size, num_layer
data = paddle.randn([4, 23, 16])    # batch_size, seq_len, dim 
prev_h = paddle.randn([2, 4, 32])   # num_layer, batch_size, hidden_size
prev_c = paddle.randn([2, 4, 32])   # num_layer, batch_size, hidden_size

y, (h, c) = lstm(data, (prev_h, prev_c))
y.shape     # [4, 23, 32]
h.shape     # [2, 4,  32]
c.shape     # [2, 4,  32]

paddle.nn.GRUCell() GRU网络单元基类
paddle.nn.GRU() GRU()

八、Transformer 相关

class paddle.nn.MultiHeadAttention(embed_dim, num_heads, dropout=0.0, kdim=None, vdim=None, need_weights=False, weight_attr=None, bias_attr= None) 多头注意力机制 ,attention_mask？输入输出形状? 学习到的参数? 4*dim *dim q,k,v,out

注意力机制可以将 查询(Query) 与 一组键值对(Key-Value)映射到输出，而多头注意力机制是将注意力机制的计算过程计算多次，以便模型提取不同子空间的信息。   
参数: 
    1.embed_dim: int, 输入输出的维度  
    2.num_heads: int, 多头注意力机制的 Head 数量  
    3.dropout: float,可选,注意力目标的随机丢弃率，0表示不加
    4.kdim: int, 可选, 键值对中 key 的维度,如果为 None, 则 kdim=embed_dim, 默认值:None
    5.vdim: int, 可选, 键值对中 value 的维度, 如果None,则 kdim=embed_dim, 默认: None
    6.need_weights: bool, 可选, 表明是否返回注意力权重，默认值: False 
    7.weight_attr:ParamAttr, 可选, 指定权重参数属性的对象, 默认值None
    8.bias_attr: ParamAttr,可选, 指定偏置参数属性的对象。  

from paddle.nn import MultiHeadAttention

# encoder input: [batch_size, sequence_length, d_model]
query = paddle.rand((2, 4, 128))
# self-attention mask: [batch_size, num_heads, query_len, query_len]
attn_mask = paddle.rand((2, 2, 4, 4))
multi_head_attn = MultiHeadAttention(128, 2)
output = multi_head_attn(query, None, None, attn_mask=attn_mask)  # [2, 4, 128]

paddle.nn.Transformer(d_model=512, nhead=8, num_encoder_layers=6, num_decoder_layers=6, dim_feedforward=2048....) Transformer模型:编码器+解码器

paddle.nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout=0.1, activation="relu", attn_dropout=None, act_dropout=None, normalize_before=False, weight_attr=None, bias_attr= None) Transformer编码器层

Transformer 编码器层由两个子层组成: 多投自注意力机制 和 前馈神经网络。 如果 normalize_before=True, 则对每个子层的输入进行 层标准化(Layer Normalization), 对每个子层的输出进行 dropout 和 残差连接。 否则:normalize_before=False, 则对每个子层的输入不进行处理,只对每个子层的输出进行 dropout、残差连接、层标准化。   

参数: 
    1.d_model: int, 输入、输出的维度 
    2.n_head: 多头注意力机制的 Head数量  
    3.dim_feedforward (int) - 前馈神经网络中隐藏层的大小
    4.dropout (float，可选) - 对两个子层的输出进行处理的dropout值。默认值：0.1
    5.activation (str，可选) - 前馈神经网络的激活函数。默认值：relu
    6.attn_dropout (float，可选) - 多头自注意力机制中对注意力目标的随机失活率。如果为 None 则 attn_dropout = dropout。默认值：None
    7.act_dropout (float，可选) - 前馈神经网络的激活函数后的dropout。如果为 None 则 act_dropout = dropout。默认值：None
    8.normalize_before (bool, 可选) - 设置对每个子层的输入输出的处理
    9.weight_attr (ParamAttr|tuple，可选) - 指定权重参数属性的对象
    10.bias_attr （ParamAttr|tuple|bool，可选）- 指定偏置参数属性的对象

import paddle
from paddle.nn import TransformerEncoderLayer 

# encoder_input: [batch_size, src_len, d_model]
enc_input = paddle.rand([2, 4, 128])
# self-attention mask: [batch_size, n_head, src_len, src_len]
attn_mask = paddle.rand([2, 2, 4, 4])  
encoder_layer = TransformerEncoderLayer(128, 2, 512)
enc_output = encoder_layer(enc_input, attn_mask)        # [2, 4, 128]

class paddle.nn.TransformerEncoder(encoder_layer, num_layers, norm=None) Transformer编码器

Transformer编码器由多个 Transformer 编码器层(TransformerEncoderLayer)叠加而成的。  

参数: 
    1.encoder_layer: Layer, TransformerEncoderLayer 的一个实例,作为Transformer编码器的第一层,其他层将根据它的配置进行构建。  
    2.num_layers: int, TransforEncoderLayer层的叠加数量。  
    3.norm: LayerNorm, 可选，层标准化，如果提供该参数，将对编码器的最后一层的输出进行层 标准化。   
输入: 

import paddle
from paddle.nn inport TansformerEncopderLayer, TransformerEncoder

# encoder input: [batch_size, src_len, d_model]  
enc_input = paddle.rand([2, 4, 128])

# self_attention mask: [batch_size, n_head, src_len ,src_len]
attn_mask = paddle.rand([2, 2, 4, 4])
encoder_layer = TransformerEncoderLayer(128, 2, 512)
encoder = TransformerEncoder(encoder_layer, 2)
enc_output = encoder(enc_input, attn_mask)      # [2, 4, 128]

paddle.nn.TransformerDecoder() Transformer解码器
paddle.nn.TransformerDecoderLayer() Transformer解码器层

九、线性层

paddle.nn.Linear(in_features, out_features, weight_attr=None, bias_attr= None) 线性变换层

Linear层只接受一个 tensor 作为输入，形状为: [batch_size, *, in_features],其中 * 表示可以为 任意个 额外的维度。计算 输入tensor 和 权重矩阵 W 的乘积，然后生成形状为 [batch_size, * , out_features] 的输出tensor. 如果 bias_attr 不是 False, 则将会=创建一个 偏置参数并将其添加到 输出中。   

参数: 
    1. in_features: int , 线性变换层 输入单元的数目  
    2. out_features: int, 线性变换层  输出单元的数目 
    3. weight_attr: ParamAttr, 可选, 指定权重参数的属性。   
    4. bias_attr: ParamAttr, 可选, 指定偏置参数的属性。   
属性: 
    1.weight: 本层的可学习参数,类型为: Parameter  
    2. bias: 本层的可学习偏置，类型为： Parameter  
形状: 
    1. 输入: [batch_size, *, in_fetures] 的多维tensor。
    2. 输出: [batch_size, *, out_features] 的多维tensor  

# 参数自定义(可以不定义,自动生成)   
weight_attr = paddle.nn.ParamAttr(
        name= "weight",
        initializer = paddle.nn.initializer.Constant(value=0.5))
bias_attr = paddle.nn.ParamAttr(
        name = "bias",
        initializer = paddle.nn.initializer.Constant(value= 1.0))
linear = paddle.nn.Linear(2, 4, weight_attr= weight_attr, bias_attr = bias_attr)  
# linear.weight: [[0.5 0.5 0.5 0.5]
#                 [0.5 0.5 0.5 0.5]]
# linear.bias: [1. 1. 1. 1.]

x = paddle.randn((3, 2), dtype="float32")
# x: [[-0.32342386 -1.200079  ]
#     [ 0.7979031  -0.90978354]
#     [ 0.40597573  1.8095392 ]]
y = linear(x)
# y: [[0.23824859 0.23824859 0.23824859 0.23824859]
#     [0.9440598  0.9440598  0.9440598  0.9440598 ]
#     [2.1077576  2.1077576  2.1077576  2.1077576 ]]

paddle.nn.Bilinnear(in_1_features, in_2_features, out_features, weight_attr= None, bias_attr = None) 对两个输入执行双线性张量积

out_i = X1 * W_i * X2.t()       
* x1: 第一个输入, 形状: [batch_size, in_1_features] 
* x2: 第二个输入, 形状: [batch_size, in_2_features] 
* W_i: 第 i 个被学习的权重, 形状是[in_1_features, in_2_features]，完整的W的形状: [out_features, in_1_features, in_2_features]  
* out_i: 输出的 第 i 个元素, 形状:[batch_size], 而完整的out形状:[batch_size, out_features] 
* b: 偏置， 形状:[1, out_features]

参数: 
    1.in_1_features: int, 每个 x1 元素的维度。  
    2.in_2_features: int, 每个 x2 元素的维度
    3.out_features: int, 输出张量的维度
    4.weight_attr: ParamAttr, 可选 
    5. bias_attr: ParamAttr, 可选  

属性: 
    1.weight: 本层的可学习参数,类型为: Parameter
    2.bias:本层的可学习偏置,类型为: Paramter

返回: 
    tensor, 形状:[batch_size, out_features] 的 2-D 张量。 

layer1 = numpy.random.random((5, 5)).astype('float32')
layer2 = numpy.random.random((5, 4)).astype('float32')
bilinear = paddle.nn.Bilinear(
    in1_features=5, in2_features=4, out_features=1000)
result = bilinear(paddle.to_tensor(layer1),
                paddle.to_tensor(layer2))     # result shape [5, 1000]

十、Dropout层

paddle.nn.Dropout(p= 0.5, axis= None, mode="upscale_in_train") Dropout

Dropout 是一种正则化手段，根据给定的丢弃概率P，在训练过程中随机将一些神经元输出设置为0， 通过阻止神经元节点之间的 相关性来减少拟合。  动态图模式下，使用模型的 eval()方法切换至 测试阶段。  

参数: 
    1.p:float, 将输入节点 置为0的概率，即丢弃概率，默认: 0.5 
    2.axis: int/list, 指定对输入 tensor 进行dropout的轴，默认None  ??? 默认哪一维度？
    3.不懂---mode: str, 丢弃单元的方式,有两种设置: "upscale_in_train" 和 "downscale_in_infer" 默认:upscale_in_train.  
    3.1 upscale_in_train: 在训练时增大输出结果。  
    * train: out = input * mask / (1-p)  
    * infer: out = input  
    3.2 downscale_in_infer:在预测时较小输出结果 
    * train: out = input * mask
    * infer: out = input * (1-p)

x = np.array([[1,2,3], [4,5,6]]).astype('float32')
x = paddle.to_tensor(x)
m = paddle.nn.Dropout(p=0.5)
y_train = m(x)
m.eval()  # switch the model to test phase
y_test = m(x)
print(x)
print(y_train)
print(y_test)

paddle.nn.Dropout2D() 二维Dropout
paddle.nn.Dropout3D() 三维Dropout

Embedding层

class paddle.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, sparse= False, weight_attr= None) 嵌入层(Embedding Layer)

嵌入层(Embedding Layer)
用于构建 Embedding 的一个可调用对象, 其根据 input 中的id信息从 embedding 矩阵中查询对应 embedding 信息，并会根据 输入的 size(num_embeddings, embedding_dim) 和 weight_attr 自动构造一个 二维embedding矩阵。   

输出: tensor, shape 是在输入 tensor shape 的最后一维后面添加了 embedding_dim 的维度  

参数: 
    1. num_embeddings: int, 嵌入字典的大小, input 中的 id必须满足 0<=id< num_embeddings
    2. embedding_dim: int, 每个嵌入向量的维度  
    3. padding_idx: int/long/None, padding_idx 的配置区间为 [-weight.shape[0], weight.shape[0]]
    4.sparse: bool, 是否使用稀疏更新,在词嵌入权重比较大的情况下，使用稀疏更新能够获得更快的训练速度和更小的内存、显存占用。  
    5.weight_attr: ParamAttr, None, 指定嵌入向量的配置，包括初始化方法,一般无需设置，默认None  
返回：input映射后得到的Embedding Tensor，数据类型和词嵌入的定义类型一致

data = paddle.to_tensor([[1], [2], [3]], dtype="int64", stop_gradient= False)  
embedding = paddle.nn.Embedding(10, 3, sparse=True)
w0 = paddle.full(shape=[10,3], fill_value=2, dtype="float32")
embedding.weight.set_value(w0)

adam = paddle.optimizer.Adam(parameters = embedding.weight, learning_rate= 0.1) 
adam.clear_grad()  

# weight.shape = [10, 3]
# x.data = [[3],[4],[5]]
# x.shape = [3, 1]

out = embedding(data)
out.backward()
adam.step()

十二、Loss层

1.class paddle.nn.BCELoss(weight=None, reduction="mean") BCELoss层

创建一个BCELoss 的可调用类,用于计算输入 input 和 标签 label 之间的二值交叉熵损失值。   
* weight: label*log(input) 前的系数
* 当reduction=None, 直接返回最原始的 out 结果。  
* 当reduction=mean,最后结果为: out = mean(out)
* 当reduction=sum, 最后结果为: sum(out) 
注意: 输入数据 input 一般是 sigmoid 的输出,因为是二分类,所以标签值 label 是 0 或 1.  

参数: 
    1. weight: tensor, 可选, 手动指定每个batch二值交叉熵的权重。   
    2. reduction: str, 可选, 直营应用于输出结果的计算方式。  
形状:
    1.input: tensor, [N, *], 其中N是batch_size, * 是任意其他维度, 输入数据一般 sigmod 的输出, 数据类型: float32、float64  
    2.label: tensor, [N, *], 标签label的维度、数据类型和输入 input 相同。  
    3. output: tensor, 输出的tensor, reduction=None, 输出维度: [N,*],与输入相同。  如果mean 或 sum, 则输出的维度为 [1].  
返回: 
    返回计算BCELoss 的可调用对象  

input = paddle.to_tensor([0.5, 0.6, 0.7], dtype="float32")
label = paddle.to_tensor([1, 0, 1], dtype="float32")
bce_loss = paddle.nn.BCELoss()
output = bce_loss(input, label)
print(output)       # [0.65537095]

2.paddle.nn.BCEWithLogitsLoss(weight=None, reduction="mean", pos_weight=None) BCEWithLogitsLoss层

sigmoid 操作 + BCELoss() 操作。 log(sigmoid(logits))
参数: 
    1.weight: 
    2.reduction: 
    3.pos_weight:
形状:
    1.logit: tensor, [N, *]
    2.label: tensor, [N, *]
    3.output: tensor, [N, *]
返回:
    返回计算BCEWithLogitsLoss 的可调用对象  

logit = paddle.to_tensor([5.0, 1.0, 3.0], dtype="float32")
label = paddle.to_tensor([1.0, 0.0, 1.0], dtype="float32")
bce_logit_loss = paddle.nn.BCEWithLogitsLoss()
output = bce_logit_loss(logit, label)
print(output)  # [0.45618808]

3.paddle.nn.CrossEntropyLoss(weight=None, ignore_index=-100, reduction="mean", soft_label=False, axis=-1) 交叉熵Loss

参数: 
    1.weight:tensor, 可选, 指定每个类别的权重  
    2.ignore_index: int64, 可选，指定一个忽略的标签值,此标签不参与计算。  
    3.reduction: str,可选, 指定应用于 输出结果的计算方法。 
    4.soft_label: bool,可选,指明 label 是否是软标签,默认为False,表示label为硬标签。  
    5.axis: int, 可选, 进行softmax计算的维度索引。 默认值； -1 
形状: 
    1.input: tensor, 输入tensor, float32/64, 形状:[N, C],其中C是类别数。  
    2.label: tensor, 输入input对应的标签值,int64, 形状:[N]
    3.output: tensor, 计算CrossEntropyLoss 交叉熵后的损失值。  

input_data = paddle.uniform([5, 100], dtype="float64")
label_data = np.random.randint(0, 100, size=(5)).astype(np.int64)
weight_data = np.random.random([100]).astype("float64")

input =  paddle.to_tensor(input_data)
label =  paddle.to_tensor(label_data)
weight = paddle.to_tensor(weight_data)

ce_loss = paddle.nn.CrossEntropyLoss(weight=weight, reduction='mean')
output = ce_loss(input, label)
print(output)
# [4.84496039]

6.paddle.nn.NLLLoss(weight=None, ignore_index=-100, reduction="mean") NLLLoss层

CrossEntropyLoss = NLLLoss() + LOG() + Softmax() 
计算逻辑和交叉熵差不多。 
NLLLoss： label对应的位置的预测结果去掉 负号就是...  

参数: 
    1.weight:
    2.ignore_index:
    3.reduction:
形状:
    1.input:
    2.label:
    3.output:

nll_loss = paddle.nn.loss.NLLLoss()
log_softmax = paddle.nn.LogSoftmax(axis=1)

input = paddle.to_tensor([[0.88103855, 0.9908683 , 0.6226845 ],
                        [0.53331435, 0.07999352, 0.8549948 ],
                        [0.25879037, 0.39530203, 0.698465  ],
                        [0.73427284, 0.63575995, 0.18827209],
                        [0.05689114, 0.0862954 , 0.6325046 ]], "float32")
log_out = log_softmax(input)
label = paddle.to_tensor([0, 2, 1, 1, 0], "int64")
result = nll_loss(log_out, label)
print(result) # Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=True, [1.07202101])

4.paddle.nn.L1Loss(reduction="mean") L1 loss

参数: 
    1.reduction: str, 可选
形状:
    1.input: tensor, 输入的tensor, 维度是[N, *], 其中N是 batch_size
    2.label: 标签, [N, *]
    3.output: tessor  

input = paddle.to_tensor([[1.5, 0.8], [0.2, 1.3]])
label = paddle.to_tensor([[1.7, 1.0], [0.4, 0.5]])

l1_loss = paddle.nn.loss.L1Loss()
output = l1_loss(input, label)
print(output)
# [0.35]

paddle.nn.SmoothL1Loss() 平滑L1损失层

5.paddle.nn.MSELoss() 均方误差损失层

计算预测值 和 目标值 的均方差误差。 

input_data = np.array([1.5]).astype("float32")
label_data = np.array([1.7]).astype("float32")

mse_loss = paddle.nn.MSELoss()
input = paddle.to_tensor(input_data)
label = paddle.to_tensor(label_data)
output = mse_loss(input, label)
print(output)
# [0.04000002]

7.KLDivLoss(reduction="mean") Kullback-Leibler 散度损失层
```
形状: 
    1.input:
    2.label: [N, *], 同 input
    3.output
```

8.paddle.nn.MarginRankingLoss(margin=0.0, reduction="mean") MarginRankingLoss层

用于创建一个 MarginRankingLoss 的可调用类，计算输入input，other 和 标签label间的 margin rank loss 损失
margin_rank_loss = max(0, margin - label*(input - other))

参数: 
    1.margin: float, 可选, 默认值0  
    2.reduction: str, 可选 

形状:
    1.input: N-D tensor, 形状:[N, *], 其中N:batch_size  
    2.other: 与 input的形状、数据类型相同  
    3.label: 与 input的形状、数据类型相同
    4.output: 

input = paddle.to_tensor([[1, 2], [3, 4]], dtype='float32')
other = paddle.to_tensor([[2, 1], [2, 4]], dtype='float32')
label = paddle.to_tensor([[1, -1], [-1, -1]], dtype='float32')
margin_rank_loss = paddle.nn.MarginRankingLoss()
loss = margin_rank_loss(input, other, label)
print(loss) # [0.75]

不回9.paddle.nn.HSigmoidLoss() 层次sigmoid损失层
不回 paddle.nn.CTCLoss() CTCLoss层

十三、Vision层

十四、Clip相关

paddle.nn.ClipGradByGlobalNorm 将一个 Tensor列表 t_list 中所有Tensor的L2范数之和，限定在 clip_norm 范围内
paddle.nn.ClipGradByNorm() 将输入的多维Tensor X 的L2范数限制在 clip_norm 范围之内
paddle.nn.ClipGradByValue() 将输入的多维Tensor X 的值限制在 [min, max] 范围

十五、公共层

paddle.nn.Flatten 将一个连续维度的Tensor展平成一维Tensor
paddle.nn.CosineSimilarity 余弦相似度计算
paddle.nn.BeamSearchDecoder 带beam search解码策略的解码器
paddle.nn.PairwiseDistance 计算两个向量之间pairwise的距离
paddle.nn.dynamic_decode 循环解码

十六、卷积相关函数

paddle.nn.functional.conv1d 一维卷积函数
paddle.nn.functional.conv1d_transpose 一维转置卷积函数
paddle.nn.functional.conv2d 二维卷积函数
paddle.nn.functional.conv2d_transpose 二维转置卷积函数
paddle.nn.functional.conv3d 三维卷积函数
paddle.nn.functional.conv3d_transpose 三维转置卷积函数

十七、pooling相关函数

paddle.nn.functional.adaptive_avg_pool1d 一维自适应平均池化
paddle.nn.functional.adaptive_avg_pool2d 二维自适应平均池化
paddle.nn.functional.adaptive_avg_pool3d 三维自适应平均池化
paddle.nn.functional.adaptive_max_pool1d 一维自适应最大池化
paddle.nn.functional.avg_pool1d 一维平均池化
paddle.nn.functional.avg_pool2d 二维平均池化
paddle.nn.functional.avg_pool3d 三维平均池化
paddle.nn.functional.max_pool1d 一维最大池化
paddle.nn.functional.max_pool2d 二维最大池化
paddle.nn.functional.max_pool3d 三维最大池化

十八、paddling相关函数

paddle.nn.functional.pad 依照 pad 和 mode 属性对input进行填充

十九、激活函数

二十、Normalization方法

二十一、线性处理相关函数

二十二、Dropout 方法

二十三、Embedding 相关方法

二十四、损失函数

二十五、公用方法

二十六、初始化相关

paddle.nn.initializer.Assign 使用Numpy数组、Python列表、Tensor来初始化参数
paddle.nn.initializer.Bilinear 该接口为参数初始化函数，用于转置卷积函数中
paddle.nn.initializer.Constant 用于权重初始化，通过输入的value值初始化输入变量
paddle.nn.initializer.KaimingNormal 实现Kaiming正态分布方式的权重初始化
paddle.nn.initializer.KaimingUniform 实现Kaiming均匀分布方式的权重初始化
paddle.nn.initializer.Normal 随机正态（高斯）分布初始化函数
paddle.nn.initializer.set_global_initializer 用于设置Paddle框架中全局的参数初始化方法
paddle.nn.initializer.TruncatedNormal 随机截断正态（高斯）分布初始化函数
paddle.nn.initializer.Uniform 随机均匀分布初始化函数
paddle.nn.initializer.XavierNormal 实现Xavier权重初始化方法（ Xavier weight initializer）
paddle.nn.initializer.XavierUniform 实现Xavier权重初始化方法（ Xavier weight initializer）

posted @ 2021-05-06 13:41 自私的人阅读(878) 评论(0) 编辑收藏举报

刷新页面返回顶部

Where there is a will, there is a way