mindspore 2.7.0rc1__cp311-cp311-win_amd64.whl → 2.7.1__cp311-cp311-win_amd64.whl

mindspore/mint/nn/__init__.py

@@ -61,6 +61,7 @@ from mindspore.nn.layer import ReLU
 
 # 14
 from mindspore.nn.layer.basic import DropoutExt as Dropout
+from mindspore.nn.layer.basic import Dropout2dExt as Dropout2d
 # 15
 from mindspore.mint.nn.layer.conv import Conv1d, Conv2d, Conv3d, ConvTranspose2d
 # 16
@@ -260,9 +261,6 @@ from mindspore.mint.nn.layer.activation import Threshold
 # 258
 from mindspore.ops.function.nn_func import mse_loss_ext
 
-# 393
-from mindspore.mint.nn.layer.basic import Dropout2d
-
 # 406
 from mindspore.mint.nn.layer.activation import ELU
 
@@ -325,9 +323,6 @@ class NLLLoss(Cell):
         \sum_{n=1}^{N} l_{n}, & \text { if reduction }=\text { 'sum' }
         \end{array}\right.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         weight (Tensor, optional): A rescaling weight applied to the loss of each batch element.
             If not None, the shape is :math:`(C,)`, data type must be float16 or float32 or bfloat16(only supported by
@@ -696,9 +691,6 @@ class ReLU6(Cell):
     r"""
     Activation function ReLU6.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Refer to :func:`mindspore.mint.nn.functional.relu6` for more details.
 
     ReLU6 Activation Function Graph:
@@ -847,9 +839,6 @@ class SmoothL1Loss(Cell):
 
     Refer to :func:`mindspore.mint.nn.functional.smooth_l1_loss` for more details.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Supported Platforms:
         ``Ascend``
 
@@ -1190,7 +1179,7 @@ class PixelShuffle(Cell):
         >>> input = mint.randn(1, 9, 4, 4)
         >>> output = pixel_shuffle(input)
         >>> print(output.shape)
-            [1, 1, 12, 12]
+            (1, 1, 12, 12)
     """
 
     def __init__(self, upscale_factor):
@@ -1448,9 +1437,6 @@ __all__ = [
 
     # 388
     'AdaptiveMaxPool2d',
-
-    # 393
-    'Dropout2d',
     # 406
     'ELU',
     # 407

mindspore/mint/nn/functional.py

@@ -15,10 +15,7 @@
 """mint nn functional."""
 from __future__ import absolute_import
 import mindspore.ops as ops
-import mindspore.mint as mint
-from mindspore import log as logger
 from mindspore import _checkparam as validator
-from mindspore.ops.primitive import constexpr
 from mindspore.ops.function.nn_func import max_pool2d_ext as max_pool2d
 from mindspore.ops.functional import (
     conv_transpose2d,
@@ -55,8 +52,9 @@ from mindspore.ops.function.nn_func import relu_
 
 # 14
 from mindspore.ops.function.nn_func import dropout_ext as dropout
+from mindspore.ops.function.nn_func import dropout2d_ext as dropout2d
 # 15
-from mindspore.ops.function.nn_func import conv1d_ext as conv1d
+from mindspore.ops.functional_overload import conv1d
 from mindspore.ops.function.nn_func import conv2d_ext as conv2d
 # 16
 from mindspore.ops.function.nn_func import log_softmax_ext as log_softmax
@@ -126,6 +124,7 @@ from mindspore.ops.auto_generate import inplace_silu
 
 # 49
 from mindspore.ops.functional import sigmoid
+from mindspore.ops.functional import inplace_sigmoid as sigmoid_
 # 50
 
 # 51
@@ -502,9 +501,6 @@ def relu6(input, inplace=False):
     .. image:: ../images/ReLU6.png
         :align: center
 
-    .. warning::
-        This is an experimental optimizer API that is subject to change.
-
     Args:
         input (Tensor): input Tensor. Dtype is in int8, int16, int32, int64, uint8, float16, float32, bfloat16.
         inplace (bool, optional): Whether to apply erasing inplace. Default: ``False``.
@@ -770,9 +766,6 @@ def smooth_l1_loss(input, target, reduction='mean', beta=1.0):
     Here :math:`\text{beta}` controls the point where the loss function changes from quadratic to linear.
     :math:`\text{beta} \geq 0` , its default value is ``1.0`` . :math:`N` is the batch size.
 
-    .. warning::
-        This is an experimental optimizer API that is subject to change.
-
     Note:
         - Arg `input` and `target` comply with the implicit type conversion rules to make the data types consistent.
           If they have different data types, the lower precision data type will be converted to relatively the
@@ -837,104 +830,6 @@ def smooth_l1_loss(input, target, reduction='mean', beta=1.0):
     return ops.function.smooth_l1_loss(input, target, beta, reduction)
 
 
-@constexpr
-def log_warning(msg):
-    """Adds warning to logger."""
-    logger.warning(msg)
-
-
-def dropout2d(input, p=0.5, training=True):
-    r"""
-    During training, randomly zeroes some channels of the input tensor with probability `p`
-    from a Bernoulli distribution (For a 4-dimensional tensor with a shape of :math:`(N, C, H, W)`,
-    the channel feature map refers to a 2-dimensional feature map with the shape of :math:`(H, W)`).
-
-    For example, the :math:`j\_th` channel of the :math:`i\_th` sample in the batched input is a to-be-processed
-    `2D` tensor input[i,j].
-    Each channel will be zeroed out independently on every forward call which based on Bernoulli distribution
-    probability `p`.
-    The parper `Dropout: A Simple Way to Prevent Neural Networks from Overfitting
-    <http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf>`_ mentioned this technology, and it is proved that
-    it can effectively reduce over fitting and prevent neuronal coadaptation.
-    For more details, refer to `Improving neural networks by preventing co-adaptation of feature detectors
-    <https://arxiv.org/pdf/1207.0580.pdf>`_ .
-
-    `dropout2d` can improve the independence between channel feature maps.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Args:
-        input (Tensor): A `4D` tensor with shape :math:`(N, C, H, W)`, where `N` is the batch size, `C` is the number
-            of channels, `H` is the feature height, and `W` is the feature width.
-        p (float, optional): The dropping probability of a channel, between 0 and 1, e.g. `p` = 0.8,
-            which means dropping out 80% of channels. Default: ``0.5`` .
-        training(bool, optional): If `training` is True, applying dropout, otherwise, not applying. Default: ``True`` .
-
-    Returns:
-        Tensor, output, with the same shape and data type as `input`.
-
-    Raises:
-        TypeError: If `input` is not a Tensor.
-        TypeError: If the data type of `p` is not float.
-        ValueError: If `p` is out of the range `[0.0, 1.0]`.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, mint
-        >>> input = Tensor(np.ones([2, 1, 2, 3]), mindspore.float32)
-        >>> output = mint.nn.functional.dropout2d(input, 0.5)
-        >>> print(output.shape)
-        (2, 1, 2, 3)
-    """
-    def dropout2d_impl_(input, p, training):
-        if p == 0 or not training or input.numel() == 0:
-            return input
-
-        if p == 1:
-            return mint.mul(input, mint.zeros((), dtype=input.dtype))
-
-        if input.ndim < 2:
-            raise ValueError(f'For dropout2d, input size after unsqueeze must be greater or equal to 2')
-
-        if ops.is_sequence_shape_unknown(input.shape):
-            input_tensor_shape = ops.TensorShape()(input)
-            nosie_tensor_shape = mint.ones_like(input_tensor_shape)
-            nosie_tensor_shape[0] = input_tensor_shape[0]
-            nosie_tensor_shape[1] = input_tensor_shape[1]
-            nosie_shape = ops.TensorToTuple()(nosie_tensor_shape)
-        else:
-            nosie_shape = input.shape[:2] + tuple(1 for _ in range(len(input.shape) - 2))
-        nosie = mint.full(nosie_shape, 1 - p, dtype=input.dtype)
-        nosie = mint.bernoulli(nosie)
-        nosie = mint.div(nosie, 1 - p)
-
-        return mint.mul(input, nosie)
-
-    validator.check_float_range(p, 0.0, 1.0, validator.INC_BOTH, "p", "dropout2d")
-    validator.check_bool(training, "training", "dropout2d")
-
-    if input.ndim not in (3, 4):
-        log_warning(f"dropout2d receviced a {input.ndim}-D input which is not recommended. Please use dropout instead.")
-
-    is_batched = input.ndim == 4
-    if not is_batched:
-        input_shape = input.shape
-        if ops.is_sequence_shape_unknown(input.shape):
-            input_shape = ops.TensorToTuple()(ops.TensorShape()(input))
-        input = input.reshape((1, *input_shape))
-        result = dropout2d_impl_(input, p, training)
-        result = result.reshape(input_shape)
-    else:
-        result = dropout2d_impl_(input, p, training)
-
-    return result
-
-
 def normalize(input, p=2.0, dim=1, eps=1e-12):
     r"""
     Perform normalization of inputs over specified dimension
@@ -1060,7 +955,6 @@ def adaptive_avg_pool3d(input, output_size):
 
     .. warning::
         For Ascend, it is only supported on Atlas A2 Training Series Products.
-        This is an experimental optimizer API that is subject to change or deletion.
 
     Args:
         input (Tensor): The input of adaptive_avg_pool3d, which is a 4D or 5D Tensor.
@@ -1265,6 +1159,7 @@ __all__ = [
 
     # 49
     'sigmoid',
+    'sigmoid_',
     # 50
 
     # 51
@@ -1402,7 +1297,6 @@ __all__ = [
     'adaptive_avg_pool2d',
 
     # 350
-    'conv1d',
 
     # 393
     'dropout2d',

mindspore/mint/nn/layer/__init__.py

@@ -31,7 +31,6 @@ from mindspore.mint.nn.layer.normalization import SyncBatchNorm
 from mindspore.mint.nn.layer.activation import LogSigmoid
 from mindspore.mint.nn.layer.activation import SiLU
 from mindspore.mint.nn.layer.activation import Threshold
-from mindspore.mint.nn.layer.basic import Dropout2d
 from mindspore.mint.nn.layer.pooling import AdaptiveMaxPool1d
 from mindspore.mint.nn.layer.pooling import AdaptiveAvgPool1d
 from mindspore.mint.nn.layer.pooling import AdaptiveAvgPool2d
@@ -46,7 +45,6 @@ __all__ = [
     'LayerNorm',
     'LogSigmoid',
     'SiLU',
-    'Dropout2d',
     'AdaptiveMaxPool1d',
     'AdaptiveAvgPool1d',
     'AdaptiveAvgPool2d',

mindspore/mint/nn/layer/_functions.py

@@ -23,7 +23,7 @@ from mindspore.communication.management import get_rank, get_group_size, GlobalC
 from mindspore.ops.auto_generate.gen_ops_prim import BatchNormReduceGrad
 from mindspore.ops.auto_generate.gen_ops_prim import BatchNormElemtGrad
 from mindspore.ops.primitive import Primitive, prim_arg_register, PrimitiveWithInfer, prim_attr_register
-from mindspore.ops.operations.comm_ops import ReduceOp, check_hcom_group_valid, check_collective_target_dtype
+from mindspore.ops.operations.comm_ops import ReduceOp, check_collective_target_dtype
 
 batch_norm_reduce_grad = BatchNormReduceGrad()
 batch_norm_elemt_grad = BatchNormElemtGrad()
@@ -71,7 +71,6 @@ class AllReduce(Primitive):
         if not isinstance(self.group, str):
             raise TypeError(f"For '{self.name}', the 'group' must be str, "
                             f"but got {type(self.group).__name__}.")
-        check_hcom_group_valid(self.group, prim_name=self.name)
         self.op = op
         self.add_prim_attr('group', self.group)
         self.add_prim_attr('fusion', 0)

mindspore/mint/nn/layer/activation.py

@@ -147,9 +147,6 @@ class LogSigmoid(Cell):
     .. image:: ../images/LogSigmoid.png
         :align: center
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Inputs:
         - **input** (Tensor) - The input of LogSigmoid with data type of bfloat16, float16 or float32.
           The shape is :math:`(*)` where :math:`*` means, any number of additional dimensions.
@@ -313,9 +310,6 @@ class Tanh(Cell):
     .. image:: ../images/Tanh.png
         :align: center
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Inputs:
         - **input** (Tensor) - Tensor of any dimension, input with data type of float16 or float32.
 

mindspore/mint/nn/layer/basic.py

@@ -18,52 +18,6 @@ from __future__ import division
 
 from mindspore import mint
 from mindspore.nn.cell import Cell
-from mindspore import _checkparam as validator
-
-
-class Dropout2d(Cell):
-    r"""
-    During training, randomly zeroes some channels of the input tensor with probability `p`
-    from a Bernoulli distribution (For a 4-dimensional tensor with a shape of :math:`NCHW`,
-    the channel feature map refers to a 2-dimensional feature map with the shape of :math:`HW`).
-
-    For example, the :math:`j\_th` channel of the :math:`i\_th` sample in the batched input is a to-be-processed
-    `2D` tensor input[i,j].
-    Each channel will be zeroed out independently on every forward call with probability `p` using samples
-    from a Bernoulli distribution.
-
-    `Dropout2d` can improve the independence between channel feature maps.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Refer to :func:`mindspore.mint.nn.functional.dropout2d` for more details.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, mint
-        >>> import numpy as np
-        >>> dropout = mint.nn.Dropout2d(p=0.5)
-        >>> x = Tensor(np.ones([2, 1, 2, 3]), mindspore.float32)
-        >>> output = dropout(x)
-        >>> print(output.shape)
-        (2, 1, 2, 3)
-    """
-
-    def __init__(self, p=0.5):
-        """Initialize Dropout2d."""
-        super(Dropout2d, self).__init__()
-        validator.check_float_range(p, 0.0, 1.0, validator.INC_BOTH, "p", self.cls_name)
-        self.p = p
-
-    def construct(self, x):
-        if not self.training or self.p == 0:
-            return x
-
-        return mint.nn.functional.dropout2d(x, self.p)
 
 
 class Flatten(Cell):
@@ -118,6 +72,5 @@ class Flatten(Cell):
 
 
 __all__ = [
-    'Dropout2d',
     'Flatten',
 ]

mindspore/mint/nn/layer/conv.py

@@ -200,8 +200,6 @@ class Conv1d(_Conv):
               possible length. Extra sequence that could not complete a full stride will
               be discarded.
 
-        padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
-            ``"zeros"`` , ``"reflect"`` or ``"replicate"`` . Default: ``"zeros"`` .
         dilation (Union[int, tuple[int], list[int]], optional): Specifies the dilation
             rate to use for dilated convolution.
             It can be a single int or a tuple/list of 1 integer. 
@@ -219,13 +217,15 @@ class Conv1d(_Conv):
             - :math:`(\text{weight[1]} = C_{in} / \text{groups})`
 
         bias (bool, optional): Whether the Conv1d layer has a bias parameter. Default: ``True`` .
+        padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"zeros"`` , ``"reflect"`` or ``"replicate"`` . Default: ``"zeros"`` .
         dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``None``, using ``mstype.float32``.
 
     Variables:
-        - **weight** (Tensor) - The weight of the convolution layer, with shape :math:
-          `(C_{out}, C_{in} / \text{groups}, \text{kernel_size[0]})`.
-        - **bias** (Tensor) - The bias of the convolution layer, with shape :math:
-          `(C_{out})`. If bias is False, this will be None.
+        - **weight** (Tensor) - The weight of the convolution layer, with shape
+          :math:`(C_{out}, C_{in} / \text{groups}, \text{kernel_size[0]})`.
+        - **bias** (Tensor) - The bias of the convolution layer, with shape
+          :math:`(C_{out})`. If bias is False, this will be None.
 
     Inputs:
         - **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})` \
@@ -393,8 +393,6 @@ class Conv2d(_Conv):
               possible height and width. Extra pixels that could not complete a full stride will
               be discarded.
 
-        padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
-            ``"zeros"`` , ``"reflect"`` or ``"replicate"`` . Default: ``"zeros"`` .
         dilation (Union[int, tuple[int], list[int]], optional): Specifies the dilation rate to use
             for dilated convolution.
             It can be a single int or a tuple/list of 2 integers. A single int means the dilation size is the same
@@ -415,6 +413,8 @@ class Conv2d(_Conv):
             - :math:`(\text{weight[1]} = C_{in} / \text{groups})`
 
         bias (bool, optional): Whether the Conv2d layer has a bias parameter. Default: ``True`` .
+        padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"zeros"`` , ``"reflect"`` or ``"replicate"`` . Default: ``"zeros"`` .
         dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``None``, using ``mstype.float32``.
 
     Variables:
@@ -600,8 +600,6 @@ class Conv3d(_Conv):
               possible height and width. Extra pixels that could not complete a full stride will
               be discarded.
 
-        padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
-            ``"zeros"`` , ``"reflect"`` or ``"replicate"`` . Default: ``"zeros"`` .
         dilation (Union[int, tuple[int], list[int]], optional): Controlling the space between the kernel points.
             Default: ``1`` .
         groups (int, optional): Splits filter into groups, `in_channels` and `out_channels` must be
@@ -615,6 +613,8 @@ class Conv3d(_Conv):
             - :math:`(\text{weight[1]} = C_{in} / \text{groups})`
 
         bias (bool, optional): Whether the Conv3d layer has a bias parameter. Default: ``True`` .
+        padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"zeros"`` , ``"reflect"`` or ``"replicate"`` . Default: ``"zeros"`` .
         dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``None``, using ``mstype.float32``.
 
     Variables:

mindspore/mint/nn/layer/normalization.py

@@ -37,7 +37,6 @@ class _NormBase(Cell):
                  dtype=None
                  ) -> None:
         super(_NormBase, self).__init__()
-        self.set_train()
         self.shape = ops.Shape()
         self.num_features = num_features
         self.eps = eps
@@ -110,7 +109,6 @@ class _BatchNorm(_NormBase):
             dtype=None) -> None:
         super(_BatchNorm, self).__init__(num_features, eps, momentum, affine, track_running_stats,
                                          dtype)
-        self.training = True
 
 
     def _check_input_dim(self, input):
@@ -170,7 +168,6 @@ class BatchNorm1d(_BatchNorm):
 
     .. warning::
         This API does not support Dynamic Rank.
-        This is an experimental API that is subject to change or deletion.
 
     Args:
         num_features (int): `C` from an expected input of shape :math:`(N, C, L)`.
@@ -209,8 +206,8 @@ class BatchNorm1d(_BatchNorm):
         >>> net = mint.nn.BatchNorm1d(4)
         >>> output = net(input_x)
         >>> print(output)
-        [[ 0.99950075 0.9980011 -0.9980068 -0.9997783]
-         [-0.9995012 -0.99799967 0.9980068  0.9997778]]
+        [[0.6999965  0.4999975  0.4999975  0.59999704]
+         [0.4999975  0.399998   0.59999704 0.89999545]]
     """
 
     def _check_input_dim(self, input):
@@ -218,7 +215,7 @@ class BatchNorm1d(_BatchNorm):
         dim = len(shape)
         if dim != 2 and dim != 3:
             raise ValueError(
-                "expected 2D or 3D input (got {}D input)".format(dim)
+                "expected 2D or 3D input, but got " + str(dim) + "D input"
             )
 
 
@@ -239,7 +236,6 @@ class BatchNorm2d(_BatchNorm):
 
     .. warning::
         - This API does not support Dynamic Rank.
-        - This is an experimental API that is subject to change or deletion.
 
     Args:
         num_features (int): `C` from an expected input of shape :math:`(N, C, H, W)`.
@@ -277,10 +273,10 @@ class BatchNorm2d(_BatchNorm):
         >>> net = mint.nn.BatchNorm2d(2)
         >>> output = net(input_x)
         >>> print(output)
-        [[[[-0.99950075]]
-          [[0.9980087]]]
-          [[[0.999501]]
-          [[-0.9980097]]]]
+        [[[[0.29999852]]
+          [[0.399998  ]]]
+         [[[0.4999975 ]]
+          [[0.29999852]]]]
     """
 
     def _check_input_dim(self, input):
@@ -288,7 +284,7 @@ class BatchNorm2d(_BatchNorm):
         dim = len(shape)
         if dim != 4:
             raise ValueError(
-                "expected 4D input (got {}D input)".format(dim)
+                "expected 4D input, but got " + str(dim) + "D input"
             )
 
 
@@ -309,7 +305,6 @@ class BatchNorm3d(_BatchNorm):
 
     .. warning::
         This API does not support Dynamic Rank.
-        This is an experimental API that is subject to change or deletion.
 
     Args:
         num_features (int): `C` from an expected input of shape :math:`(N, C, D, H, W)`.
@@ -347,8 +342,8 @@ class BatchNorm3d(_BatchNorm):
         >>> net = mint.nn.BatchNorm3d(2)
         >>> output = net(input_x)
         >>> print(output)
-        [[[[[-0.9999688 0.99996865]]]
-          [[[-0.9999833 06.9999831]]]]]
+        [[[[[0.0999995  0.89999545]]]
+          [[[1.1999941  2.2999885 ]]]]]
     """
 
     def _check_input_dim(self, input):
@@ -356,7 +351,7 @@ class BatchNorm3d(_BatchNorm):
         dim = len(shape)
         if dim != 5:
             raise ValueError(
-                "expected 5D input (got {}D input)".format(dim)
+                "expected 5D input, but got " + str(dim) + "D input"
             )
 
 

mindspore/mint/nn/layer/pooling.py

@@ -73,9 +73,6 @@ class AdaptiveAvgPool2d(_AdaptiveAvgPoolNd):
     The output is of size :math:`H x W` , for any input size.
     The number of output features is equal to the number of input planes.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         output_size (Union(int, tuple[int])): the target output size of the image of the form :math:`H x W` .
             Can be a tuple :math:`(H, W)` or a single :math:`H` for square image :math:`H x H` .
@@ -129,7 +126,6 @@ class AdaptiveAvgPool3d(Cell):
 
     .. warning::
         For Ascend, it is only supported on Atlas A2 Training Series Products.
-        This is an experimental optimizer API that is subject to change or deletion.
 
     Args:
         output_size (Union[int, tuple]): The target output size. `output_size` can be a tuple :math:`(D, H, W)`,

mindspore/nn/__init__.py

@@ -21,7 +21,7 @@ from __future__ import absolute_import
 
 __all__ = ["Cell", "GraphCell", "PipelineGradReducer", "PipelineCell", "MicroBatchInterleaved"]
 
-from mindspore.nn import layer, loss, optim, wrap, grad, metrics, probability, sparse, dynamic_lr, reinforcement
+from mindspore.nn import layer, loss, optim, wrap, grad, metrics, probability, sparse, dynamic_lr
 from mindspore.parallel.nn.parallel_grad_reducer import PipelineGradReducer
 from mindspore.parallel.nn.parallel_cell_wrapper import PipelineCell, MicroBatchInterleaved
 from mindspore.nn.learning_rate_schedule import *
@@ -34,7 +34,6 @@ from mindspore.nn.metrics import *
 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.utils import *
 
 __all__.extend(layer.__all__)
@@ -46,7 +45,6 @@ __all__.extend(grad.__all__)
 __all__.extend(sparse.__all__)
 __all__.extend(learning_rate_schedule.__all__)
 __all__.extend(dynamic_lr.__all__)
-__all__.extend(reinforcement.__all__)
 __all__.extend(utils.__all__)
 
 __all__.sort()