mindspore 2.3.0rc1__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/nn/extend/layer/normalization.py

@@ -0,0 +1,107 @@
+# Copyright 2020-2024 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.
+# ============================================================================
+"""normalization"""
+from __future__ import absolute_import
+from __future__ import division
+
+from mindspore.ops import functional as F
+from mindspore.common.parameter import Parameter
+from mindspore.common.initializer import initializer
+from mindspore.common import dtype as mstype
+from mindspore.nn.cell import Cell
+
+__all__ = ['LayerNorm']
+
+
+class LayerNorm(Cell):
+    r"""
+    Applies Layer Normalization over a mini-batch of inputs.
+
+    Layer Normalization is widely used in recurrent neural networks. It applies
+    normalization on a mini-batch of inputs for each single training case as described
+    in the paper `Layer Normalization <https://arxiv.org/pdf/1607.06450.pdf>`_. Unlike Batch
+    Normalization, Layer Normalization performs exactly the same computation at training and
+    testing time. It is applied across all channels and pixel but only one batch size.
+    :math:`\gamma` and :math:`\beta` are trainable scale and shift.
+    It can be described using the following formula:
+
+    .. math::
+        y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta
+
+    Args:
+        normalized_shape (Union(tuple[int], list[int])): The normalized shape of `x` for LayerNorm
+        gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\gamma` weight.
+            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+            ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'ones'`` .
+        beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\beta` weight.
+            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+            ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'zeros'`` .
+        epsilon (float): A value added to the denominator for numerical stability(:math:`\epsilon`). Default: ``1e-5`` .
+        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
+
+    Inputs:
+        - **x** (Tensor) - The shape is :math:`(N, *)`, where :math:`*` means, any number of additional dimensions.
+
+    Outputs:
+        Tensor, the normalized and scaled offset tensor, has the same shape and data type as the `x`.
+
+    Raises:
+        TypeError: If `epsilon` is not a float.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> x = ms.Tensor(np.ones([20, 5, 10, 10]), ms.float32)
+        >>> shape1 = x.shape[1:]
+        >>> m = ms.nn.extend.LayerNorm(shape1)
+        >>> output = m(x).shape
+        >>> print(output)
+        (20, 5, 10, 10)
+    """
+
+    def __init__(self,
+                 normalized_shape,
+                 gamma_init='ones',
+                 beta_init='zeros',
+                 epsilon=1e-5,
+                 dtype=mstype.float32
+                 ):
+        """Initialize LayerNorm."""
+        super(LayerNorm, self).__init__()
+        if not isinstance(normalized_shape, (tuple, list)):
+            raise TypeError(f"For '{self.cls_name}', the type of 'normalized_shape' must be tuple[int] or list[int], "
+                            f"but got {normalized_shape} and the type is {type(normalized_shape)}.")
+        if not normalized_shape:
+            raise ValueError(
+                f"Expected normalized_shape to be at least 1-dimensional, i.e., containing at "
+                f"least one element, but got normalized_shape = {normalized_shape}"
+            )
+        self.normalized_shape = normalized_shape
+        self.epsilon = epsilon
+        self.gamma = Parameter(initializer(
+            gamma_init, normalized_shape, dtype=dtype), name="gamma")
+        self.beta = Parameter(initializer(
+            beta_init, normalized_shape, dtype=dtype), name="beta")
+
+    def construct(self, input_x):
+        y = F.layer_norm(input_x, self.normalized_shape, self.gamma.astype(input_x.dtype),
+                         self.beta.astype(input_x.dtype), self.epsilon)
+        return y
+
+    def extend_repr(self):
+        return 'normalized_shape={}, gamma{}, beta={}'.format(self.normalized_shape, self.gamma, self.beta)

mindspore/nn/extend/pooling.py

