Remove transformer apis

2023-01-29 11:59:11 +08:00 · 2023-01-29 11:59:11 +08:00 · 2f227c4537
parent 6bb7c08540
commit 2f227c4537
37 changed files with 20 additions and 616 deletions
--- a/docs/api/api_python/mindspore.nn.transformer.rst
+++ b/docs/api/api_python/mindspore.nn.transformer.rst
@ -1,25 +0,0 @@
-mindspore.nn.transformer
-========================
-
-.. note::
-    Transformer网络。这些是实验性接口，可能会修改或删除。
-
-.. include:: transformer/mindspore.nn.transformer.AttentionMask.rst
-.. include:: transformer/mindspore.nn.transformer.VocabEmbedding.rst
-.. include:: transformer/mindspore.nn.transformer.MultiHeadAttention.rst
-.. include:: transformer/mindspore.nn.transformer.FeedForward.rst
-.. include:: transformer/mindspore.nn.transformer.TransformerEncoder.rst
-.. include:: transformer/mindspore.nn.transformer.TransformerDecoder.rst
-.. include:: transformer/mindspore.nn.transformer.TransformerEncoderLayer.rst
-.. include:: transformer/mindspore.nn.transformer.TransformerDecoderLayer.rst
-.. include:: transformer/mindspore.nn.transformer.Transformer.rst
-.. include:: transformer/mindspore.nn.transformer.TransformerOpParallelConfig.rst
-.. include:: transformer/mindspore.nn.transformer.EmbeddingOpParallelConfig.rst
-.. include:: transformer/mindspore.nn.transformer.TransformerRecomputeConfig.rst
-.. include:: transformer/mindspore.nn.transformer.CrossEntropyLoss.rst
-.. include:: transformer/mindspore.nn.transformer.OpParallelConfig.rst
-.. include:: transformer/mindspore.nn.transformer.FixedSparseAttention.rst
-.. include:: transformer/mindspore.nn.transformer.MoEConfig.rst
-
-.. automodule::  mindspore.nn.transformer
-    :members:
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.AttentionMask.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.AttentionMask.rst
@ -1,18 +0,0 @@
-.. py:class:: mindspore.nn.transformer.AttentionMask(seq_length, parallel_config=default_dpmp_config)
-
-    从输入掩码中获取下三角矩阵。输入掩码是值为1或0的二维Tensor (batch_size, seq_length)，1表示当前位置是一个有效的标记，0则表示当前位置不是一个有效的标记。
-
-    参数：
-        - **seq_length** (int) - 表示输入Tensor的序列长度。
-        - **parallel_config** (OpParallelConfig) - 表示并行配置。默认值为 `default_dpmp_config` ，表示一个带有默认参数的 `OpParallelConfig` 实例。
-
-    输入：
-        - **input_mask** (Tensor) - 掩码矩阵，shape为(batch_size, seq_length)，表示每个位置是否为有效输入。
-
-    输出：
-        Tensor，表示shape为(batch_size, seq_length, seq_length)的注意力掩码矩阵。
-
-    异常：
-        - **TypeError** - `seq_length` 不是整数。
-        - **ValueError** - `seq_length` 不是正数。
-        - **TypeError** - `parallel_config` 不是OpParallelConfig的子类。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.CrossEntropyLoss.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.CrossEntropyLoss.rst
@ -1,14 +0,0 @@
-.. py:class:: mindspore.nn.transformer.CrossEntropyLoss(parallel_config=default_dpmp_config)
-
-    计算输入和输出之间的交叉熵损失。
-
-    参数：
-        - **parallel_config** (OpParallelConfig) - 表示并行配置。默认值为 `default_dpmp_config` ，表示一个带有默认参数的 `OpParallelConfig` 实例。
-
-    输入：
-        - **logits** (Tensor) - shape为(N, C)的Tensor。表示的输出logits。其中N表示任意大小的维度，C表示类别个数。数据类型必须为float16或float32。
-        - **labels** (Tensor) - shape为(N, )的Tensor。表示样本的真实标签，其中每个元素的取值区间为[0,C)。
-        - **input_mask** (Tensor) - shape为(N, )的Tensor。input_mask表示是否有填充输入。1表示有效，0表示无效，其中元素值为0的位置不会计算进损失值。
-
-    输出：
-        Tensor，表示对应的交叉熵损失。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.EmbeddingOpParallelConfig.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.EmbeddingOpParallelConfig.rst
@ -1,8 +0,0 @@
-.. py:class:: mindspore.nn.transformer.EmbeddingOpParallelConfig(data_parallel=1, model_parallel=1, vocab_emb_dp=True)
-
-    `VocabEmbedding` 类中的并行配置，用来设置对嵌入表进行数据并行或者模型并行。
-
-    参数：
-        - **data_parallel** (int) - 表示数据并行度。根据这个数值，VocabEmbedding层的的输入数据将会被切分成原来的1/data_parallel。默认值：1。
-        - **model_parallel** (int) - 表示模型并行度。根据这个数值，VocabEmbedding层的的权重将会在第零维度被切分成原来的1/model_parallel。默认值：1。
-        - **vocab_emb_dp** (bool) - 表示将权重进行模型切分或数据并行。如果是True，嵌入表查找的操作将会以数据并行的方式进行，此时model_parallel的值将会被忽略。如果是False,嵌入表将会在第零维度进行切分成model_parallel份数。默认值：True。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.FeedForward.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.FeedForward.rst
@ -1,31 +0,0 @@
-.. py:class:: mindspore.nn.transformer.FeedForward(hidden_size, ffn_hidden_size, dropout_rate, hidden_act="gelu", expert_num=1, expert_group_size=None, param_init_type=mstype.float32, parallel_config=default_dpmp_config)
-
-    具有两层线性层的多层感知器，并在最终输出上使用Dropout。第一个线性层将输入维度从hidden_size投影到ffn_hidden_size，并在中间应用激活层。第二个线性层将该维度从ffn_hidden_size投影到hidden_size。配置parallel_config之后，
-    第一个线性层的权重将在输入维度上被分片，第二个线性层在输出维度上进行切分。总体过程如下：
-
-    .. math::
-        Dropout((xW_1+b_1)W_2 + b_2)
-
-    其中 :math:`W_1, W_2, b_1` 和 :math:`b_2` 为可训练参数。
-
-    参数：
-        - **hidden_size** (int) - 表示输入的维度。
-        - **ffn_hidden_size** (int) - 表示中间隐藏大小。
-        - **dropout_rate** (float) - 表示第二个线性层输出的丢弃率。
-        - **hidden_act** (str, nn.Cell) - 表示前馈层的激活行为。其值可为'relu'、'relu6'、'tanh'、'gelu'、'fast_gelu'、'elu'、'sigmoid'、'prelu'、'leakyrelu'、'hswish'、'hsigmoid'、'logsigmoid'等等。用户可以传入自定义的激活函数。如果用户要想在并行模式下运行此网络，自定义的激活函数必须提供 `activation_shard` 类方法。请查看类 `mindspore.nn.transformer.FeedForward` 的示例。默认值：gelu。
-        - **expert_num** (int) - 表示线性层中使用的专家数量。对于expert_num > 1用例，使用BatchMatMul。BatchMatMul中的第一个维度表示expert_num。默认值：1。
-        - **expert_group_size** (int) - 表示每个数据并行组收到的词语（token）数量。默认值：None。该参数只在自动并行且非策略传播模式下起作用。
-        - **param_init_type** (dtype.Number) - 表示参数初始化类型。其值应为mstype.float32或mstype.float16。默认值：mstype.float32。
-        - **parallel_config** (OpParallelConfig, MoEParallelConfig) - 表示配置该网络的并行度的并行配置。更多详情，请参见 :class:`mindspore.nn.transformer.OpParallelConfig` 。默认值为 `default_dpmp_config` ，表示一个带有默认参数的 `OpParallelConfig` 实例。
-
-    输入：
-        - **x** (Tensor) - 应为 `[batch, seq_length, hidden_size]或[batch * seq_length, hidden_size]` 。表示浮点Tensor。
-
-    输出：
-        Tensor，表示映射后该层的输出。shape为 `[batch, seq_length, hidden_size]` 或 `[batch * seq_length, hidden_size]` 。
-
-    异常：
-        - **TypeError** - `hidden_act` 不是字符串或者nn.Cell。
-        - **TypeError** - `parallel_config` 不是OpParallelConfig的子类。
-        - **ValueError** - `ffn_hidden_size` 不是parallel_config中model_parallel的倍数。
-        - **ValueError** - `hidden_size` 不是parallel_config中model_parallel的倍数。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.FixedSparseAttention.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.FixedSparseAttention.rst
@ -1,30 +0,0 @@
-.. py:class:: mindspore.nn.transformer.FixedSparseAttention(batch_size, num_heads, size_per_head, block_size, seq_length=1024, num_different_global_patterns=4, parallel_config=default_dpmp_config)
-
-    固定稀疏注意力层。
-
-    此接口实现了Sparse Transformer中使用的稀疏注意力原语，更多详情，请见论文 `Generating Long Sequences with Sparse Transformers <https://arxiv.org/abs/1904.10509>`_ 。
-
-    具体来说，它包括以下内容：
-
-    1. 正常注意力的更快实现（不计算上三角，并且融合了许多操作）。
-    2. 如论文Sparse Transformers所述，“分散”和“固定”注意力的实现。
-
-    参数：
-        - **batch_size** (int) - 表示输入batch size的数量。
-        - **num_heads** (int) - 表示注意力头数。
-        - **block_size** (int) - 表示用来确定block size的整数。目前稀疏自注意力的实现基于稀疏块矩阵。此参数定义了稀疏矩阵块的大小。目前仅支持64。
-        - **seq_length** (int) - 表示输入序列的长度。目前只支持1024。默认值为1024。
-        - **num_different_global_patterns** (int) - 表示用于确定不同的全局注意力数量。虽然全局注意力由局部的代表性的块决定，
-          但由于有多个头，所以每个头都可以使用不同的全局代表。目前只支持4。默认值为4。
-        - **size_per_head** (int) - 表示每个注意力头的向量大小。目前仅支持64和128。
-        - **parallel_config** (OpParallelConfig) - 并行设置，内容请参阅 `OpParallelConfig` 的定义。默认值为 `default_dpmp_config` ，一个用默认参数初始化的 `OpParallelConfig` 的实例。
-
-    输入：
-        - **q** (Tensor) - Tensor query ( `mstype.fp16` [batch_size, seq_length, hidden_size])：表示上下文的query向量。
-        - **k** (Tensor) - Tensor key ( `mstype.fp16` [batch_size, seq_length, hidden_size])：表示上下文的key向量。
-        - **v** (Tensor) - Tensor value ( `mstype.fp16` [批次大小, seq_length, hidden_size])：表示上下文的value向量。
-        - **attention_mask** (Tensor) - Float Tensor the mask of ( `mstype.fp32` , `mstype.fp16` [batch_size, seq_length, seq_length])：
-          表示掩码的下三角形矩阵。
-
-    输出：
-        Tensor，shape为[batch_size, seq_length, hidden_size]。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.MoEConfig.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.MoEConfig.rst
@ -1,13 +0,0 @@
-.. py:class:: mindspore.nn.transformer.MoEConfig(expert_num=1, capacity_factor=1.1, aux_loss_factor=0.05, num_experts_chosen=1, expert_group_size=None, group_wise_a2a=False, comp_comm_parallel=False, comp_comm_parallel_degree=2)
-
-    MoE (Mixture of Expert)的配置。
-
-    参数：
-        - **expert_num** (int) - 表示使用的专家数量。默认值：1。
-        - **capacity_factor** (float) - 表示专家处理的容量关系，其值大于等于1.0。默认值：1.1。
-        - **aux_loss_factor** (float) - 表示负载均衡损失（由路由器产生）的平衡系数。相乘的结果会加到总损失函数中。此系数的值小于1.0。默认值：0.05。
-        - **num_experts_chosen** (int) - 表示每个标识选择的专家数量，其值小于等于专家数量。默认值：1。
-        - **expert_group_size** (int) - 表示每个数据并行组收到的词语（token）数量。默认值：None。该参数只在自动并行且非策略传播模式下起作用。
-        - **group_wise_a2a** (bool) - 表示否是使能group-wise alltoall通信，group-wise alltoall通信可以把部分节点间通信转化为节点内通信从而减低通信时间。默认值：False。该参数只有在模型并行数大于1且数据并行数等于专家并行数生效。
-        - **comp_comm_parallel** (bool) - 是否使能MoE计算和通信并行，可以通过拆分重叠计算和通信来减少纯通信时间。默认值：False。
-        - **comp_comm_parallel_degree** (int) - 计算和通信的拆分数量。数字越大重叠越多，但会消耗更多的显存。默认值：2。该参数只在comp_comm_parallel为True下生效。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.MultiHeadAttention.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.MultiHeadAttention.rst
@ -1,43 +0,0 @@
-.. py:class:: mindspore.nn.transformer.MultiHeadAttention(batch_size, src_seq_length, tgt_seq_length, hidden_size, num_heads, hidden_dropout_rate=0.1, attention_dropout_rate=0.1, compute_dtype=mstype.float16, softmax_compute_type=mstype.float32, param_init_type=mstype.float32, use_past=False, parallel_config=default_dpmp_config)
-
-    论文 `Attention Is All You Need <https://arxiv.org/pdf/1706.03762v5.pdf>`_ 中所述的多头注意力的实现。给定src_seq_length长度的query向量，tgt_seq_length长度的key向量和value，注意力计算流程如下：
-
-    .. math::
-           MultiHeadAttention(query, key, vector) = Dropout(Concat(head_1, \dots, head_h)W^O)
-
-    其中， :math:`head_i = Attention(QW_i^Q, KW_i^K, VW_i^V)` 。注意：输出层的投影计算中带有偏置参数。
-
-    如果query tensor、key tensor和value tensor相同，则上述即为自注意力机制的计算过程。
-
-    参数：
-        - **batch_size** (int) - 表示增量预测时输入张量的批量大小，应该是正整数。当进行训练或预测时，该参数将不起作用，用户可将None传递给此参数。
-        - **src_seq_length** (int) - 表示query向量的序列长度。
-        - **tgt_seq_length** (int) - 表示key向量和value向量的序列长度。
-        - **hidden_size** (int) - 表示输入的向量大小。
-        - **num_heads** (int) - 表示注意力机制中头的数量。
-        - **hidden_dropout_rate** (float) - 表示最后dense输出的丢弃率。默认值：0.1
-        - **attention_dropout_rate** (float) - 表示注意力score的丢弃率。默认值：0.1
-        - **compute_dtype** (dtype.Number) - 表示dense中矩阵乘法的计算类型。默认值：mstype.float16。其值应为mstype.float32或mstype.float16。
-        - **param_init_type** (dtype.Number) - 表示模块的参数初始化类型。默认值：mstype.float32。其值应为mstype.float32或mstype.float16。
-        - **softmax_compute_type** (dtype.Number) - 表示softmax计算模块的类型。默认值：mstype.float32。  其值应为mstype.float32或mstype.float16。
-        - **use_past** (bool) - 使用过去状态进行计算，用于增量预测。例如，如果我们有两个单词，想生成十个或以上单词。我们只需要计算一次这两个单词的状态，然后逐个生成下一个单词。当use_past为True时，有两个步骤可以执行预测。
-          第一步是通过 `model.add_flags_recursive(is_first_iteration=True)` 将is_first_iteration设为True，并传递完整的输入。然后，通过 `model.add_flags_recursive(is_first_iteration=False)` 将is_first_iteration设为False。此时，传递step的输入tensor，并对其进行循环。默认值：False
-        - **parallel_config** (OpParallelConfig) - 表示并行配置。默认值为 `default_dpmp_config` ，表示一个带有参数的 `OpParallelConfig` 实例。
-
-    输入：
-        - **query_tensor** (Tensor) - use_past为False或is_first_iteration为True时，表示shape为(batch_size, src_seq_length, hidden_size)或(batch_size * src_seq_length, hidden_size)的query向量。否则，shape必须为(batch_size, 1, hidden_size)。
-        - **key_tensor** (Tensor) - use_past为False或is_first_iteration为True时，表示shape为(batch_size, tgt_seq_length, hidden_size)或(batch_size * tgt_seq_length, hidden_size)的key向量。否则，shape必须为(batch_size, 1, hidden_size)。
-        - **value_tensor** (Tensor) - use_past为False或is_first_iteration为True时，表示shape为(batch_size, tgt_seq_length, hidden_size)或(batch_size * tgt_seq_length, hidden_size)的value向量。否则，shape必须为(batch_size, 1, hidden_size)。
-        - **attention_mask** (Tensor) - use_past为False或is_first_iteration为True时，表示shape为(batch_size, src_seq_length, tgt_seq_length)的注意力掩码矩阵, 或者为None，None表示在Softmax计算中将不会进行掩码。否则，shape必须为(batch_size, 1, tgt_seq_length)。
-        - **key_past** (Tensor) - shape为(batch_size, num_heads, size_per_head, tgt_seq_length)的Float16 tensor，表示过去所计算的key向量。
-          当use_past为True时，需要传入非None值用于增量预测。默认值为None。
-        - **value_past** (Tensor) - shape为(batch_size, num_heads, tgt_seq_length, size_per_head)的Float16 tensor，表示过去所计算的value向量。
-          当use_past为True时，需要传入非None值用于增量预测。默认值为None。
-        - **batch_valid_length** (Tensor) - shape为(batch_size,)的Int32 tensor，表示已经计算的token索引。
-          当use_past为True时，需要传入非None值用于增量预测。默认值为None。
-
-    输出：
-        Tuple，表示一个包含(`output`, `layer_present`)的元组。
-
-        - **output** (Tensor) - Tensor。use_past为False或is_first_iteration为True时，表示shape为(batch_size, src_seq_length, hidden_size)或(batch_size * src_seq_length, hidden_size)的层输出的float tensor。否则，shape将为(batch_size, 1, hidden_size)。
-        - **layer_present** (Tuple) - 表示shape为((batch_size, num_heads, size_per_head, tgt_seq_length)或(batch_size, num_heads, tgt_seq_length, size_per_head))的投影key向量和value向量的Tensor的元组。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.OpParallelConfig.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.OpParallelConfig.rst
@ -1,7 +0,0 @@
-.. py:class:: mindspore.nn.transformer.OpParallelConfig(data_parallel=1, model_parallel=1)
-
-    用于设置数据并行和模型并行的OpParallelConfig。
-
-    参数：
-        - **data_parallel** (int) - 表示数据并行度。默认值：1
-        - **model_parallel** (int) - 表示模型并行度。默认值：1
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.Transformer.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.Transformer.rst
@ -1,45 +0,0 @@
-.. py:class:: mindspore.nn.transformer.Transformer(hidden_size, batch_size, ffn_hidden_size, src_seq_length, tgt_seq_length, encoder_layers=3, decoder_layers=3, num_heads=2, attention_dropout_rate=0.1, hidden_dropout_rate=0.1, hidden_act="gelu", post_layernorm_residual=False, layernorm_compute_type=mstype.float32, softmax_compute_type=mstype.float32, param_init_type=mstype.float32, lambda_func=None, use_past=False, moe_config=default_moe_config, parallel_config=default_transformer_config)
-
-    Transformer模块，包括编码器和解码器。与原始的实现方式的区别在于该模块在实行层归一化之前使用了残差加法。默认的激活层为 `gelu` 。
-    详细信息可参考 `Attention Is All You Need <https://arxiv.org/pdf/1706.03762v5.pdf>`_ 。
-
-    .. note::
-        这是一个实验接口，可能会被更改或者删除。
-
-    参数：
-        - **batch_size** (int) - 表示增量预测时输入张量的批量大小，应该是正整数。当进行训练或预测时，该参数将不起作用，用户可将None传递给此参数。
-        - **encoder_layers** (int) - 表示 `TransformerEncoderLayer` 的层数。
-        - **decoder_layers** (int) - 表示 `TransformerDecoderLayer` 的层数。
-        - **hidden_size** (int) - 表示输入向量的大小。
-        - **ffn_hidden_size** (int) - 表示前馈层中bottleneck的隐藏大小。
-        - **src_seq_length** (int) - 表示编码器的输入Tensor的seq_length。
-        - **tgt_seq_length** (int) - 表示解码器的输入Tensor的seq_length。
-        - **num_heads** (int) - 表示注意力头的数量。默认值：2
-        - **hidden_dropout_rate** (float) - 表示作用在隐藏层输出的丢弃率。默认值：0.1
-        - **attention_dropout_rate** (float) - 表示注意力score的丢弃率。默认值：0.1
-        - **post_layernorm_residual** (bool) - 表示是否在LayerNorm之前使用残差，即是否选择残差为Post-LayerNorm或者Pre-LayerNorm。默认值：False
-        - **use_past** (bool) - 表示是否开启增量推理。在推理中会缓存注意力机制计算结果，避免冗余计算。默认值为False。
-        - **layernorm_compute_type** (dtype.Number) - 表示LayerNorm的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **softmax_compute_type** (dtype.Number) - 表示注意力机制中softmax的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **param_init_type** (dtype.Number) - 表示模块的参数初始化类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **hidden_act** (str, nn.Cell) - 表示前馈层的激活行为。其值可为'relu'、'relu6'、'tanh'、'gelu'、'fast_gelu'、'elu'、'sigmoid'、'prelu'、'leakyrelu'、'hswish'、'hsigmoid'、'logsigmoid'等等。用户可以传入自定义的激活函数。如果用户要想在并行模式下运行此网络，自定义的激活函数必须提供 `activation_shard` 类方法。请查看类 `mindspore.nn.transformer.FeedForward` 的示例。默认值：gelu。
-        - **moe_config** (MoEConfig) - 表示MoE (Mixture of Expert)的配置。默认值为 `default_moe_config` ，表示带有默认参数的 `MoEConfig` 实例。
-        - **lambda_func** - 表示设置融合索引、pipeline阶段和重计算属性的函数。如果用户想确定pipeline阶段和梯度融合，用户可以传递一个接受 `network` 、 `layer_id` 、 `offset` 、 `parallel_config` 和 `layers` 的函数。 `network(Cell)` 表示transformer块， `layer_id(int)` 表示当前模块的层索引，从零开始计数， `offset(int)` 表示如果网络中还有其他模块，则layer_id需要一个偏移。pipeline的默认设置为： `(layer_id + offset) // ((encoder_layers + decoder_length) / pipeline_stage)` 。默认值为None。
-        - **parallel_config** (TransformerOpParallelConfig) - 表示并行配置。默认值为 `default_transformer_config` ，表示带有默认参数的 `TransformerOpParallelConfig` 实例。
-
-    输入：
-        - **encoder_inputs** (Tensor) - shape为[batch_size, seq_length, hidden_size]或[batch_size * seq_length, hidden_size]的输入Tensor。
-        - **encoder_masks** (Tensor) - shape为[batch_size, seq_length, seq_length]的解码器的注意力掩码。或者为None，None表示在编码器中self attention中的Softmax计算中将不会进行掩码。
-        - **decoder_inputs** (Tensor) - shape为[batch_size, seq_length, hidden_size]或[batch_size * seq_length, hidden_size]的编码器的输出。如果解码器层数为0，则此值应为None。
-        - **decoder_masks** (Tensor) - shape为[batch_size, seq_length, seq_length]的解码器的注意力掩码。或者为None，None表示将不会在解码器中的self attention中的Softmax计算中引入掩码计算。
-        - **memory_mask** (Tensor) - shape为[batch, tgt_seq_length,  src_seq_length]的交叉注意力的memory掩码，其中tgt_seq_length表示解码器的长度。或者为None，None表示将不会在cross attention中的Softmax计算中引入掩码计算。
-        - **init_reset** (Tensor) - shape为[1]的bool tensor，用于清除增量预测中使用的past key参数和past value参数。仅当use_past为True时有效。默认值为True。
-        - **batch_valid_length** (Tensor) - shape为[batch_size]的Int32 tensor，表示过去所计算的索引。当use_past为True时，它用于增量预测。默认值为None。
-
-    输出：
-        Tuple，表示包含(`output`, `encoder_layer_present`, `encoder_layer_present`, `accum_loss`)的元组。
-
-        - **output** (Tensor) - 如果只有编码器，则表示编码器层的输出logit。shape为[batch, src_seq_length, hidden_size] or [batch * src_seq_length, hidden_size]。如果有编码器和解码器，则输出来自于解码器层。shape为[batch, tgt_seq_length, hidden_size]或[batch * tgt_seq_length, hidden_size]。
-        - **encoder_layer_present** (Tuple) - 大小为num_layers的元组，其中每个元组都是shape为((batch_size, num_heads, size_per_head, src_seq_length)或(batch_size, num_heads, src_seq_length, size_per_head))的自注意力中的投影key向量和value向量的tensor的元组。
-        - **decoder_layer_present** (Tuple) - 大小为num_layers的元组，其中每个元组都是shape为((batch_size, num_heads, size_per_head, tgt_seq_length)或(batch_size, num_heads, tgt_seq_length, size_per_head))的自注意力中的投影key向量和value向量的tensor的元组，或者是shape为((batch_size, num_heads, size_per_head, src_seq_length)或(batch_size, num_heads, src_seq_length, size_per_head))的交叉注意力中的投影key向量和value向量的tensor的元组。如果未设置解码器，返回值将为None。
-        - **accum_loss** (Tensor) - 表示一个辅助损失来最小化路由到每个专家的数据部分的均方，且仅仅在专家数大于1时才会返回。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.TransformerDecoder.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.TransformerDecoder.rst
@ -1,41 +0,0 @@
-.. py:class:: mindspore.nn.transformer.TransformerDecoder(num_layers, batch_size, hidden_size, ffn_hidden_size, src_seq_length, tgt_seq_length, num_heads, attention_dropout_rate=0.1, hidden_dropout_rate=0.1, post_layernorm_residual=False, layernorm_compute_type=mstype.float32, softmax_compute_type=mstype.float32, param_init_type=mstype.float32, hidden_act="gelu", lambda_func=None, use_past=False, offset=0, moe_config=default_moe_config, parallel_config=default_transformer_config)
-
-    Transformer中的解码器模块，为多层堆叠的 `TransformerDecoderLayer` ，包括多头自注意力层、交叉注意力层和前馈层。
-
-    参数：
-        - **batch_size** (int) - 表示增量预测时输入张量的批量大小，应该是正整数。当进行训练或预测时，该参数将不起作用，用户可将None传递给此参数。
-        - **num_layers** (int) - 表示 `TransformerDecoderLayer` 的层数。
-        - **hidden_size** (int) - 表示输入的隐藏大小。
-        - **ffn_hidden_size** (int) - 表示前馈层中bottleneck的隐藏大小。
-        - **src_seq_length** (int) - 表示输入源序列长度。
-        - **tgt_seq_length** (int) - 表示输入目标序列长度。
-        - **num_heads** (int) - 表示注意力头的数量。
-        - **hidden_dropout_rate** (float) - 表示作用在隐藏层输出的丢弃率。默认值：0.1
-        - **attention_dropout_rate** (float) - 表示注意力score的丢弃率。默认值：0.1
-        - **post_layernorm_residual** (bool) - 表示是否在LayerNorm之前使用残差，即是否选择残差为Post-LayerNorm或者Pre-LayerNorm。默认值：False
-        - **hidden_act** (str, nn.Cell) - 表示前馈层的激活行为。其值可为'relu'、'relu6'、'tanh'、'gelu'、'fast_gelu'、'elu'、'sigmoid'、'prelu'、'leakyrelu'、'hswish'、'hsigmoid'、'logsigmoid'等等。用户可以传入自定义的激活函数。如果用户要想在并行模式下运行此网络，自定义的激活函数必须提供 `activation_shard` 类方法。请查看类 `mindspore.nn.transformer.FeedForward` 的示例。默认值：gelu。
-        - **layernorm_compute_type** (dtype.Number) - 表示LayerNorm的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **use_past** (bool) - 表示是否开启增量推理。在推理中会缓存注意力机制计算结果，避免冗余计算。默认值为False。
-        - **softmax_compute_type** (dtype.Number) - 表示注意力中softmax的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **param_init_type** (dtype.Number) - 表示模块的参数初始化类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **offset** (int) - 表示 `decoder` 的初始层索引偏移值。其用于设置梯度聚合的融合值和流水线并行的stage值，使其不与编码器层的相关属性重叠。默认值为0。
-        - **lambda_func** (function) - 表示确定梯度融合索引、pipeline阶段和重计算属性的函数。如果用户想确定pipeline阶段和梯度聚合融合，用户可以传递一个接受 `network` 、 `layer_id` 、 `offset` 、 `parallel_config` 和 `layers` 的函数。 `network(Cell)` 表示transformer块， `layer_id(int)` 表示当前模块的层索引，从零开始计数， `offset(int)` 表示如果网络中还有其他模块，则layer_index需要一个偏置。pipeline的默认设置为： `(layer_id + offset) // (layers / pipeline_stage)` 。默认值：None。
-        - **moe_config** (MoEConfig) - 表示MoE (Mixture of Expert)的配置。默认值为 `default_moe_config` ，表示带有默认参数的 `MoEConfig` 实例。
-        - **parallel_config** (TransformerOpParallelConfig) - 表示并行配置。默认值为 `default_transformer_config` ，表示带有默认参数的 `TransformerOpParallelConfig` 实例。
-
-    输入：
-        - **hidden_stats** (Tensor) - shape为[batch_size, seq_length, hidden_size]或[batch_size * seq_length, hidden_size]的输入tensor。
-        - **attention_mask** (Tensor) - shape为[batch_size, seq_length, seq_length]的解码器的注意力掩码。或者为None，None表示将不会在self attention中的Softmax计算中引入掩码计算。
-        - **encoder_output** (Tensor) - shape为[batch_size, seq_length, hidden_size]或[batch_size * seq_length, hidden_size]的编码器的输出。
-
-          .. note::当网络位于最外层时，此参数不能通过None传递。默认值为None。
-
-        - **memory_mask** (Tensor) - shape为[batch, tgt_seq_length, src_seq_length]的交叉注意力的memory掩码，其中tgt_seq_length表示解码器的长度。或者为None，None表示将不会在cross attention中的Softmax计算中引入掩码计算。
-        - **init_reset** (Tensor) - shape为[1]的bool tensor，用于清除增量预测中使用的past key参数和past value参数。仅当use_past为True时有效。默认值为True。
-        - **batch_valid_length** (Tensor) - shape为[batch_size]的Int32 tensor，表示过去所计算的索引。当use_past为True时，它用于增量预测。默认值为None。
-
-    输出：
-        Tuple，表示一个包含(`output`, `layer_present`)的元组。
-
-        - **output** (Tensor) - 输出的logit。shape为[batch, tgt_seq_length, hidden_size]或[batch * tgt_seq_length, hidden_size]。
-        - **layer_present** (Tuple) - 大小为层数的元组，其中每个元组都是shape为((batch_size, num_heads, size_per_head, tgt_seq_length)或(batch_size, num_heads, tgt_seq_length, size_per_head)的自注意力中的投影key向量和value向量的tensor的元组，或者是shape为(batch_size, num_heads, size_per_head, src_seq_length)或(batch_size, num_heads, src_seq_length, size_per_head))的交叉注意力中的投影key向量和value向量的tensor的元组。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.TransformerDecoderLayer.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.TransformerDecoderLayer.rst
@ -1,35 +0,0 @@
-.. py:class:: mindspore.nn.transformer.TransformerDecoderLayer(hidden_size, ffn_hidden_size, num_heads, batch_size, src_seq_length, tgt_seq_length, attention_dropout_rate=0.1, hidden_dropout_rate=0.1, post_layernorm_residual=False, use_past=False, layernorm_compute_type=mstype.float32, softmax_compute_type=mstype.float32, param_init_type=mstype.float32, hidden_act="gelu", moe_config=default_moe_config, parallel_config=default_dpmp_config)
-
-    Transformer的解码器层。Transformer的解码器层上的单层的实现，包括自注意力层、交叉注意力层和前馈层。当encoder_output为None时，交叉注意力将无效。
-
-    参数：
-        - **batch_size** (int) - 表示增量预测时输入张量的批量大小，应该是正整数。当进行训练或预测时，该参数将不起作用，用户可将None传递给此参数。
-        - **hidden_size** (int) - 表示输入的隐藏大小。
-        - **src_seq_length** (int) - 表示输入源序列长度。
-        - **tgt_seq_length** (int) - 表示输入目标序列长度。
-        - **ffn_hidden_size** (int) - 表示前馈层中bottleneck的隐藏大小。
-        - **num_heads** (int) - 表示注意力头的数量。
-        - **hidden_dropout_rate** (float) - 表示作用在隐藏层输出的丢弃率。默认值：0.1
-        - **attention_dropout_rate** (float) - 表示注意力score的丢弃率。默认值：0.1
-        - **post_layernorm_residual** (bool) - 表示是否在LayerNorm之前使用残差，即是否选择残差为Post-LayerNorm或者Pre-LayerNorm。默认值：False
-        - **hidden_act** (str, nn.Cell) - 表示前馈层的激活行为。其值可为'relu'、'relu6'、'tanh'、'gelu'、'fast_gelu'、'elu'、'sigmoid'、'prelu'、'leakyrelu'、'hswish'、'hsigmoid'、'logsigmoid'等等。用户可以传入自定义的激活函数。如果用户要想在并行模式下运行此网络，自定义的激活函数必须提供 `activation_shard` 类方法。请查看类 `mindspore.nn.transformer.FeedForward` 的示例。默认值：gelu。
-        - **layernorm_compute_type** (dtype.Number) - 表示LayerNorm的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **softmax_compute_type** (dtype.Number) - 表示注意力中softmax的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **param_init_type** (dtype.Number) - 表示模块的参数初始化类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **use_past** (bool) - 使用过去状态进行计算，用于增量预测。默认值：False。
-        - **moe_config** (MoEConfig) - 表示MoE (Mixture of Expert)的配置。默认值为 `default_moe_config` ，表示带有默认参数的 `MoEConfig` 实例。
-        - **parallel_config** (OpParallelConfig, MoEParallelConfig) - 表示并行配置。默认值为 `default_dpmp_config` ，表示一个带有默认参数的 `OpParallelConfig` 实例。
-
-    输入：
-        - **hidden_stats** (Tensor) - shape为[batch_size, tgt_seq_length, hidden_size]或[batch_size * tgt_seq_length, hidden_size]的输入tensor。
-        - **decoder_mask** (Tensor) - shape为[batch_size, src_seq_length, seq_length]的解码器的注意力掩码。或者为None，None表示将不会在self attention中的Softmax计算中引入掩码计算。
-        - **encoder_output** (Tensor) - shape为[batch_size, seq_length, hidden_size]或[batch_size * seq_length, hidden_size]的编码器的输出。注：当网络位于最外层时，此参数不能通过None传递。默认值为None。
-        - **memory_mask** (Tensor) - shape为[batch, tgt_seq_length, src_seq_length]的交叉注意力的memory掩码，其中tgt_seq_length表示解码器的长度。或者为None，None表示将不会在cross attention中的Softmax计算中引入掩码计算。
-        - **init_reset** (Tensor) - shape为[1]的bool tensor，用于清除增量预测中使用的past key参数和past value参数。仅当use_past为True时有效。默认值为True。
-        - **batch_valid_length** (Tensor) - shape为[batch_size]的Int32 tensor，表示过去所计算的索引。当use_past为True时，它用于增量预测。默认值为None。
-
-    输出：
-        Tuple，表示一个包含(`output`, `layer_present`)的元组。
-
-        - **output** (Tensor) - 此层的输出logit。shape为[batch, seq_length, hidden_size]或[batch * seq_length, hidden_size]。
-        - **layer_present** (Tuple) - 元组，其中每个元组都是shape为((batch_size, num_heads, size_per_head, tgt_seq_length)或(batch_size, num_heads, tgt_seq_length, size_per_head)的自注意力中的投影key向量和value向量的tensor的元组，或者是shape为(batch_size, num_heads, size_per_head, src_seq_length)或(batch_size, num_heads, src_seq_length, size_per_head))的交叉注意力中的投影key向量和value向量的tensor的元组。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.TransformerEncoder.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.TransformerEncoder.rst
@ -1,35 +0,0 @@
-.. py:class:: mindspore.nn.transformer.TransformerEncoder(batch_size, num_layers, hidden_size, ffn_hidden_size, seq_length, num_heads, attention_dropout_rate=0.1, hidden_dropout_rate=0.1, hidden_act="gelu", post_layernorm_residual=False, layernorm_compute_type=mstype.float32, softmax_compute_type=mstype.float32, param_init_type=mstype.float32, lambda_func=None, offset=0, use_past=False, moe_config=default_moe_config, parallel_config=default_transformer_config)
-
-    Transformer中的编码器模块，具有多层堆叠的 `TransformerEncoderLayer` ，包括多头自注意力层和前馈层。
-
-    参数：
-        - **batch_size** (int) - 表示增量预测时输入张量的批量大小，应该是正整数。当进行训练或预测时，该参数将不起作用，用户可将None传递给此参数。
-        - **num_layers** (int) - 表示 `TransformerEncoderLayer` 的层。
-        - **hidden_size** (int) - 表示输入的隐藏大小。
-        - **ffn_hidden_size** (int) - 表示前馈层中bottleneck的隐藏大小。
-        - **seq_length** (int) - 表示输入序列长度。
-        - **num_heads** (int) - 表示注意力头的数量。
-        - **hidden_dropout_rate** (float) - 表示作用在隐藏层输出的丢弃率。默认值：0.1
-        - **attention_dropout_rate** (float) - 表示注意力score的丢弃率。默认值：0.1
-        - **post_layernorm_residual** (bool) - 表示是否在LayerNorm之前使用残差，即是否选择残差为Post-LayerNorm或者Pre-LayerNorm。默认值：False
-        - **hidden_act** (str, nn.Cell) - 表示前馈层的激活行为。其值可为'relu'、'relu6'、'tanh'、'gelu'、'fast_gelu'、'elu'、'sigmoid'、'prelu'、'leakyrelu'、'hswish'、'hsigmoid'、'logsigmoid'等等。用户可以传入自定义的激活函数。如果用户要想在并行模式下运行此网络，自定义的激活函数必须提供 `activation_shard` 类方法。请查看类 `mindspore.nn.transformer.FeedForward` 的示例。默认值：gelu。
-        - **layernorm_compute_type** (dtype.Number) - 表示LayerNorm的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **softmax_compute_type** (dtype.Number) - 表示注意力中softmax的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **param_init_type** (dtype.Number) - 表示模块的参数初始化类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **use_past** (bool) - 使用过去状态进行计算，用于增量预测。例如，如果我们有两个单词，想生成十个或以上单词。我们只需要计算一次这两个单词的状态，然后逐个生成下一个单词。当use_past为True时，有两个步骤可以运行预测。第一步是通过 `model.add_flags_recursive(is_first_iteration=True)` 将is_first_iteration设为True，并传递完整的输入。然后，通过 `model.add_flags_recursive(is_first_iteration=False)` 将is_first_iteration设为False。此时，传递step的输入tensor，并对其进行环回。默认值：False。
-        - **lambda_func** (function) - 表示设置融合索引、pipeline阶段和重计算属性的函数。如果用户想确定pipeline阶段和梯度聚合融合，用户可以传递一个接受 `network` 、 `layer_id` 、 `offset` 、 `parallel_config` 和 `layers` 的函数。 `network(Cell)` 表示transformer块， `layer_id(int)` 表示当前模块的层索引，从零开始计数， `offset(int)` 表示如果网络中还有其他模块，则layer_index需要一个偏置。pipeline的默认设置为： `(layer_id + offset) // (layers / pipeline_stage)` 。默认值：None。
-        - **offset** (int) - 表示 `decoder` 的初始层索引。其用于设置梯度聚合的融合值和流水线并行的stage值。默认值：0。
-        - **moe_config** (MoEConfig) - 表示MoE (Mixture of Expert)的配置。默认值为 `default_moe_config` ，表示带有默认参数的 `MoEConfig` 实例。
-        - **parallel_config** (TransformerOpParallelConfig) - 表示并行配置。默认值为 `default_transformer_config` ，表示带有默认参数的 `TransformerOpParallelConfig` 实例。
-
-    输入：
-        - **hidden_states** (Tensor) - Tensor。如果use_past为False或者is_first_iteration为True，shape为[batch_size, seq_length, hidden_size]或者[batch_size * seq_length, hidden_size]。否则，shape应为[batch_size, 1, hidden_size]。
-        - **attention_mask** (Tensor) - Tensor。use_past为False或者is_first_iteration为True时，表示shape为[batch_size, seq_length, seq_length]的注意力掩码，或者为None，None表示在Softmax计算中将不会进行掩码。否则，shape应为[batch_size, 1, hidden_size]。
-        - **init_reset** (Tensor) - shape为[1]的bool tensor，用于清除增量预测中使用的past key参数和past value参数。仅当use_past为True时有效。默认值为True。
-        - **batch_valid_length** (Tensor) - shape为[batch_size]的Int32 tensor，表示过去所计算的索引。当use_past为True时，它用于增量预测。默认值为None。
-
-    输出：
-        Tuple，表示一个包含(`output`, `layer_present`)的元组。
-
-        - **output** (Tensor) - use_past为False或is_first_iteration为True时，表示shape为(batch_size, seq_length, hidden_size)或(batch_size * seq_length, hidden_size)的层输出的float tensor。否则，shape将为(batch_size, 1, hidden_size)。
-        - **layer_present** (Tuple) - 大小为num_layers的元组，其中每个元组都包含shape为((batch_size, num_heads, size_per_head, seq_length)或(batch_size, num_heads, seq_length, size_per_head))的投影key向量和value向量的Tensor的元组。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.TransformerEncoderLayer.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.TransformerEncoderLayer.rst
@ -1,32 +0,0 @@
-.. py:class:: mindspore.nn.transformer.TransformerEncoderLayer(batch_size, hidden_size, ffn_hidden_size, num_heads, seq_length, attention_dropout_rate=0.1, hidden_dropout_rate=0.1, post_layernorm_residual=False, layernorm_compute_type=mstype.float32, softmax_compute_type=mstype.float32, param_init_type=mstype.float32, hidden_act="gelu", use_past=False, moe_config=default_moe_config, parallel_config=default_dpmp_config)
-
-    Transformer的编码器层。Transformer的编码器层上的单层的实现，包括多头注意力层和前馈层。
-
-    参数：
-        - **batch_size** (int) - 表示增量预测时输入张量的批量大小，应该是正整数。当进行训练或预测时，该参数将不起作用，用户可将None传递给此参数。
-        - **hidden_size** (int) - 表示输入的隐藏大小。
-        - **seq_length** (int) - 表示输入序列长度。
-        - **ffn_hidden_size** (int) - 表示前馈层中bottleneck的隐藏大小。
-        - **num_heads** (int) - 表示注意力头的数量。
-        - **hidden_dropout_rate** (float) - 表示作用在隐藏层输出的丢弃率。默认值：0.1
-        - **attention_dropout_rate** (float) - 表示注意力score的丢弃率。默认值：0.1
-        - **post_layernorm_residual** (bool) - 表示是否在LayerNorm之前使用残差，即是否选择残差为Post-LayerNorm或者Pre-LayerNorm。默认值：False
-        - **hidden_act** (str, nn.Cell) - 表示前馈层的激活行为。其值可为'relu'、'relu6'、'tanh'、'gelu'、'fast_gelu'、'elu'、'sigmoid'、'prelu'、'leakyrelu'、'hswish'、'hsigmoid'、'logsigmoid'等等。用户可以传入自定义的激活函数。如果用户要想在并行模式下运行此网络，自定义的激活函数必须提供 `activation_shard` 类方法。请查看类 `mindspore.nn.transformer.FeedForward` 的示例。默认值：gelu。
-        - **layernorm_compute_type** (dtype.Number) - 表示LayerNorm的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **softmax_compute_type** (dtype.Number) - 表示注意力中softmax的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **param_init_type** (dtype.Number) - 表示模块的参数初始化类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。
-        - **use_past** (bool) - 使用过去状态进行计算，用于增量预测。例如，如果我们有两个单词，想生成十个或以上单词。我们只需要计算一次这两个单词的状态，然后逐个生成下一个单词。当use_past为True时，有两个步骤可以运行预测。第一步是通过 `model.add_flags_recursive(is_first_iteration=True)` 将is_first_iteration设为True，并传递完整的输入。然后，通过 `model.add_flags_recursive(is_first_iteration=False)` 将is_first_iteration设为False。此时，传递step的输入tensor，并对其进行环回。默认值：False
-        - **moe_config** (MoEConfig) - 表示MoE (Mixture of Expert)的配置。默认值为 `default_moe_config` ，表示带有默认参数的 `MoEConfig` 实例。
-        - **parallel_config** (OpParallelConfig, MoEParallelConfig) - 表示并行配置。默认值为 `default_dpmp_config` ，表示一个带有默认参数的 `OpParallelConfig` 实例。
-
-    输入：
-        - **x** (Tensor) - Float Tensor。如果use_past为False或者is_first_iteration为True，shape应为[batch_size, seq_length, hidden_size]或者[batch_size * seq_length, hidden_size]。否则，shape应为[batch_size, 1, hidden_size]。
-        - **input_mask** (Tensor) - Float tensor。use_past为False或者is_first_iteration为True时，表示shape为[batch_size, seq_length, seq_length]的注意力掩码，或者为None，None表示在Softmax计算中将不会进行掩码。否则，shape应为[batch_size, 1, hidden_size]。
-        - **init_reset** (Tensor) - shape为[1]的bool tensor，用于清除增量预测中使用的past key参数和past value参数。仅当use_past为True时有效。默认值为True。
-        - **batch_valid_length** (Tensor) - shape为[batch_size]的Int32 tensor，表示过去所计算的索引。当use_past为True时，它用于增量预测。默认值为None。
-
-    输出：
-        Tuple，表示一个包含(`output`, `layer_present`)的元组。
-
-        - **output** (Tensor) - use_past为False或is_first_iteration为True时，表示shape为(batch_size, seq_length, hidden_size)或(batch_size * seq_length, hidden_size)的层输出的float tensor。否则，shape将为(batch_size, 1, hidden_size)。
-        - **layer_present** (Tuple) - 表示shape为((batch_size, num_heads, size_per_head, seq_length)或(batch_size, num_heads, seq_length, size_per_head))的投影key向量和value向量的Tensor的元组。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.TransformerOpParallelConfig.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.TransformerOpParallelConfig.rst
@ -1,19 +0,0 @@
-.. py:class:: mindspore.nn.transformer.TransformerOpParallelConfig(data_parallel=1, model_parallel=1, expert_parallel=1, pipeline_stage=1, micro_batch_num=1, recompute=default_transformer_recompute_config, optimizer_shard=False, gradient_aggregation_group=4, vocab_emb_dp=True)
-
-    用于设置数据并行、模型并行等等并行配置的TransformerOpParallelConfig。
-
-    .. note::
-        除recompute参数外，当用户未将auto_parallel_context设为 `SEMI_AUTO_PARALLEL` 或 `AUTO_PARALLEL` 时，其他参数将无效。
-        在训练时，micro_batch_num的值必须大于或等于 pipeline_stage的值。data_parallel\*model_parallel  \*pipeline_stage的值必须等于或小于总设备的数量。设置pipeline_stage和optimizer_shard时，其配置将覆盖auto_parallel_context的配置。
-        例如，当给定8张计算卡，并且设置data_parallel为1和model_parallel为1时，模型将会在每张卡上重复计算。
-
-    参数：
-        - **data_parallel** (int) - 表示数据并行数。默认值：1。
-        - **model_parallel** (int) - 表示模型并行数。默认值：1。
-        - **expert_parallel** (int) - 表示专家并行数，只有在应用混合专家结构（MoE，Mixture of Experts）时才会生效。默认值：1。
-        - **pipeline_stage** (int) - 表示将Transformer切分成的stage数目。其值应为正数。默认值：1。
-        - **micro_batch_num** (int) - 表示用于pipeline训练的batch的微型大小。默认值：1。
-        - **optimizer_shard** (bool) - 表示是否使能优化器切分。默认值：False。
-        - **gradient_aggregation_group** (int) - 表示优化器切分的融合组大小。默认值：4。
-        - **recompute** (Union[TransformerRecomputeConfig, bool]) - 表示是否启用transformer每层的的重计算。默认值：一个按默认参数初始化的 `TransformerRecomputeConfig` 实例。
-        - **vocab_emb_dp** (bool) - 表示Embedding表是否为数据并行，否则将在查找表中的第零维度根据模型并行度进行切分。默认值：True。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.TransformerRecomputeConfig.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.TransformerRecomputeConfig.rst
@ -1,9 +0,0 @@
-.. py:class:: mindspore.nn.transformer.TransformerRecomputeConfig(recompute=False, parallel_optimizer_comm_recompute=False, mp_comm_recompute=True, recompute_slice_activation=False)
-
-    Transformer的重计算配置接口。
-
-    参数：
-        - **recompute** (bool) - 是否使能重计算。默认值为False。
-        - **parallel_optimizer_comm_recompute** (bool) - 指定由优化器切分产生的AllGather算子是否进行重计算。默认值为False。
-        - **mp_comm_recompute** (bool) - 指定由模型并行成分产生的通信算子是否进行重计算。默认值为True。
-        - **recompute_slice_activation** (bool) - 指定激活层是否切片保存。默认值为False。
--- a/docs/api/api_python/transformer/mindspore.nn.transformer.VocabEmbedding.rst
+++ b/docs/api/api_python/transformer/mindspore.nn.transformer.VocabEmbedding.rst
@ -1,27 +0,0 @@
-.. py:class:: mindspore.nn.transformer.VocabEmbedding(vocab_size, embedding_size, parallel_config=default_embedding_parallel_config, param_init="normal")
-
-    根据输入的索引查找参数表中的行作为返回值。当设置并行模式为 `AUTO_PARALLEL_MODE` 时，如果parallel_config.vocab_emb_dp为True时，那么embedding lookup表采用数据并行的方式，数据并行度为 `parallel_config.data_parallel` ，如果为False，按 `parallel_config.model_parallel` 对embedding表中的第零维度进行切分。
-
-    .. note::
-        启用 `AUTO_PARALLEL` / `SEMI_AUTO_PARALLEL` 模式时，此层仅支持二维度的输入，因为策略是为2D输入而配置的。
-
-    参数：
-        - **vocab_size** (int) - 表示查找表的大小。
-        - **embedding_size** (int) - 表示查找表中每个嵌入向量的大小。
-        - **param_init** (Union[Tensor, str, Initializer, numbers.Number]) - 表示embedding_table的Initializer。当指定字符串时，请参见 `initializer` 类了解字符串的值。默认值：'normal'。
-        - **parallel_config** (EmbeddingOpParallelConfig) - 表示网络的并行配置。默认值为 `default_embedding_parallel_config` ，表示带有默认参数的 `EmbeddingOpParallelConfig` 实例。
-
-    输入：
-        - **input_ids** (Tensor) - shape为(batch_size, seq_length)的输入，其数据类型为int32。
-
-    输出：
-        Tuple，表示一个包含(`output`, `embedding_table`)的元组。
-
-        - **output** (Tensor) - shape为(batch_size, seq_length, embedding_size)嵌入向量查找结果。
-        - **embedding_table** (Tensor) - shape为(vocab_size, embedding_size)的嵌入表。
-
-    异常：
-        - **ValueError** - parallel_config.vocab_emb_dp为True时，词典的大小不是parallel_config.model_parallel的倍数。
-        - **ValueError** - `vocab_size` 不是正值。
-        - **ValueError** - `embedding_size` 不是正值。
-        - **TypeError** - `parallel_config` 不是OpParallelConfig的子类。
--- a/mindspore/python/mindspore/nn/init.py
+++ b/mindspore/python/mindspore/nn/init.py
@ -31,9 +31,6 @@ from mindspore.nn.wrap import *
 from mindspore.nn.grad import Jvp, Vjp
 from mindspore.nn.sparse import *
 from mindspore.nn.reinforcement import *
