mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

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/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

@@ -222,10 +222,10 @@ class Conv1d(_Conv):
         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})` \

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):
@@ -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):
@@ -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):

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()

mindspore/nn/cell.py

@@ -192,6 +192,7 @@ class Cell(Cell_):
         super().__setattr__("_auto_prefix", auto_prefix)
         super().__setattr__("_scope", None)
         super().__setattr__("_phase", 'train')
+        super().__setattr__("_compile_phase", None)
         super().__setattr__("_parameter_layout_dict", None)
         super().__setattr__("_parallel_parameter_name_list", None)
         super().__setattr__("_parallel_parameter_merge_net_dict", None)
@@ -493,6 +494,19 @@ class Cell(Cell_):
             raise TypeError(f"For 'Cell', the property 'phase' must be string type, but got type {type(value)}.")
         self._phase = value
 
+    @property
+    def compile_phase(self):
+        return self._compile_phase
+
+    @compile_phase.setter
+    def compile_phase(self, value):
+        if not isinstance(value, str):
+            raise TypeError(f"For 'Cell', 'compile_phase' must be string type, but got type {type(value)}.")
+        self._compile_phase = value
+        for cell in self._cells.values():
+            if cell is not None:
+                cell.compile_phase = value
+
     @property
     def parameter_layout_dict(self):
         """
@@ -1705,6 +1719,7 @@ class Cell(Cell_):
         _init_auto_parallel_context(self)
         compile_args = self._get_compile_args(args)
         self._has_mutable_args_list = _get_mutable_flags(compile_args)
+        _cell_graph_executor.set_real_args(args, kwargs)
         _cell_graph_executor.compile(self, *compile_args, phase=self.phase,
                                      jit_config_dict=self._jit_config_dict, **kwargs)
         _clear_auto_parallel_context(self)
@@ -2587,23 +2602,6 @@ class Cell(Cell_):
         else:
             self._jit_config_dict = jit_config.jit_config_dict
 
-    def flatten_weights(self, fusion_size=0):
-        """
-        Reset data for weight parameters so that they are using contiguous memory chunks grouped by data type.
-
-        Note:
-            By default, parameters with same data type will using a single contiguous memory chunk. but for
-            some models with huge number of parameters, splitting a large memory chunk into several smaller
-            memory chunks has the potential for performance gains, if this is the case, we can use 'fusion_size'
-            to limit the maximum memory chunk size.
-
-        Args:
-            fusion_size (int): Maximum memory chunk size in bytes, ``0`` for unlimited. Default: ``0`` .
-        """
-        if fusion_size < 0:
-            raise ValueError(f"Negative 'fusion_size' {fusion_size} is invalid.")
-        Tensor._flatten_tensors(self.trainable_params(), fusion_size)  # pylint: disable=W0212
-
     @jit_forbidden_register
     def register_forward_pre_hook(self, hook_fn, with_kwargs=False):
         """
@@ -3507,24 +3505,6 @@ class Cell(Cell_):
         _update_hook_version()
         return handle
 
-    def set_param_ps(self, recurse=True, init_in_server=False):
-        """
-        Set whether the trainable parameters are updated by parameter server and whether the
-        trainable parameters are initialized on server.
-
-        Note:
-            It only works when a running task is in the parameter server mode.
-            It is only supported in graph mode.
-
-        Args:
-            recurse (bool): Whether sets the trainable parameters of subcells. Default: ``True`` .
-            init_in_server (bool): Whether trainable parameters updated by parameter server are
-                initialized on server. Default: ``False`` .
-        """
-        params = self.trainable_params(recurse)
-        for param in params:
-            param.set_param_ps(init_in_server)
-
     def set_comm_fusion(self, fusion_type, recurse=True):
         """
         Set `comm_fusion` for all the parameters in this cell. Please refer to the description of
@@ -3628,8 +3608,7 @@ class Cell(Cell_):
                 introduced by optimizer shard are recomputed in auto parallel or semi auto parallel mode.
                 Default: ``False`` .
         """
-        if context._get_mode() == context.PYNATIVE_MODE:
-            self._recompute_cell = recompute_registry.get()(self.construct)
+        self._recompute_cell = recompute_registry.get()(self.construct)
         self._recompute()
         if 'mp_comm_recompute' in kwargs.keys():
             self._mp_comm_recompute(kwargs.get('mp_comm_recompute', False))
@@ -3646,35 +3625,6 @@ class Cell(Cell_):
                                  "the key kwargs must be 'mp_comm_recompute', "
                                  "'parallel_optimizer_comm_recompute', 'recompute_slice_activation'" % key)
 
-    def place(self, role, rank_id):
-        """
-        Set the label for all operators in this cell.
-        This label tells MindSpore compiler on which process this cell should be launched.
-        And each process's identical label consists of input `role` and `rank_id`.
-        So by setting different cells with different labels, which will be launched on different processes,
-        users can launch a distributed training or predicting job.
-
-        Note:
-            - This method is effective only after
-              `mindspore.communication.init()` is called for dynamic cluster building.
-
-        Args:
-            role (str): The role of the process on which this cell will be launched.
-                        Only 'MS_WORKER' is supported for now.
-            rank_id (int): The rank id of the process on which this cell will be launched.
-                           The rank is unique in processes with the same role.
-
-        Examples:
-            >>> from mindspore import context
-            >>> import mindspore.nn as nn
-            >>> context.set_context(mode=context.GRAPH_MODE)
-            >>> fc = nn.Dense(2, 3)
-            >>> fc.place('MS_WORKER', 0)
-        """
-        all_ops = self._get_prims_recursively()
-        for op in all_ops:
-            op.place(role, rank_id)
-
     def _get_attr_from_cell(self, network):
         if not isinstance(network, Cell):
             return

mindspore/nn/layer/basic.py

@@ -38,7 +38,7 @@ from mindspore.common.generator import default_generator
 
 __all__ = ['Dropout', 'Flatten', 'Dense', 'Linear', 'ClipByNorm', 'Norm', 'OneHot', 'Pad', 'Unfold', 'Tril', 'Triu',
            'MatrixDiag', 'MatrixDiagPart', 'MatrixSetDiag', 'L1Regularizer', 'Dropout1d',
-           'Dropout2d', 'Dropout3d', 'Upsample', 'Roll', 'Identity', 'Unflatten', 'DropoutExt']
+           'Dropout2d', 'Dropout3d', 'Upsample', 'Roll', 'Identity', 'Unflatten', 'DropoutExt', 'Dropout2dExt']
 
 
 class L1Regularizer(Cell):
@@ -382,6 +382,54 @@ class Dropout2d(Cell):
         return f"p={self.keep_prob}"
 
 
+
+class Dropout2dExt(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, inplace=False):
+        """Initialize Dropout2d."""
+        super(Dropout2dExt, self).__init__()
+        self.p = p
+        self.inplace = inplace
+        self.generator_step = Tensor(12, mstype.int64)
+
+    def construct(self, input):
+        if not self.training or self.p == 0:
+            return input
+
+        seed, offset = default_generator._step(self.generator_step)  # pylint: disable=protected-access
+        return ops.auto_generate.dropout2d_ext_op(input, self.p, self.training, self.inplace, seed, offset)
+
+
 class Dropout3d(Cell):
     r"""
     During training, randomly zeroes some channels of the input tensor

mindspore/nn/layer/container.py

@@ -247,6 +247,14 @@ class SequentialCell(Cell):
         self._cells = temp_dict
         self.cell_list = list(self._cells.values())
 
+    def __setattr__(self, name, value):
+        from mindspore.common.recompute import _RecomputeCell
+        if isinstance(value, _RecomputeCell):
+            # RecomputeCell should not be executed
+            object.__setattr__(self, name, value)
+        else:
+            super().__setattr__(name, value)
+
     def __bool__(self):
         return len(self._cells) != 0
 
@@ -594,6 +602,14 @@ class CellDict(_CellDictBase, Cell):
     def __delitem__(self, key):
         del self._cells[key]
 
+    def __setattr__(self, name, value):
+        from mindspore.common.recompute import _RecomputeCell
+        if isinstance(value, _RecomputeCell):
+            # RecomputeCell should not be executed
+            object.__setattr__(self, name, value)
+        else:
+            super().__setattr__(name, value)
+
     def __len__(self):
         return len(self._cells)