mindspore 2.0.0a0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/nn/layer/channel_shuffle.py

@@ -13,21 +13,21 @@
 # limitations under the License.
 # ============================================================================
 """channel shuffle"""
-from mindspore.ops.primitive import constexpr
 from mindspore.ops import operations as P
 from mindspore.nn.cell import Cell
+from mindspore.ops.primitive import _primexpr
 
 __all__ = ['ChannelShuffle']
 
 
 class ChannelShuffle(Cell):
     r"""
-    Divide the channels in a tensor of shape :math:`(*, C , H, W)`
-    into g groups and rearrange them as :math:`(*, C \frac g, g, H, W)`,
-    while keeping the original tensor shape.
+    Divide the channels of Tensor whose shape is :math:`(*, C, H, W)` into :math:`g` groups to obtain a Tensor with
+    shape :math:`(*, C \frac g, g, H, W)`, and transpose along the corresponding axis of :math:`C`,
+    :math:`\frac{g}{}` and :math:`g` to restore Tensor to the original shape.
 
     Args:
-        groups (int): Number of groups to divide channels in. Refer to :math:`g`.
+        groups (int): Number of groups to divide channels in, must be greater than 0. Refer to :math:`g`.
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(*, C_{in}, H_{in}, W_{in})`.
@@ -83,8 +83,9 @@ class ChannelShuffle(Cell):
         self.transpose = P.Transpose()
 
     @staticmethod
-    @constexpr
+    @_primexpr
     def _check_input_dim(shape, channels, groups, cls_name):
+        """check input dim"""
         dim = len(shape)
         if dim < 3:
             raise ValueError(f"For {cls_name}, the in_shape must have more than 2 dims, but got {dim}.")

mindspore/nn/layer/combined.py

@@ -17,7 +17,7 @@ from __future__ import absolute_import
 
 from mindspore import nn
 from mindspore.ops.primitive import Primitive
-from mindspore._checkparam import Validator
+import mindspore._checkparam as Validator
 from mindspore.nn.layer.normalization import BatchNorm2d, BatchNorm1d
 from mindspore.nn.layer.activation import get_activation, LeakyReLU
 from mindspore.nn.cell import Cell

mindspore/nn/layer/container.py

@@ -109,7 +109,7 @@ class _CellListBase:
 class SequentialCell(Cell):
     """
     Sequential Cell container. For more details about Cell, please refer to
-    `Cell <https://www.mindspore.cn/docs/en/r2.0.0-alpha/api_python/nn/mindspore.nn.Cell.html#mindspore.nn.Cell>`_.
+    `Cell <https://www.mindspore.cn/docs/en/r2.0/api_python/nn/mindspore.nn.Cell.html#mindspore.nn.Cell>`_.
 
     A list of Cells will be added to it in the order they are passed in the constructor.
     Alternatively, an ordered dict of cells can also be passed in.
@@ -168,7 +168,12 @@ class SequentialCell(Cell):
         self._is_dynamic_name = []
         if len(args) == 1:
             cells = args[0]
-            if isinstance(cells, list):
+            if isinstance(cells, Cell):
+                cell = cells
+                self.insert_child_to_cell(str(0), cell)
+                cell.update_parameters_name(str(0) + ".")
+                self._is_dynamic_name.append(True)
+            elif isinstance(cells, list):
                 for index, cell in enumerate(cells):
                     self.insert_child_to_cell(str(index), cell)
                     cell.update_parameters_name(str(index) + ".")
@@ -179,7 +184,7 @@ class SequentialCell(Cell):
                     cell.update_parameters_name(name + ".")
                     self._is_dynamic_name.append(False)
             else:
-                raise TypeError(f"For '{self.__class__.__name__}', the 'args[0]' must be list or orderedDict, "
+                raise TypeError(f"For '{self.__class__.__name__}', the 'args[0]' must be Cell, list or orderedDict, "
                                 f"but got {type(cells).__name__}")
         else:
             for index, cell in enumerate(args):
@@ -233,6 +238,9 @@ class SequentialCell(Cell):
         self._cells = temp_dict
         self.cell_list = list(self._cells.values())
 
+    def __bool__(self):
+        return len(self._cells) != 0
+
     def __len__(self):
         return len(self._cells)
 
@@ -279,11 +287,37 @@ class SequentialCell(Cell):
             input_data = cell(input_data)
         return input_data
 
+    def _insert(self, index, cell):
+        """
+        Inserts a given Cell before a given index in the list.
+
+        Args:
+            index(int): The Insert index in the CellList.
+            cell(Cell): The Cell to be inserted.
+        """
+        cls_name = self.__class__.__name__
+        idx = _valid_index(len(self), index, cls_name)
+        _valid_cell(cell, cls_name)
+        length = len(self)
+        prefix, key_index = _get_prefix_and_index(self._cells)
+        while length > idx:
+            if self._auto_prefix:
+                tmp_cell = self._cells[str(length-1)]
+                for _, param in tmp_cell.parameters_and_names():
+                    param.name = f'{prefix}{str(length)}{"."}{".".join(param.name.split(".")[key_index+1:])}'
+            self._cells[str(length)] = self._cells[str(length - 1)]
+            length -= 1
+        self._cells[str(idx)] = cell
+        if self._auto_prefix:
+            cell.update_parameters_name(prefix + str(idx) + ".")
+        self.cell_list = list(self._cells.values())
+        self._is_dynamic_name.insert(index, True)
+
 
 class CellList(_CellListBase, Cell):
     """
     Holds Cells in a list. For more details about Cell, please refer to
-    `Cell <https://www.mindspore.cn/docs/en/r2.0.0-alpha/api_python/nn/mindspore.nn.Cell.html#mindspore.nn.Cell>`_.
+    `Cell <https://www.mindspore.cn/docs/en/r2.0/api_python/nn/mindspore.nn.Cell.html#mindspore.nn.Cell>`_.
 
     CellList can be used like a regular Python list, the Cells it contains have been initialized. Unlike the
     SequentialCell, the cells in CellList are not connected.
@@ -364,6 +398,9 @@ class CellList(_CellListBase, Cell):
             temp_dict[str(idx)] = cell
         self._cells = temp_dict
 
+    def __bool__(self):
+        return len(self._cells) != 0
+
     def __len__(self):
         return len(self._cells)
 

mindspore/nn/layer/conv.py

@@ -20,11 +20,12 @@ import numpy as np
 from mindspore import log as logger
 from mindspore import context
 from mindspore.ops import operations as P
-from mindspore.ops.primitive import constexpr
+from mindspore.ops.primitive import _primexpr
 from mindspore.common.parameter import Parameter
 from mindspore.common.initializer import initializer
 from mindspore.common.tensor import Tensor
-from mindspore._checkparam import Validator, Rel, twice, _check_3d_int_or_tuple
+from mindspore import _checkparam as Validator
+from mindspore._checkparam import twice, _check_3d_int_or_tuple
 from mindspore._extends import cell_attr_register
 from mindspore.nn.cell import Cell
 
@@ -142,7 +143,7 @@ class Conv2d(_Conv):
         \sum_{k = 0}^{C_{in} - 1} \text{ccor}({\text{weight}(C_{\text{out}_j}, k), \text{X}(N_i, k)})
 
     where :math:`ccor` is the `cross-correlation <https://en.wikipedia.org/wiki/Cross-correlation>`_,
-    :math:`C_{in}` is the channel number of the input, :math:`out_{j}` corresponds to the jth channel of
+    :math:`C_{in}` is the channel number of the input, :math:`out_{j}` corresponds to the :math:`j`-th channel of
     the output and :math:`j` is in the range of :math:`[0, C_{out}-1]`. :math:`\text{weight}(C_{\text{out}_j}, k)`
     is a convolution kernel slice with shape :math:`(\text{kernel_size[0]}, \text{kernel_size[1]})`,
     where :math:`\text{kernel_size[0]}` and :math:`\text{kernel_size[1]}` are the height and width of the convolution
@@ -220,17 +221,17 @@ class Conv2d(_Conv):
 
         .. math::
             \begin{array}{ll} \\
-                H_{out} ＝ \left \lceil{\frac{H_{in}}{\text{stride[0]}}} \right \rceil \\
-                W_{out} ＝ \left \lceil{\frac{W_{in}}{\text{stride[1]}}} \right \rceil \\
+                H_{out} = \left \lceil{\frac{H_{in}}{\text{stride[0]}}} \right \rceil \\
+                W_{out} = \left \lceil{\frac{W_{in}}{\text{stride[1]}}} \right \rceil \\
             \end{array}
 
         pad_mode is 'valid':
 
         .. math::
             \begin{array}{ll} \\
-                H_{out} ＝ \left \lceil{\frac{H_{in} - \text{dilation[0]} \times (\text{kernel_size[0]} - 1) }
+                H_{out} = \left \lceil{\frac{H_{in} - \text{dilation[0]} \times (\text{kernel_size[0]} - 1) }
                 {\text{stride[0]}}} \right \rceil \\
-                W_{out} ＝ \left \lceil{\frac{W_{in} - \text{dilation[1]} \times (\text{kernel_size[1]} - 1) }
+                W_{out} = \left \lceil{\frac{W_{in} - \text{dilation[1]} \times (\text{kernel_size[1]} - 1) }
                 {\text{stride[1]}}} \right \rceil \\
             \end{array}
 
@@ -238,9 +239,9 @@ class Conv2d(_Conv):
 
         .. math::
             \begin{array}{ll} \\
-                H_{out} ＝ \left \lfloor{\frac{H_{in} + padding[0] + padding[1] - (\text{kernel_size[0]} - 1) \times
+                H_{out} = \left \lfloor{\frac{H_{in} + padding[0] + padding[1] - (\text{kernel_size[0]} - 1) \times
                 \text{dilation[0]} - 1 }{\text{stride[0]}} + 1} \right \rfloor \\
-                W_{out} ＝ \left \lfloor{\frac{W_{in} + padding[2] + padding[3] - (\text{kernel_size[1]} - 1) \times
+                W_{out} = \left \lfloor{\frac{W_{in} + padding[2] + padding[3] - (\text{kernel_size[1]} - 1) \times
                 \text{dilation[1]} - 1 }{\text{stride[1]}} + 1} \right \rfloor \\
             \end{array}
 
@@ -315,7 +316,7 @@ class Conv2d(_Conv):
         return output
 
 
-@constexpr
+@_primexpr
 def _check_input_3d(input_shape, op_name):
     if len(input_shape) != 3:
         raise ValueError(f"For '{op_name}', the dimension of input must be 3d, but got {len(input_shape)}.")
@@ -333,7 +334,7 @@ class Conv1d(_Conv):
         \sum_{k = 0}^{C_{in} - 1} \text{ccor}({\text{weight}(C_{\text{out}_j}, k), \text{X}(N_i, k)})
 
     where :math:`ccor` is the `cross-correlation <https://en.wikipedia.org/wiki/Cross-correlation>`_,
-    :math:`C_{in}` is the channel number of the input, :math:`out_{j}` corresponds to the jth channel of
+    :math:`C_{in}` is the channel number of the input, :math:`out_{j}` corresponds to the :math:`j`-th channel of
     the output and :math:`j` is in the range of :math:`[0, C_{out}-1]`. :math:`\text{weight}(C_{\text{out}_j}, k)`
     is a convolution kernel slice with shape :math:`\text{kernel_size}`, where :math:`\text{kernel_size}`
     is the width of the convolution kernel. :math:`\text{bias}` is the bias parameter,
@@ -440,10 +441,10 @@ class Conv1d(_Conv):
         Validator.check_value_type("stride", stride, [int], self.cls_name)
         Validator.check_value_type("padding", padding, [int], self.cls_name)
         Validator.check_value_type("dilation", dilation, [int], self.cls_name)
-        Validator.check_int(kernel_size, 1, Rel.GE, 'kernel_size', self.cls_name)
-        Validator.check_int(stride, 1, Rel.GE, 'stride', self.cls_name)
+        Validator.check_int(kernel_size, 1, Validator.GE, 'kernel_size', self.cls_name)
+        Validator.check_int(stride, 1, Validator.GE, 'stride', self.cls_name)
         Validator.check_non_negative_int(padding, 'padding', self.cls_name)
-        Validator.check_int(dilation, 1, Rel.GE, 'dilation', self.cls_name)
+        Validator.check_int(dilation, 1, Validator.GE, 'dilation', self.cls_name)
         kernel_size = (1, kernel_size)
         stride = (1, stride)
         dilation = (1, dilation)
@@ -496,7 +497,7 @@ class Conv1d(_Conv):
         return output
 
 
-@constexpr
+@_primexpr
 def _check_input_5dims(input_shape, op_name):
     if len(input_shape) != 5:
         raise ValueError(f"For '{op_name}', the dimension of input must be 5d, but got {len(input_shape)}.")
@@ -516,8 +517,8 @@ class Conv3d(_Conv):
         \sum_{k = 0}^{C_{in} - 1} \text{ccor}({\text{weight}(C_{\text{out}_j}, k), \text{X}(N_i, k)})
 
     where :math:`ccor` is the `cross-correlation <https://en.wikipedia.org/wiki/Cross-correlation>`_,
-    :math:`C_{in}` is the channel number of the input, :math:`out_{j}` corresponds to the jth channel of
-    the output and :math:`j` is in the range of :math:`[0，C_{out}-1]`. :math:`\text{weight}(C_{\text{out}_j}, k)`
+    :math:`C_{in}` is the channel number of the input, :math:`out_{j}` corresponds to the :math:`j`-th channel of
+    the output and :math:`j` is in the range of :math:`[0, C_{out}-1]`. :math:`\text{weight}(C_{\text{out}_j}, k)`
     is a convolution kernel slice with shape
     :math:`(\text{kernel_size[0]}, \text{kernel_size[1]}, \text{kernel_size[2]})`,
     where :math:`\text{kernel_size[0]}`, :math:`\text{kernel_size[1]}` and :math:`\text{kernel_size[2]}` are
@@ -724,7 +725,8 @@ class Conv3dTranspose(_Conv):
     Calculates a 3D transposed convolution, which can be regarded as Conv3d for the gradient of the input.
     It also called deconvolution (although it is not an actual deconvolution).
 
-    The input is typically of shape :math:`(N, C, D, H, W)`, where :math:`N` is batch size, :math:`C` is a number of
+    he input is typically of shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`,
+    where :math:`N` is batch size, :math:`C_{in}` is a number of
     channels, :math:`D_{in}, H_{in}, W_{in}` are the depth, height and width of the feature layer respectively.
 
     When Conv3d and Conv3dTranspose are initialized with the same parameters, and `pad_mode` is set to 'pad',
@@ -973,6 +975,12 @@ class Conv2dTranspose(_Conv):
             If `padding` is a tuple of 4 integers, then the top, bottom, left, and right padding
             is equal to `padding[0]`, `padding[1]`, `padding[2]`, and `padding[3]` respectively.
             The value should be greater than or equal to 0. Default: 0.
+        output_padding (Union[int, tuple[int]]): The number of padding on the height and width directions of the output.
+            The data type is an integer or a tuple of two integers. If `output_padding` is an integer,
+            then the bottom and right padding are all equal to `output_padding`. If `output_padding` is a tuple of
+            2 integers, then the bottom and right padding is equal to `output_padding[0]`, `output_padding[1]`
+            respectively. If `output_padding` is not equal to 0, `pad_mode` must be `pad`.
+            The value should be in range of `[0, max(stride, dilation))` . Default: 0.
         dilation (Union[int, tuple[int]]): Dilation size of 2D convolution kernel.
             The data type is an integer or a tuple of two integers. If :math:`k > 1`, the kernel is sampled
             every `k` elements. The value of `k` on the height and width directions is in range of [1, H]
@@ -1020,10 +1028,10 @@ class Conv2dTranspose(_Conv):
             \begin{array}{ll} \\
                 H_{out} = \text H_{in}\times \text {stride[0]} - (padding[0] + padding[1])
                 + \text{kernel_size[0]} + (\text{dilation[0]} - 1) \times
-                (\text{kernel_size[0]} - 1) - \text {stride[0]} \\
+                (\text{kernel_size[0]} - 1) - \text {stride[0]} + \text {output_padding[0]} \\
                 W_{out} = \text W_{in}\times \text {stride[1]} - (padding[2] + padding[3])
                 + \text{kernel_size[1]} + (\text{dilation[1]} - 1) \times
-                (\text{kernel_size[1]} - 1) - \text {stride[1]} \\
+                (\text{kernel_size[1]} - 1) - \text {stride[1]} + \text {output_padding[1]} \\
             \end{array}
 
     Raises:
@@ -1053,6 +1061,7 @@ class Conv2dTranspose(_Conv):
                  stride=1,
                  pad_mode='same',
                  padding=0,
+                 output_padding=0,
                  dilation=1,
                  group=1,
                  has_bias=False,
@@ -1065,6 +1074,9 @@ class Conv2dTranspose(_Conv):
         Validator.check_value_type('padding', padding, (int, tuple), self.cls_name)
         if isinstance(padding, tuple):
             Validator.check_equal_int(len(padding), 4, 'padding size', self.cls_name)
+        Validator.check_value_type('output_padding', output_padding, (int, tuple), self.cls_name)
+        if isinstance(output_padding, tuple):
+            Validator.check_equal_int(len(output_padding), 2, 'output_padding size', self.cls_name)
         # out_channels and in_channels swap.
         # cause Conv2DBackpropInput's out_channel refers to Conv2D's out_channel,
         # then Conv2dTranspose's out_channel refers to Conv2DBackpropInput's in_channel.
@@ -1089,6 +1101,7 @@ class Conv2dTranspose(_Conv):
         self.is_valid = self.pad_mode == 'valid'
         self.is_same = self.pad_mode == 'same'
         self.is_pad = self.pad_mode == 'pad'
+        self.output_padding = output_padding
         if Validator.check_bool(has_bias, "has_bias", self.cls_name):
             self.bias = Parameter(initializer(bias_init, [out_channels]), name='bias')
 
@@ -1120,7 +1133,29 @@ class Conv2dTranspose(_Conv):
         if self.has_bias:
             return self.bias_add(self.conv2d_transpose(x, self.weight, (n, self.out_channels, h_out, w_out)),
                                  self.bias)
-        return self.conv2d_transpose(x, self.weight, (n, self.out_channels, h_out, w_out))
+        conv2d_trans_ret = self.conv2d_transpose(x, self.weight, (n, self.out_channels, h_out, w_out))
+        if isinstance(self.output_padding, tuple):
+            if self.output_padding[0] < 0 or self.output_padding[0] >= max(self.dilation[0], self.stride[0]):
+                raise ValueError("output_padding[0] must be in range of [0, max(stride_h, dilation_h)).")
+            if self.output_padding[1] < 0 or self.output_padding[1] >= max(self.dilation[1], self.stride[1]):
+                raise ValueError("output_padding[1] must be in range of [0, max(stride_w, dilation_w)).")
+            if not self.is_pad and (self.output_padding[0] > 0 or self.output_padding[1] > 0):
+                raise ValueError("when output_padding is not zero, pad_mode must be 'pad'")
+
+            pad = P.Pad(paddings=((0, 0), (0, 0), (0, self.output_padding[0]), (0, self.output_padding[1])))
+            return pad(conv2d_trans_ret)
+
+        if self.output_padding == 0:
+            return conv2d_trans_ret
+
+        if self.output_padding < 0 or self.output_padding >= max(self.dilation[0], self.stride[0]):
+            raise ValueError("output_padding must be in range of [0, max(stride_h, dilation_h)).")
+        if self.output_padding < 0 or self.output_padding >= max(self.dilation[1], self.stride[1]):
+            raise ValueError("output_padding must be in range of [0, max(stride_w, dilation_w)).")
+        if not self.is_pad and self.output_padding > 0:
+            raise ValueError("when output_padding is not zero, pad_mode must be 'pad'")
+        pad = P.Pad(paddings=((0, 0), (0, 0), (0, self.output_padding), (0, self.output_padding)))
+        return pad(conv2d_trans_ret)
 
 
 class Conv1dTranspose(_Conv):
@@ -1128,7 +1163,8 @@ class Conv1dTranspose(_Conv):
     Calculates a 1D transposed convolution, which can be regarded as Conv1d for the gradient of the input,
     also called deconvolution (although it is not an actual deconvolution).
 
-    The input is typically of shape :math:`(N, C, L)`, where :math:`N` is batch size, :math:`C` is a number of channels
+    The input is typically of shape :math:`(N, C_{in}, L_{in})`, where :math:`N` is batch size,
+    :math:`C` is a number of channels
     and :math:`L_{in}` is a length of sequence.
 
     When Conv1d and ConvTranspose1d are initialized with the same parameters, and `pad_mode` is set to 'pad',
@@ -1180,18 +1216,18 @@ class Conv1dTranspose(_Conv):
         pad_mode is 'same':
 
         .. math::
-            L_{out} ＝ \left \lfloor{\frac{L_{in}}{\text{stride}} + 1} \right \rfloor
+            L_{out} = \left \lfloor{\frac{L_{in}}{\text{stride}} + 1} \right \rfloor
 
         pad_mode is 'valid':
 
         .. math::
-            L_{out} ＝ \left \lfloor{\frac{L_{in} - \text{dilation} \times (\text{kernel_size} - 1) }
+            L_{out} = \left \lfloor{\frac{L_{in} - \text{dilation} \times (\text{kernel_size} - 1) }
             {\text{stride}} + 1} \right \rfloor
 
         pad_mode is 'pad':
 
         .. math::
-            L_{out} ＝ \left \lfloor{\frac{L_{in} + 2 \times padding - (\text{dilation} - 1) \times
+            L_{out} = \left \lfloor{\frac{L_{in} + 2 \times padding - (\text{dilation} - 1) \times
             \text{kernel_size} - 1 }{\text{stride}} + 1} \right \rfloor
 
     Raises:
@@ -1228,10 +1264,10 @@ class Conv1dTranspose(_Conv):
         Validator.check_value_type("stride", stride, [int], self.cls_name)
         Validator.check_value_type("padding", padding, [int], self.cls_name)
         Validator.check_value_type("dilation", dilation, [int], self.cls_name)
-        Validator.check_int(kernel_size, 1, Rel.GE, 'kernel_size', self.cls_name)
-        Validator.check_int(stride, 1, Rel.GE, 'stride', self.cls_name)
+        Validator.check_int(kernel_size, 1, Validator.GE, 'kernel_size', self.cls_name)
+        Validator.check_int(stride, 1, Validator.GE, 'stride', self.cls_name)
         Validator.check_non_negative_int(padding, 'padding', self.cls_name)
-        Validator.check_int(dilation, 1, Rel.GE, 'dilation', self.cls_name)
+        Validator.check_int(dilation, 1, Validator.GE, 'dilation', self.cls_name)
         kernel_size = (1, kernel_size)
         stride = (1, stride)
         dilation = (1, dilation)

mindspore/nn/layer/dense.py

@@ -23,14 +23,14 @@ import mindspore.common.dtype as mstype
 from mindspore.common.tensor import Tensor
 from mindspore.common.initializer import initializer, Uniform
 from mindspore.common.parameter import Parameter
-from mindspore.ops.primitive import constexpr
-from mindspore._checkparam import Validator
+from mindspore.ops.primitive import constexpr, _primexpr
+from mindspore import _checkparam as Validator
 from mindspore.nn.cell import Cell
 
 __all__ = ['BiDense']
 
 
-@constexpr
+@_primexpr
 def check_dense_inputs_same_shape(input1, input2, prim_name=None):
     msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if input1[:-1] != input2[:-1]:
@@ -46,7 +46,7 @@ def _check_is_tensor(param_name, input_data, cls_name):
                         f"but got '{P.typeof(input_data)}'")
 
 
-@constexpr
+@_primexpr
 def check_last_dimension(input_dim, input_channels, input_name, input_channels_name, prim_name=None):
     msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if input_dim != input_channels:
@@ -63,7 +63,7 @@ class BiDense(Cell):
     .. math::
         y = x_1^T A x_2 + b,
 
-    where :math:`x_1` is the first input tensor, :math:`x_2` is the second input tensor
+    where :math:`x_{1}` is the first input tensor, :math:`x_{2}` is the second input tensor
     , :math:`A` is a weight matrix with the same data type as the :math:`x_{*}` created by the layer
     , and :math:`b` is a bias vector with the same data type as the :math:`x_{*}` created by the layer
     (only if has_bias is True).
@@ -76,7 +76,7 @@ class BiDense(Cell):
             The values of str refer to the function `initializer`. Default: None.
         bias_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable bias_init parameter.
             The values of str refer to the function `initializer`. Default: None.
-        has_bias (bool): Specifies whether the layer uses a bias vector. Default: True.
+        has_bias (bool): Specifies whether the layer uses :math:`\text{bias}` vector. Default: True.
 
     Shape:
         - **input1** - :math:`(*, H_{in1})` where :math:`H_{in1}=\text{in1_channels}` and
@@ -85,8 +85,9 @@ class BiDense(Cell):
         - **input2** - :math:`(*, H_{in2})` where :math:`H_{in2}=\text{in2_channels}` and
           :math:`*` means any number of additional dimensions including none. All but the last dimension
           of the inputs should be the same.
-        - **output** - :math:`(*, H_{out})` where :math:`H_{out}=\text{out_channels}`
-          and all but the last dimension are the same shape as the inputs.
+        - **output** - :math:`(*, H_{out})` where :math:`H_{out}=\text{out_channels}` and
+          :math:`*` means any number of additional dimensions including none. All but the last dimension
+          are the same shape as the inputs.
 
     Dtype:
         - **input1** (Tensor) - The dtype must be float16 or float32 and be same as **input2**.

mindspore/nn/layer/embedding.py

@@ -29,26 +29,23 @@ from mindspore.parallel._utils import _get_parallel_mode, _get_full_batch
 from mindspore.parallel._ps_context import _get_ps_context, _enable_distributed_mindrt
 from mindspore.parallel._ps_context import _is_role_worker, _is_role_pserver
 from mindspore.parallel._ps_context import _insert_hash_table_size, _set_cache_enable, _set_rank_id
-from mindspore._checkparam import Rel
-from mindspore._checkparam import Validator as validator
-from mindspore.ops.primitive import constexpr
+from mindspore import _checkparam as Validator
+from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.nn.layer.basic import ClipByNorm
-from mindspore.nn.layer.math import Range
 from mindspore.nn.cell import Cell
 
 __all__ = ['Embedding', 'EmbeddingLookup', 'MultiFieldEmbeddingLookup']
 
 
-@constexpr
+@_primexpr
 def _check_input_2d(input_shape, param_name, func_name):
     if len(input_shape) != 2:
         raise ValueError(f"For '{func_name}', the dimension of '{param_name}' must be 2d, but got {len(input_shape)}")
-    return True
 
 
 @constexpr
 def _check_input_dtype(input_dtype, param_name, allow_dtypes, cls_name):
-    validator.check_type_name(param_name, input_dtype, allow_dtypes, cls_name)
+    Validator.check_type_name(param_name, input_dtype, allow_dtypes, cls_name)
 
 
 class Embedding(Cell):
@@ -102,16 +99,16 @@ class Embedding(Cell):
                  dtype=mstype.float32, padding_idx=None):
         """Initialize Embedding."""
         super(Embedding, self).__init__()
-        self.vocab_size = validator.check_value_type('vocab_size', vocab_size, [int], self.cls_name)
-        self.embedding_size = validator.check_value_type('embedding_size', embedding_size, [int], self.cls_name)
-        validator.check_value_type('use_one_hot', use_one_hot, [bool], self.cls_name)
-        validator.check_subclass("dtype", dtype, mstype.number_type, self.cls_name)
+        self.vocab_size = Validator.check_value_type('vocab_size', vocab_size, [int], self.cls_name)
+        self.embedding_size = Validator.check_value_type('embedding_size', embedding_size, [int], self.cls_name)
+        Validator.check_value_type('use_one_hot', use_one_hot, [bool], self.cls_name)
+        Validator.check_subclass("dtype", dtype, mstype.number_type, self.cls_name)
         self.use_one_hot = use_one_hot
         self.dtype = dtype
         self.init_tensor = initializer(embedding_table, [vocab_size, embedding_size])
         self.padding_idx = padding_idx
         if padding_idx is not None:
-            self.padding_idx = validator.check_int_range(padding_idx, 0, vocab_size, Rel.INC_LEFT,
+            self.padding_idx = Validator.check_int_range(padding_idx, 0, vocab_size, Validator.INC_LEFT,
                                                          "padding_idx", self.cls_name)
             if isinstance(self.init_tensor, Tensor) and self.init_tensor.init is not None:
                 self.init_tensor = self.init_tensor.init_data()
@@ -129,9 +126,13 @@ class Embedding(Cell):
         self.array_mul = P.MatMul()
         self.reshape = P.Reshape()
         self.get_shp = P.Shape()
+        self.get_tensor_shp = P.TensorShape()
+        self.concat = P.Concat()
 
     def construct(self, ids):
         out_shape = self.get_shp(ids) + (self.embedding_size,)
+        if F.is_sequence_value_unknown(self.get_shp(ids)):
+            out_shape = self.concat((self.get_tensor_shp(ids), Tensor([self.embedding_size])))
         flat_ids = self.reshape_flat(ids, self.shp_flat)
 
         if self.use_one_hot:
@@ -230,14 +231,14 @@ class EmbeddingLookup(Cell):
                  max_norm=None, sparse=True, vocab_cache_size=0):
         """Initialize EmbeddingLookup."""
         super(EmbeddingLookup, self).__init__()
-        validator.check_value_type('sparse', sparse, [bool], self.cls_name)
-        self.vocab_size = validator.check_positive_int(vocab_size, 'vocab_size')
-        self.vocab_cache_size = validator.check_non_negative_int(vocab_cache_size, 'vocab_cache_size')
+        Validator.check_value_type('sparse', sparse, [bool], self.cls_name)
+        self.vocab_size = Validator.check_positive_int(vocab_size, 'vocab_size')
+        self.vocab_cache_size = Validator.check_non_negative_int(vocab_cache_size, 'vocab_cache_size')
         self.target = target
         self.sparse = sparse
         self.cache_enable = self.vocab_cache_size > 0
         self.forward_unique = False
-        validator.check_string(target, ['CPU', 'DEVICE'], 'target', self.cls_name)
+        Validator.check_string(target, ['CPU', 'DEVICE'], 'target', self.cls_name)
         if not sparse and target == 'CPU':
             raise ValueError(f"For '{self.cls_name}', 'sparse' must be True when 'target' is \"CPU\", "
                              f"but got 'sparse': {sparse} and 'target': {target}")
@@ -250,7 +251,7 @@ class EmbeddingLookup(Cell):
         enable_ps = _get_ps_context("enable_ps")
         if enable_ps:
             self._process_vocab_cache(slice_mode)
-        self.embedding_size = validator.check_positive_int(embedding_size, 'embedding_size', self.cls_name)
+        self.embedding_size = Validator.check_positive_int(embedding_size, 'embedding_size', self.cls_name)
         self.embedding_table = Parameter(initializer(param_init, [self.vocab_size, self.embedding_size]),
                                          name='embedding_table')
         parallel_mode = _get_parallel_mode()
@@ -275,7 +276,7 @@ class EmbeddingLookup(Cell):
                 raise TypeError(f"For '{self.cls_name}', the type of 'manual_shapes' must be tuple(int), "
                                 f"but got {type(manual_shapes).__name__}!")
             for dim in manual_shapes:
-                validator.check_positive_int(dim, 'manual shape dim', self.cls_name)
+                Validator.check_positive_int(dim, 'manual shape dim', self.cls_name)
             self.gatherv2.add_prim_attr("manual_split", manual_shapes)
             self.embeddinglookup.add_prim_attr("manual_split", manual_shapes)
             self.gatherv2.shard(((get_group_size(), 1), (1, get_group_size())))
@@ -313,7 +314,7 @@ class EmbeddingLookup(Cell):
         self.embedding_table.unique = self.forward_unique
         self.max_norm = max_norm
         if self.max_norm is not None:
-            self.max_norm = validator.check_positive_float(self.max_norm, 'max_norm', self.cls_name)
+            self.max_norm = Validator.check_positive_float(self.max_norm, 'max_norm', self.cls_name)
             self.max_norm = Tensor(self.max_norm, dtype=mstype.float32)
 
     def _process_vocab_cache(self, slice_mode):
@@ -343,13 +344,15 @@ class EmbeddingLookup(Cell):
                                      f"But got full_batch: {full_batch} and 'slice_mode': \"{slice_mode}\".")
                 self.vocab_cache_size = self.vocab_cache_size * rank_size
                 _set_rank_id(rank_id)
+
             self.cache_enable = True
+            _set_cache_enable(True)
+
             if _is_role_worker():
                 self.vocab_size = self.vocab_cache_size
 
     def _set_voacb_cache_enable_for_ps(self, vocab_cache_size, embedding_size, vocab_size, param_init):
         """PS embeddingLookup cache enable set."""
-        _set_cache_enable(True)
         if self.sparse:
             self.forward_unique = True
         param_key = _get_unique_parameter_key()
@@ -484,7 +487,7 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
         'MEAN'. Ensure the input_values of the padded id is zero, so that they can be ignored. The final
         output will be zeros if the sum of absolute weight of the field is zero. This class only
         supports ['table_row_slice', 'batch_slice' and 'table_column_slice']. For the operation 'MAX' on
-        device Ascend, there is a constraint where batch_size * (seq_length + field_size) < 3500.
+        device Ascend, there is a constraint where :math:`batch\_size * (seq\_length + field\_size) < 3500`.
 
     Args:
         vocab_size (int): The size of the dictionary of embeddings.
@@ -549,7 +552,7 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
         """Initialize MultiFieldEmbeddingLookup."""
         super(MultiFieldEmbeddingLookup, self).__init__(vocab_size, embedding_size, param_init, target,
                                                         slice_mode, feature_num_list, max_norm, sparse)
-        self.field_size = validator.check_positive_int(field_size, 'field_size', self.cls_name)
+        self.field_size = Validator.check_positive_int(field_size, 'field_size', self.cls_name)
         self.operator = operator
 
         self.mul = P.Mul()
@@ -567,7 +570,7 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
         self.max_mask_mul = P.Mul()
         self.max_no_equal = P.NotEqual()
 
-        validator.check_string(operator, ['SUM', 'MAX', 'MEAN'], 'operator', self.cls_name)
+        Validator.check_string(operator, ['SUM', 'MAX', 'MEAN'], 'operator', self.cls_name)
         if operator == MultiFieldEmbeddingLookup.OPERATOR_SUM:
             self.merge_op = P.UnsortedSegmentSum()
         elif operator == MultiFieldEmbeddingLookup.OPERATOR_MAX:
@@ -619,7 +622,6 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
         self.negative_inf_value = -3.402823466E+38
 
     def construct(self, input_indices, input_values, field_ids):
-
         _check_input_2d(F.shape(input_indices), "input_indices", self.cls_name)
         _check_input_2d(F.shape(input_values), "input_values", self.cls_name)
         _check_input_2d(F.shape(field_ids), "field_ids", self.cls_name)
@@ -629,7 +631,7 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
 
         batch_size = self.shape(input_indices)[0]
         num_segments = batch_size * self.field_size
-        bias = Range(0, num_segments, self.field_size)()
+        bias = F.tuple_to_array(F.make_range(0, num_segments, self.field_size))
         bias = self.reshape(bias, (batch_size, -1))
         field_ids = self.bias_add(field_ids, bias)