-from mindspore.nn.transformer import AttentionMask, VocabEmbedding, MultiHeadAttention, FeedForward, \
-    TransformerEncoder, TransformerDecoder, TransformerEncoderLayer, TransformerDecoderLayer, Transformer,\
-    TransformerOpParallelConfig, EmbeddingOpParallelConfig, TransformerRecomputeConfig, MoEConfig, OpParallelConfig

 __all__ = ["Cell", "GraphCell"]
 __all__.extend(layer.__all__)
@ -46,6 +43,5 @@ __all__.extend(sparse.__all__)
 __all__.extend(learning_rate_schedule.__all__)
 __all__.extend(dynamic_lr.__all__)
 __all__.extend(reinforcement.__all__)
-__all__.extend(transformer.__all__)

 __all__.sort()
--- a/mindspore/python/mindspore/parallel/_transformer/OWNERS
+++ b/mindspore/python/mindspore/parallel/_transformer/OWNERS
--- a/mindspore/python/mindspore/parallel/_transformer/init.py
+++ b/mindspore/python/mindspore/parallel/_transformer/init.py
@ -19,13 +19,13 @@ NOTE:
 """
 from __future__ import absolute_import

-from mindspore.nn.transformer.transformer import AttentionMask, VocabEmbedding, MultiHeadAttention, \
+from mindspore.parallel._transformer.transformer import AttentionMask, VocabEmbedding, MultiHeadAttention, \
    FeedForward, TransformerEncoder, TransformerDecoder, TransformerEncoderLayer, TransformerDecoderLayer, \
    Transformer, TransformerOpParallelConfig, EmbeddingOpParallelConfig, TransformerRecomputeConfig
-from mindspore.nn.transformer.moe import MoEConfig
-from mindspore.nn.transformer.layers import FixedSparseAttention
-from mindspore.nn.transformer.loss import CrossEntropyLoss
-from mindspore.nn.transformer.op_parallel_config import OpParallelConfig
+from mindspore.parallel._transformer.moe import MoEConfig
+from mindspore.parallel._transformer.layers import FixedSparseAttention
+from mindspore.parallel._transformer.loss import CrossEntropyLoss
+from mindspore.parallel._transformer.op_parallel_config import OpParallelConfig

 __all__ = []
 __all__.extend(transformer.__all__)
--- a/mindspore/python/mindspore/parallel/_transformer/layers.py
+++ b/mindspore/python/mindspore/parallel/_transformer/layers.py
@ -37,7 +37,7 @@ from mindspore._checkparam import Validator
 from mindspore.ops.primitive import constexpr
 from mindspore.parallel._utils import _get_parallel_mode, _is_sharding_propagation
 from mindspore.context import ParallelMode
-from mindspore.nn.transformer.op_parallel_config import default_dpmp_config, OpParallelConfig, MoEParallelConfig
+from mindspore.parallel._transformer.op_parallel_config import default_dpmp_config, OpParallelConfig, MoEParallelConfig
 from mindspore import log as logger

 __all__ = [
--- a/mindspore/python/mindspore/parallel/_transformer/loss.py
+++ b/mindspore/python/mindspore/parallel/_transformer/loss.py
@ -30,8 +30,8 @@ from mindspore.context import ParallelMode
 from mindspore.parallel._utils import _get_device_num, _get_pipeline_stages
 from mindspore.log import _LogActionOnce
 from mindspore import log as logger
-from mindspore.nn.transformer.layers import _check_input_dtype
-from mindspore.nn.transformer.op_parallel_config import default_dpmp_config, OpParallelConfig
+from mindspore.parallel._transformer.layers import _check_input_dtype
+from mindspore.parallel._transformer.op_parallel_config import default_dpmp_config, OpParallelConfig

 __all__ = ["CrossEntropyLoss"]

--- a/mindspore/python/mindspore/parallel/_transformer/moe.py
+++ b/mindspore/python/mindspore/parallel/_transformer/moe.py
@ -31,7 +31,7 @@ from mindspore.nn.cell import Cell
 from mindspore.nn.layer import Dense
 from mindspore.context import ParallelMode
 from mindspore.parallel._utils import _get_parallel_mode, _is_sharding_propagation
-from mindspore.nn.transformer.op_parallel_config import default_moeparallel_config
+from mindspore.parallel._transformer.op_parallel_config import default_moeparallel_config

 __all__ = [
    "MoEConfig"]
@ -188,7 +188,7 @@ class MoE(Cell):
            self.group_wise_a2a = moe_config.group_wise_a2a
            if not (self.mp > 1 and self.dp == self.ep):
                self.group_wise_a2a = False
-            from mindspore.nn.transformer import FeedForward
+            from mindspore.parallel._transformer import FeedForward

            self.ffn = FeedForward(hidden_size=hidden_size,
                                   ffn_hidden_size=ffn_hidden_size,
@ -233,7 +233,7 @@ class MoE(Cell):
            self.group_wise_a2a = moe_config.group_wise_a2a
            if not (self.mp > 1 and self.dp == self.ep):
                self.group_wise_a2a = False
-            from mindspore.nn.transformer import FeedForward
+            from mindspore.parallel._transformer import FeedForward

            self.ffn = FeedForward(hidden_size=hidden_size,
                                   ffn_hidden_size=ffn_hidden_size,
--- a/mindspore/python/mindspore/parallel/_transformer/op_parallel_config.py
+++ b/mindspore/python/mindspore/parallel/_transformer/op_parallel_config.py
--- a/mindspore/python/mindspore/parallel/_transformer/transformer.py
+++ b/mindspore/python/mindspore/parallel/_transformer/transformer.py
@ -35,12 +35,12 @@ from mindspore import log as logger
 from mindspore.parallel._utils import _get_parallel_mode, _is_sharding_propagation
 from mindspore.context import ParallelMode
 from mindspore.log import _LogActionOnce
-from mindspore.nn.transformer.layers import _LayerNorm, _Linear, \
+from mindspore.parallel._transformer.layers import _LayerNorm, _Linear, \
    _args_type_validator_check, _valid_type_checks, _valid_value_checks, \
    _check_past_none_input_none, _check_input_dtype
-from mindspore.nn.transformer.op_parallel_config import default_dpmp_config, _PipeLineConfig, OpParallelConfig, \
+from mindspore.parallel._transformer.op_parallel_config import default_dpmp_config, _PipeLineConfig, OpParallelConfig, \
    _Config, _check_config, MoEParallelConfig
-from mindspore.nn.transformer.moe import default_moe_config, MoE, _check_moe_config
+from mindspore.parallel._transformer.moe import default_moe_config, MoE, _check_moe_config

 __all__ = [
    "AttentionMask",
--- a/mindspore/python/mindspore/parallel/nn/init.py
+++ b/mindspore/python/mindspore/parallel/nn/init.py
@ -1,42 +0,0 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-NOTE:
-    Transformer Networks.
-    This is an experimental interface that is subject to change or deletion.
-    The import path of Transformer APIs have been modified from `mindspore.parallel.nn` to `mindspore.nn.transformer`,
-    while the usage of these APIs stay unchanged. The original import path will retain one or two versions.
-    You can view the changes using the examples described below:
-
-    # r1.5
-    from mindspore.parallel.nn import Transformer
-
-    # Current
-    from mindspore.nn.transformer import Transformer
-"""
-from __future__ import absolute_import
-from mindspore import log
-from mindspore.nn.transformer import AttentionMask, VocabEmbedding, MultiHeadAttention, FeedForward, \
-    TransformerEncoder, TransformerDecoder, TransformerEncoderLayer, TransformerDecoderLayer, Transformer, \
-    TransformerOpParallelConfig, \
-    EmbeddingOpParallelConfig, TransformerRecomputeConfig, MoEConfig, FixedSparseAttention, CrossEntropyLoss, \
-    OpParallelConfig
-
-__all__ = ["AttentionMask", "VocabEmbedding", "MultiHeadAttention", "FeedForward", "TransformerEncoder",
-           "TransformerDecoder", "TransformerEncoderLayer", "TransformerDecoderLayer", "Transformer",
-           "TransformerOpParallelConfig", "EmbeddingOpParallelConfig", "TransformerRecomputeConfig", "MoEConfig",
-           "FixedSparseAttention", "CrossEntropyLoss", "OpParallelConfig"]
-
-log.warning("'mindspore.parallel.nn' will be deprecated in the future. Please use 'mindspore.nn.transformer' instead.")
--- a/mindspore/python/mindspore/parallel/nn/layers.py
+++ b/mindspore/python/mindspore/parallel/nn/layers.py
@ -1,22 +0,0 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-The basic layer of the Transformer Networks. This is an experimental interface that is subject to
-change or deletion.
-"""
-from __future__ import absolute_import
-from mindspore.nn.transformer.layers import FixedSparseAttention
-
-__all__ = ["FixedSparseAttention"]
--- a/mindspore/python/mindspore/parallel/nn/loss.py
+++ b/mindspore/python/mindspore/parallel/nn/loss.py
@ -1,22 +0,0 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-Parallel Loss for the Parallel Training
-This is an experimental interface that is subject to change or deletion.
-"""
-from __future__ import absolute_import
-from mindspore.nn.transformer.loss import CrossEntropyLoss
-
-__all__ = ["CrossEntropyLoss"]
--- a/mindspore/python/mindspore/parallel/nn/moe.py
+++ b/mindspore/python/mindspore/parallel/nn/moe.py
@ -1,21 +0,0 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-Note: Mixture of Expert (MoE) structure. This is an experimental interface that is subject to change or deletion.
-"""
-from __future__ import absolute_import
-from mindspore.nn.transformer.moe import MoEConfig, default_moe_config
-
-__all__ = ["MoEConfig", "default_moe_config"]
--- a/mindspore/python/mindspore/parallel/nn/op_parallel_config.py
+++ b/mindspore/python/mindspore/parallel/nn/op_parallel_config.py
@ -1,22 +0,0 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-Parallel Config for the Parallel Training
-This is an experimental interface that is subject to change and/or deletion.
-"""
-from __future__ import absolute_import
-from mindspore.nn.transformer.op_parallel_config import OpParallelConfig, default_dpmp_config
-
-__all__ = ["OpParallelConfig", "default_dpmp_config"]
--- a/mindspore/python/mindspore/parallel/nn/transformer.py
+++ b/mindspore/python/mindspore/parallel/nn/transformer.py
@ -1,31 +0,0 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-Note:
-    Transformer Networks. This is interface that is subject to change or deletion.
-"""
-from __future__ import absolute_import
-from mindspore.nn.transformer.transformer import AttentionMask, VocabEmbedding, MultiHeadAttention, FeedForward, \
-    TransformerEncoder, TransformerDecoder, TransformerEncoderLayer, TransformerDecoderLayer, Transformer, \
-    TransformerOpParallelConfig, \
-    EmbeddingOpParallelConfig, TransformerRecomputeConfig, \
-    default_transformer_config, default_embedding_parallel_config, default_dpmp_config, default_moe_config, \
-    default_transformer_recompute_config
-
-__all__ = ["AttentionMask", "VocabEmbedding", "MultiHeadAttention", "FeedForward", "TransformerEncoder",
-           "TransformerDecoder", "TransformerEncoderLayer", "TransformerDecoderLayer", "Transformer",
-           "TransformerOpParallelConfig", "EmbeddingOpParallelConfig", "TransformerRecomputeConfig",
-           "default_transformer_config", "default_embedding_parallel_config", "default_dpmp_config",
-           "default_moe_config", "default_transformer_recompute_config"]
--- a/tests/st/ops/test_constexpr_modfied.py
+++ b/tests/st/ops/test_constexpr_modfied.py
@ -223,7 +223,7 @@ def test_calculate_expert_capacity():
    Description: Verify the result of calculate_expert_capacity
    Expectation: success
    """