@@ -0,0 +1,117 @@
+#Copyright 2020-2022 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.
+# ============================================================================
+"""pooling"""
+from __future__ import absolute_import
+
+from mindspore.ops.auto_generate.gen_ops_prim import MaxPoolWithIndices, MaxPoolWithMask
+from mindspore.nn.cell import Cell
+
+__all__ = ['MaxPool2d']
+
+
+class MaxPool2d(Cell):
+    r"""
+    Applies a 2D max pooling over an input Tensor which can be regarded as a composition of 2D planes.
+
+    Typically the input is of shape :math:`(N_{in}, C_{in}, H_{in}, W_{in})`, MaxPool2d outputs
+    regional maximum in the :math:`(H_{in}, W_{in})`-dimension. Given kernel size
+    :math:`(h_{ker}, w_{ker})` and stride :math:`(s_0, s_1)`, the operation is as follows.
+
+    .. math::
+        \text{output}(N_i, C_j, h, w) = \max_{m=0, \ldots, h_{ker}-1} \max_{n=0, \ldots, w_{ker}-1}
+        \text{input}(N_i, C_j, s_0 \times h + m, s_1 \times w + n)
+
+    .. warning::
+        Only support on Atlas training series.
+
+    Args:
+        kernel_size (Union[int, tuple[int]]): The size of kernel used to take the max value,
+            is an int number or a single element tuple that represents height and width are both kernel_size,
+            or a tuple of two int numbers that represent height and width respectively.
+            Default: ``1`` .
+        stride (Union[int, tuple[int], None]): The distance of kernel moving, an int number or a single element tuple
+            that represents the height and width of movement are both stride, or a tuple of two int numbers that
+            represent height and width of movement respectively.
+            Default: ``None`` , which indicates the moving step is `kernel_size` .
+        padding (Union(int, tuple[int], list[int])): Specifies the padding value of the pooling operation.
+            Default: ``0`` . `padding` can only be an integer or a tuple/list containing one or two integers. If
+            `padding` is an integer or a tuple/list containing one integer, it will be padded `padding` times in the
+            four directions of the input. If `padding` is a tuple/list containing two integers, it will be padded
+            `padding[0]` times in the up-down direction of the input and `padding[1]` times in the left-right direction
+            of the input.
+        dilation (Union(int, tuple[int])): The spacing between the elements of the kernel in convolution,
+            used to increase the receptive field of the pooling operation. If it is a tuple, it must contain one or two
+            integers. Default: ``1`` .
+        return_indices (bool): If ``True`` , the function will return both the result of max pooling and the indices of
+            the max elements. Default: ``False`` .
+        ceil_mode (bool): If ``True`` , use ceil to compute the output shape instead of floor. Default: ``False`` .
+
+    Inputs:
+        - **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
+
+    Outputs:
+        If `return_indices` is ``False`` , return a Tensor `output`, else return a tuple (`output`, `argmax`).
+
+        - **output** (Tensor) - Maxpooling result, with shape :math:`(N_{out}, C_{out}, H_{out}, W_{out})`. It has the
+          same data type as `input`.
+        - **argmax** (Tensor) - Index corresponding to the maximum value. Data type is int32.
+
+        .. math::
+            H_{out} = \left\lfloor\frac{H_{in} + 2 * \text{padding[0]} - \text{dilation[0]}
+                \times (\text{kernel_size[0]} - 1) - 1}{\text{stride[0]}} + 1\right\rfloor
+
+        .. math::
+            W_{out} = \left\lfloor\frac{W_{in} + 2 * \text{padding[1]} - \text{dilation[1]}
+                \times (\text{kernel_size[1]} - 1) - 1}{\text{stride[1]}} + 1\right\rfloor
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        ValueError: If length of shape of `input` is not equal to 4.
+        TypeError: If `kernel_size` , `stride` , `padding` or `dilation` is not int or tuple.
+        ValueError: If `kernel_size`, `stride` or `dilation` is less than 1.
+        ValueError: If `dilation` is not all 1.
+        ValueError: If `padding` is less than 0.
+        ValueError: If `padding` is more than half of `kernel_size`.
+        TypeError: If `ceil_mode` is not bool.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> pool = ms.nn.extend.MaxPool2d(kernel_size=3, stride=1)
+        >>> input = ms.Tensor(np.random.randint(0, 10, [1, 2, 4, 4]), ms.float32)
+        >>> output = pool(input)
+        >>> print(output.shape)
+        (1, 2, 2, 2)
+    """
+
+    def __init__(self, kernel_size=1, stride=None, padding=0, dilation=1, return_indices=False,
+                 ceil_mode=False):
+        """Initialize MaxPool2d."""
+        super(MaxPool2d, self).__init__()
+        self.return_indices = return_indices
+        strides = stride if (stride is not None) else kernel_size
+        if return_indices:
+            self.max_pool_func_ = MaxPoolWithIndices(kernel_size, strides, padding, dilation, ceil_mode)
+        else:
+            self.max_pool_func_ = MaxPoolWithMask(kernel_size, strides, padding, dilation, ceil_mode)
+
+    def construct(self, input):
+        out, indices = self.max_pool_func_(input)
+        if self.return_indices:
+            return out, indices
+        return out

mindspore/nn/generator.py

@@ -0,0 +1,297 @@
+# Copyright 2024 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.
+# ============================================================================
+"""Generator"""
+import os
+
+import numpy as np
+
+from mindspore import context
+from mindspore.common.parameter import Parameter
+from mindspore.nn.cell import Cell
+from mindspore.ops.operations import Assign, AssignAdd, Depend
+
+
+class Generator(Cell):
+    """
+    A generator that manages the state of random numbers and provides seed and offset for random functions.
+    When the seed and offset are fixed, the random function generates the same random sequence.
+
+    Inputs:
+        - **step** (int) - Set the step size for offset update.
+
+    Outputs:
+        Tuple consisting of the seed and offset of generator.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore.nn import Generator
+        >>> import numpy as np
+        >>> np.random.seed(10)
+        >>> ms.set_context(mode=1)
+        >>> generator = Generator()
+        >>> print(generator.get_state())
+        (Tensor(shape=[], dtype=Int32, value= 0), Tensor(shape=[], dtype=Int32, value= 0))
+        >>> print(generator(12))
+        (0, 0)
+        >>> print(generator.get_state())
+        (Tensor(shape=[], dtype=Int32, value= 0), Tensor(shape=[], dtype=Int32, value= 12))
+        >>> generator.manual_seed(20)
+        >>> print(generator.get_state())
+        (Tensor(shape=[], dtype=Int32, value= 20), Tensor(shape=[], dtype=Int32, value= 0))
+        >>> print(generator.seed())
+        1165313289
+        >>> print(generator.initial_seed())
+        1165313289
+    """
+
+    def __init__(self):
+        super(Generator, self).__init__()
+        self._assign = Assign().set_device("CPU")
+        self._assign_add = AssignAdd().set_device("CPU")
+        self._depend = Depend()
+        self._seed = Parameter(0, name="seed", requires_grad=False)
+        self._offset = Parameter(0, name="offset", requires_grad=False)
+        self._seed_val = 0
+        self._offset_val = 0
+
+    def set_state(self, seed, offset=None):  # pylint: disable=redefined-outer-name
+        """
+        Sets the generator state.
+
+        Args:
+            seed (int): Seed of the generator.
+            offset (int, optional): Offset of the generator, default: ``None`` , means ``0``.
+        """
+        self._seed_val = int(seed)
+        self._assign(self._seed, self._seed_val)
+        if offset is None:
+            offset = 0
+        self._offset_val = int(offset)
+        self._assign(self._offset, self._offset_val)
+
+    def get_state(self):
+        """
+        Get the generator state.
+
+        Returns:
+            Tuple consisting of the seed and offset of generator.
+        """
+        return self._seed.value(), self._offset.value()
+
+    def seed(self):  # pylint: disable=redefined-outer-name
+        """
+        Generate random seeds that can be used as seeds for generator.
+
+        Returns:
+            Tensor, randomly generated seeds.
+        """
+        seed_ = np.random.randint(np.iinfo(np.int32).min, np.iinfo(np.int32).max)
+        self.set_state(seed_)
+        return self._seed.value()
+
+    def manual_seed(self, seed):  # pylint: disable=redefined-outer-name
+        """
+        Sets the generator seed.
+
+        Args:
+            seed (int): Sets the generator seed.
+
+        Returns:
+            The generator self.
+        """
+        self.set_state(seed)
+        return self
+
+    def initial_seed(self):
+        """
+        Return the initial seed of generator.
+
+        Returns:
+            The initial seed of generator.
+        """
+        return self._seed.value()
+
+    def construct(self, step):
+        """
+        Update the value of offset, and return the seed and the previous offset.
+
+        Args:
+            step (int): Update offset by step.
+
+        Returns:
+            Seed and offset before update.
+        """
+        offset = self._offset.value()
+        step = self._depend(step, offset)
+        self._assign_add(self._offset, step)
+        return self._seed.value(), offset
+
+    def __call__(self, step):
+        if os.getenv("MS_JIT") != '0' and context.get_context("mode") == context.GRAPH_MODE:
+            return super().__call__(step)
+
+        offset_val = self._offset_val
+        self._offset_val += step
+        self._offset.set_data(self._offset_val)
+        return self._seed_val, offset_val
+
+
+default_generator_ = None
+
+
+def _init_default_generator():
+    global default_generator_
+    default_generator_ = Generator()
+    default_generator_.seed()
+
+
+def default_generator():
+    """
+    Return the default generator object.
+
+    When the user does not specify generator, the random operator invokes default generator to generate random numbers.
+
+    Returns:
+        The default generator.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore.nn import default_generator
+        >>> default_gen = default_generator()
+        >>> print(type(default_gen))
+        <class 'mindspore.nn.generator.Generator'>
+    """
+    if default_generator_ is None:
+        _init_default_generator()
+    return default_generator_
+
+
+def seed():  # pylint: disable=redefined-outer-name
+    """
+    Generate random seeds that can be used as seeds for default generator.
+
+    Returns:
+        Randomly generated seeds.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore.nn import seed
+        >>> np.random.seed(20)
+        >>> print(seed())
+        1663920602
+    """
+    if default_generator_ is None:
+        _init_default_generator()
+    return default_generator_.seed()
+
+
+def manual_seed(seed):  # pylint: disable=redefined-outer-name
+    """
+    Sets the default generator seed.
+
+    Args:
+        seed (int): Sets the default generator seed.
+
+    Returns:
+        The default generator self.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore.nn import manual_seed, initial_seed
+        >>> manual_seed(13)
+        >>> print(initial_seed())
+        13
+    """
+    if default_generator_ is None:
+        _init_default_generator()
+    default_generator_.manual_seed(seed)
+
+
+def initial_seed():
+    """
+    Return the initial seed of default generator.
+
+    Returns:
+        The initial seed of default generator.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore.nn import manual_seed, initial_seed
+        >>> manual_seed(14)
+        >>> print(initial_seed())
+        14
+    """
+    if default_generator_ is None:
+        _init_default_generator()
+    return default_generator_.initial_seed()
+
+
+def get_rng_state():
+    """
+    Get the default generator state.
+
+    Returns:
+        Tuple consisting of the seed and offset of default generator.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore.nn import get_rng_state
+        >>> np.random.seed(20)
+        >>> print(get_rng_state())
+        (Tensor(shape=[], dtype=Int32, value= 378518883), Tensor(shape=[], dtype=Int32, value= 0))
+    """
+    if default_generator_ is None:
+        _init_default_generator()
+    return default_generator_.get_state()
+
+
+def set_rng_state(seed, offset=None):  # pylint: disable=redefined-outer-name
+    """
+    Sets the default generator state.
+
+    Args:
+        seed (int): Seed of the default generator.
+        offset (int, optional): Offset of the default generator, default: ``None`` , means ``0``.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore.nn import set_rng_state, get_rng_state
+        >>> set_rng_state(10)
+        >>> print(get_rng_state())
+        (Tensor(shape=[], dtype=Int32, value= 10), Tensor(shape=[], dtype=Int32, value= 0))
+    """
+    if default_generator_ is None:
+        _init_default_generator()
+    default_generator_.set_state(seed, offset)
+
+
+__all__ = ["Generator", "default_generator", "seed", "manual_seed", "initial_seed", "set_rng_state", "get_rng_state"]