-    from mindspore.nn.transformer.moe import calculate_expert_capacity
+    from mindspore.parallel._transformer.moe import calculate_expert_capacity

    class Net(nn.Cell):
        def __init__(self):
--- a/tests/ut/python/nn/test_transformer.py
+++ b/tests/ut/python/nn/test_transformer.py
@ -22,7 +22,7 @@ import mindspore
 from mindspore import Tensor
 from mindspore.common import dtype
 from mindspore.ops import operations as ops
-from mindspore.parallel.nn import MultiHeadAttention, FeedForward, TransformerEncoderLayer, TransformerEncoder, \
+from mindspore.parallel._transformer import MultiHeadAttention, FeedForward, TransformerEncoderLayer, TransformerEncoder, \
    TransformerDecoder, TransformerDecoderLayer, Transformer, CrossEntropyLoss, AttentionMask, FixedSparseAttention
 from mindspore.common.api import _cell_graph_executor

--- a/tests/ut/python/parallel/test_parallel_config.py
+++ b/tests/ut/python/parallel/test_parallel_config.py
@ -19,7 +19,7 @@ from mindspore import Tensor
 from mindspore.context import set_auto_parallel_context, ParallelMode
 from mindspore import context
 from mindspore.ops import composite as C
-from mindspore.parallel.nn import Transformer
+from mindspore.parallel._transformer import Transformer
 from mindspore.nn.optim import AdamWeightDecay
 from mindspore.nn.wrap.cell_wrapper import TrainOneStepCell
 from mindspore.train import Model
--- a/tests/ut/python/parallel/test_parallel_moe.py
+++ b/tests/ut/python/parallel/test_parallel_moe.py
@ -21,7 +21,7 @@ from mindspore import Tensor
 from mindspore.context import set_auto_parallel_context, ParallelMode
 from mindspore.ops import composite as C
 from mindspore.ops import functional as F
-from mindspore.parallel.nn import Transformer, TransformerOpParallelConfig, MoEConfig, CrossEntropyLoss
+from mindspore.parallel._transformer import Transformer, TransformerOpParallelConfig, MoEConfig, CrossEntropyLoss
 from mindspore.parallel import set_algo_parameters
 from mindspore.nn.optim import AdamWeightDecay
 from mindspore.nn.wrap.cell_wrapper import TrainOneStepCell, _VirtualDatasetCell
--- a/tests/ut/python/parallel/test_parallel_transformer.py
+++ b/tests/ut/python/parallel/test_parallel_transformer.py
@ -24,7 +24,7 @@ from mindspore import context
 from mindspore.ops import composite as C
 from mindspore.ops import functional as F
 import mindspore.ops as P
-from mindspore.parallel.nn import TransformerEncoder, TransformerDecoder, Transformer, TransformerOpParallelConfig, \
+from mindspore.parallel._transformer import TransformerEncoder, TransformerDecoder, Transformer, TransformerOpParallelConfig, \
    VocabEmbedding, CrossEntropyLoss, OpParallelConfig, EmbeddingOpParallelConfig, FixedSparseAttention,\
    TransformerRecomputeConfig
 from mindspore.nn.wrap.loss_scale import DynamicLossScaleUpdateCell
--- a/tests/ut/python/parallel/test_pipeline_parallel_transformer.py
+++ b/tests/ut/python/parallel/test_pipeline_parallel_transformer.py
@ -18,7 +18,7 @@ import mindspore.nn as nn
 from mindspore import Tensor
 from mindspore import context
 from mindspore.context import _Context
-from mindspore.parallel.nn import TransformerOpParallelConfig
+from mindspore.parallel._transformer import TransformerOpParallelConfig
 from mindspore.nn.wrap.cell_wrapper import PipelineCell, MicroBatchInterleaved
 from mindspore.train import Model
 from tests.ut.python.parallel.test_parallel_transformer import TransformerEncoderNet