mindspore/nn/layer/basic.py

@@ -27,6 +27,7 @@ from mindspore.common.tensor import Tensor
 from mindspore.common.initializer import initializer, HeUniform, Uniform
 from mindspore.ops import operations as P
 from mindspore.ops import functional as F
+from mindspore.ops.function.nn_func import interpolate_ext
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.ops.primitive import constexpr, Primitive, _primexpr
 from mindspore.common.parameter import Parameter
@@ -35,10 +36,12 @@ from mindspore import _checkparam as Validator
 from mindspore.nn.cell import Cell
 from mindspore.nn.layer.activation import get_activation
 from mindspore.common._decorator import deprecated
+from mindspore.ops.auto_generate import dropout_ext_op
+from mindspore.nn.generator import default_generator
 
 __all__ = ['Dropout', 'Flatten', 'Dense', 'ClipByNorm', 'Norm', 'OneHot', 'Pad', 'Unfold', 'Tril', 'Triu',
            'MatrixDiag', 'MatrixDiagPart', 'MatrixSetDiag', 'L1Regularizer', 'Dropout1d',
-           'Dropout2d', 'Dropout3d', 'Upsample', 'Roll', 'Identity', 'Unflatten']
+           'Dropout2d', 'Dropout3d', 'Upsample', 'Roll', 'Identity', 'Unflatten', 'DropoutExt']
 
 
 class L1Regularizer(Cell):
@@ -201,6 +204,70 @@ class Dropout(Cell):
         return f'p={self.p}'
 
 
+class DropoutExt(Cell):
+    r"""
+    Dropout layer for the input.
+
+    Dropout is a means of regularization that reduces overfitting by preventing correlations between neuronal nodes.
+    The operator randomly sets some neurons output to 0 according to `p`, which means the probability of discarding
+    during training. And the return will be multiplied by :math:`\frac{1}{1-p}` during training.
+    During the reasoning, this layer returns the same Tensor as the `x`.
+
+    This technique is proposed in paper `Dropout: A Simple Way to Prevent Neural Networks from Overfitting
+    <http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf>`_ and proved to be effective to reduce
+    over-fitting and prevents neurons from co-adaptation. See more details in `Improving neural networks by
+    preventing co-adaptation of feature detectors
+    <https://arxiv.org/pdf/1207.0580.pdf>`_.
+
+    Note:
+        - Each channel will be zeroed out independently on every construct call.
+          Parameter `p` means the probability of the element of the input tensor to be zeroed.
+
+    Args:
+        p (float): The dropout rate, greater than or equal to 0 and less than 1.
+            E.g. rate=0.9, dropping out 90% of input neurons. Default: ``0.5`` .
+
+    Inputs:
+        - **x** (Tensor) - The input of Dropout with data type of float16 or float32.
+
+    Outputs:
+        Tensor, output tensor with the same shape as the `x`.
+
+    Raises:
+        ValueError: If `p` is not in range [0, 1).
+        ValueError: If length of shape of `x` is less than 1.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, nn
+        >>> import numpy as np
+        >>> x = Tensor(np.ones([2, 2, 3]), mindspore.float32)
+        >>> net = nn.DropoutExt(p=0.2)
+        >>> net.set_train()
+        >>> output = net(x)
+        >>> print(output.shape)
+        (2, 2, 3)
+    """
+
+    def __init__(self, p=0.5):
+        """Initialize DropoutExt."""
+        super(DropoutExt, self).__init__()
+        self.generator = default_generator()
+        self.dropout = dropout_ext_op
+        self.p = p
+
+    def construct(self, x):
+        if not self.training or self.p == 0:
+            return x
+
+        seed, offset = self.generator(1)
+        out, _ = self.dropout(x, self.p, seed, offset)
+        return out
+
+
 class Dropout1d(Cell):
     r"""
     During training, randomly zeroes entire channels of the input tensor with probability `p`
@@ -408,6 +475,47 @@ class Upsample(Cell):
         return out
 
 
+class UpsampleExt(Cell):
+    r"""
+    For details, please refer to :func:`mindspore.mint.interpolate`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore import mint
+        >>> x = ms.Tensor([[[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]]]])
+        >>> upsample = mint.Upsample(size=(5, 5))
+        >>> out = upsample(x)
+        >>> print(x.asnumpy())
+        [[[[1. 2. 3. 4.]
+           [5. 6. 7. 8.]]]]
+        >>> print(out.asnumpy())
+        [[[[1. 1. 2. 3. 4.]
+           [1. 1. 2. 3. 4.]
+           [1. 1. 2. 3. 4.]
+           [5. 5. 6. 7. 8.]
+           [5. 5. 6. 7. 8.]]]]
+        >>> print(out.shape)
+        (1, 1, 5, 5)
+    """
+
+    def __init__(self, size=None, scale_factor=None, mode="nearest", align_corners=None, recompute_scale_factor=None):
+        """Initialize Upsample."""
+        super(UpsampleExt, self).__init__()
+        self.size = size
+        self.scale_factor = scale_factor
+        self.mode = mode
+        self.align_corners = align_corners
+        self.recompute_scale_factor = recompute_scale_factor
+
+    def construct(self, x):
+        out = interpolate_ext(x, self.size, self.scale_factor, self.mode,
+                              self.align_corners, self.recompute_scale_factor)
+        return out
+
+
 class Flatten(Cell):
     r"""
     Flatten the input Tensor along dimensions from `start_dim` to `end_dim`.

mindspore/nn/layer/container.py

@@ -123,7 +123,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.3.q1/api_python/nn/mindspore.nn.Cell.html#mindspore.nn.Cell>`_.
+    `Cell <https://www.mindspore.cn/docs/en/master/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.
@@ -325,7 +325,7 @@ class SequentialCell(Cell):
 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.3.q1/api_python/nn/mindspore.nn.Cell.html#mindspore.nn.Cell>`_.
+    `Cell <https://www.mindspore.cn/docs/en/master/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 and
     the types of Cells it contains can not be CellDict.