mindspore 2.3.0rc1__cp37-none-any.whl → 2.3.0rc2__cp37-none-any.whl

mindspore/ops/extend/nn_func.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
+# Copyright 2023 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.
@@ -18,6 +18,367 @@
 NN Operators with better performance
 
 """
+from mindspore.ops._primitive_cache import _get_cache_prim
+from mindspore.ops.auto_generate.gen_ops_prim import Convolution, ConstantPadND, MaxPoolWithIndices, MaxPoolWithMask
+from mindspore.ops.auto_generate import leaky_relu_ext
+from mindspore.ops.auto_generate import BatchNormExt
+from mindspore import ops
+from mindspore import _checkparam as validator
 
 
-__all__ = []
+def _check_stride_when_same_mode(stride):
+    """ stride must be 1 when pad mode is same """
+    if isinstance(stride, int):
+        if stride != 1:
+            raise ValueError(f"For conv2d, 'padding=same' is not supported for stride convolution, " \
+                                f"but got {stride}")
+    elif isinstance(stride, tuple):
+        validator.check_int(len(stride), 2, validator.EQ, "stride", 'conv2d')
+        if not all(s == 1 for s in stride):
+            raise ValueError(f"For conv2d, 'padding=same' is not supported for stride convolution, " \
+                                f"but got {stride}")
+    else:
+        raise TypeError(f"For conv2d, the parameter 'stride' must be a int/tuple, but got {type(stride)}")
+
+
+def _get_pad_info(dilation, weight):
+    """ Get pad list by dilation and weight shape """
+    need_pad_nd = False
+    pad_l = ()
+    pad_r = ()
+    for i in range(2):
+        d = dilation[i]
+        weight_size = weight.shape[i + 2]
+        pad = d * (weight_size - 1)
+        pad_l += (int(pad / 2),)
+        pad_r += (int(pad - pad_l[i]),)
+        if pad_l[i] != pad_r[i]:
+            need_pad_nd = True
+    return need_pad_nd, pad_l, pad_r
+
+
+def _get_pad_nd_info(pad_l, pad_r):
+    """ Get pad_nd list if input need to exec pad_nd """
+    pad_nd = ()
+    new_pad_l = ()
+    for i in range(2):
+        delta_pad = pad_r[i] - pad_l[i]
+        if delta_pad > 0:
+            pad_nd = (0, delta_pad,) + pad_nd
+            new_pad_l += (pad_l[i],)
+        else:
+            pad_nd = (delta_pad, 0,) + pad_nd
+            new_pad_l += (pad_r[i],)
+    return pad_nd, new_pad_l
+
+
+def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1):
+    r"""
+    Applies a 2D convolution over an input tensor. The input tenor is typically of
+    shape :math:`(N, C_{in}, H_{in}, W_{in})`, where :math:`N` is batch size, :math:`C` is
+    channel number, :math:`H` is feature height, :math:`W` is feature width.
+
+    The output is calculated based on formula:
+
+    .. math::
+
+        \text{out}(N_i, C_{\text{out}_j}) = \text{bias}(C_{\text{out}_j}) +
+        \sum_{k = 0}^{C_{in} - 1} \text{ccor}({\text{weight}(C_{\text{out}_j}, k), \text{X}(N_i, k)})
+
+    where :math:`bias` is the output channel bias, :math:`ccor` is
+    the `cross-correlation <https://en.wikipedia.org/wiki/Cross-correlation>`_,
+    , :math:`weight` is the convolution kernel value and :math:`X` represents the input feature map.
+
+    Here are the indices' meanings:
+
+    - :math:`i` corresponds to the batch number, the range is :math:`[0, N-1]`,
+      where :math:`N` is the batch size of the input.
+
+    - :math:`j` corresponds to the output channel, the range is :math:`[0, C_{out}-1]`,
+      where :math:`C_{out}` is the number of output channels, which is also equal to the number of kernels.
+
+    - :math:`k` corresponds to the input channel, the range is :math:`[0, C_{in}-1]`,
+      where :math:`C_{in}` is the number of
+      input channels, which is also equal to the number of channels in the convolutional kernels.
+
+    Therefore, in the above formula, :math:`{bias}(C_{out_j})` represents the bias of the :math:`j`-th
+    output channel, :math:`{weight}(C_{out_j}, k)` represents the slice of the :math:`j`-th convolutional
+    kernel in the :math:`k`-th channel, and :math:`{X}(N_i, k)` represents the slice of the :math:`k`-th input
+    channel in the :math:`i`-th batch of the input feature map.
+
+    The shape of the convolutional kernel is given by :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 kernel,
+    respectively.
+    If we consider the input and output channels as well as the `group` parameter, the complete kernel shape
+    will be :math:`(C_{out}, C_{in} / \text{group}, \text{kernel_size[0]}, \text{kernel_size[1]})`,
+    where `group` is the number of groups dividing `x`'s input channel when applying group convolution.
+
+    For more details about convolution layer, please refer to `Gradient Based Learning Applied to Document Recognition
+    <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_ and
+    `ConvNets <http://cs231n.github.io/convolutional-networks/>`_.
+
+    Note:
+        On Ascend platform, only group convolution in depthwise convolution scenarios is supported.
+        That is, when `groups>1`, condition :math:`C_{in}` = :math:`C_{out}` = `groups` must be satisfied.
+
+    Args:
+        input (Tensor): Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
+        weight (Tensor): Tensor of shape
+            :math:`(N, C_{in} / \text{groups}, \text{kernel_size[0]}, \text{kernel_size[1]})`, then the size of kernel
+            is :math:`(\text{kernel_size[0]}, \text{kernel_size[1]})`.
+        bias (Tensor, optional): Bias Tensor with shape :math:`(C_{out})`.
+            When bias is ``None`` , zeros will be used. Default: ``None`` .
+        stride (Union(int, tuple[int]), optional): The distance of kernel moving, an int number that represents
+            the height and width of movement are both strides, or a tuple of two int numbers that
+            represent height and width of movement respectively. Default: ``1`` .
+        padding (Union(int, tuple[int], list[int], str), optional): Implicit paddings on both sides of the input `x`.
+            Can be a string, one integer or a tuple/list with 2 integers.
+            If `padding` is a string, the optional values are ``"same"`` , ``"valid"``.
+
+            - same: Adopts the way of completion. The height and width of the output will be equal to
+              the input `x` divided by stride. The padding will be evenly calculated in top and bottom,
+              left and right possiblily. Otherwise, the last extra padding will be calculated from the bottom
+              and the right side. If this mode is set, `padding` must be 0.
+
+            - valid: Adopts the way of discarding. The possible largest height and width of output will be returned
+              without padding. Extra pixels will be discarded. If this mode is set, `padding` must be 0.
+
+            If `padding` is one integer, the paddings of top, bottom, left and right are the same, equal to padding.
+            If `padding` is a tuple/list with 2 integers, the padding of top adn bottom is padding[0],
+            and the padding of left and right is padding[1]. Default: ``0`` .
+        dilation (Union(int, tuple[int]), optional): Gaps between kernel elements.The data type is int or a tuple of
+            2 integers. Specifies the dilation rate to use for dilated convolution. If set to be :math:`k > 1`,
+            there will be :math:`k - 1` pixels skipped for each sampling location. Its value must
+            be greater than or equal to 1 and bounded by the height and width of the input `x`. Default: ``1`` .
+        groups (int, optional): Splits `input` into groups. Default: ``1`` .
+
+    Returns:
+        Tensor, the value that applied 2D convolution. The shape is :math:`(N, C_{out}, H_{out}, W_{out})`.
+        To see how different pad modes affect the output shape, please refer to
+        :class:`mindspore.nn.Conv2d` for more details.
+
+
+    Raises:
+        TypeError: If `stride`, `padding` or `dilation` is neither an int nor a tuple.
+        TypeError: `groups` is not an int.
+        TypeError: If `bias` is not a Tensor.
+        ValueError: If  the shape of `bias` is not :math:`(C_{out})` .
+        ValueError: If `stride` or `dilation` is less than 1.
+        ValueError: If `pad_mode` is not one of 'same', 'valid' or 'pad'.
+        ValueError: If `padding` is a tuple/list whose length is not equal to 2.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.ones([10, 32, 32, 32]), mindspore.float32)
+        >>> weight = Tensor(np.ones([32, 32, 3, 3]), mindspore.float32)
+        >>> output = ops.extend.conv2d(x, weight)
+        >>> print(output.shape)
+        (10, 32, 30, 30)
+    """
+
+    def _convolution_same(input, weight, bias, dilation, groups):
+        """ convolution when mode is 'same' """
+        if isinstance(dilation, int):
+            dilation = (dilation,) * 2
+        validator.check_int(len(weight.shape), 4, validator.EQ, "weight.shape", 'conv2d')
+        validator.check_int(len(dilation), 2, validator.EQ, "dilation", 'conv2d')
+
+        # Calc padding info
+        need_pad_nd, pad_l, pad_r = _get_pad_info(dilation, weight)
+        if not need_pad_nd:
+            conv = _get_cache_prim(Convolution)(stride, pad_l, dilation, False, (0, 0), groups)
+            return conv(input, weight, bias)
+
+        # Calc pad nd info
+        pad_nd, pad_l = _get_pad_nd_info(pad_l, pad_r)
+        pad_nd_op = _get_cache_prim(ConstantPadND)()
+        padded_input = pad_nd_op(input, pad_nd, 0)
+        conv = _get_cache_prim(Convolution)(stride, pad_l, dilation, False, (0, 0), groups)
+        return conv(padded_input, weight, bias)
+
+    if isinstance(padding, int):
+        padding = (padding,) * 2
+
+    if isinstance(padding, (tuple, list)):
+        conv = _get_cache_prim(Convolution)(stride, padding, dilation, False, (0, 0), groups)
+        return conv(input, weight, bias)
+    if isinstance(padding, str):
+        if padding == 'valid':
+            conv = _get_cache_prim(Convolution)(stride, (0, 0), dilation, False, (0, 0), groups)
+            return conv(input, weight, bias)
+        if padding == 'same':
+            _check_stride_when_same_mode(stride)
+            return _convolution_same(input, weight, bias, dilation, groups)
+        raise ValueError(f"For conv2d, the parameter 'padding' must be 'same' or 'valid' when " \
+                            f"the type of 'padding' is string.")
+    raise TypeError(f"For conv2d, the parameter 'padding' must be a tuple/list " \
+                    f"or a string, but got {type(padding)}")
+
+
+def max_pool2d(input, kernel_size, stride=None, padding=0, dilation=1, *, ceil_mode=False, return_indices=False):
+    r"""
+    Performs a 2D max pooling on the input Tensor.
+
+    Typically, the input is a Tensor with shape :math:`(N_{in}, C_{in}, H_{in}, W_{in})`, outputs
+    regional maximum in the :math:`(H_{in}, W_{in})`-dimension. Given `kernel_size`
+    :math:`ks = (h_{ker}, w_{ker})` and `stride` :math:`s = (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:
+        input (Tensor): Tensor of shape :math:`(N_{in}, C_{in}, H_{in}, W_{in})` with data type of float32
+            in Ascend.
+        kernel_size (Union[int, tuple[int]]): The size of kernel used to take the maximum value and arg
+            value, is an int number that represents height and width of the kernel, or a tuple of
+            two int numbers that represent height and width respectively.
+        stride (Union[int, tuple[int], None]): The distance of kernel moving, an int number 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]]): An int number that represents the height and width of movement are both
+            strides, or a tuple of two int numbers that represent height and width of movement respectively.
+            Default: ``0`` .
+        dilation (Union[int, tuple[int]]): Control the stride of elements in the kernel. Default: ``1`` .
+        ceil_mode (bool): Whether to use ceil instead of floor to calculate output shape. Default: ``False`` .
+        return_indices (bool): Whether to output the indices of max value. Default: ``False`` .
+
+    Returns:
+        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`.
+
+        .. 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
+
+        - **argmax** (Tensor) - Index corresponding to the maximum value. In Ascend, data type is int32.
+          It will be return only when `return_indices` is True.
+
+    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
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.arange(20 * 16 * 50 * 32).reshape((20, 16, 50, 32)), mindspore.float32)
+        >>> output_tensor, argmax = ops.extend.max_pool2d(input, kernel_size=(3, 2), stride=(2, 1),
+                                                          ceil_mode=False, return_indices=True)
+        >>> print(output_tensor.shape)
+        (20, 16, 24, 31)
+        >>> print(argmax.shape)
+        (20, 16, 24, 31)
+    """
+    strides = stride if (stride is not None) else kernel_size
+    if return_indices:
+        max_pool_func_ = _get_cache_prim(MaxPoolWithIndices)(kernel_size, strides, padding, dilation, ceil_mode)
+        out, indices = max_pool_func_(input)
+    else:
+        max_pool_func_ = _get_cache_prim(MaxPoolWithMask)(kernel_size, strides, padding, dilation, ceil_mode)
+        out, indices = max_pool_func_(input)
+    if return_indices:
+        return out, indices
+    return out
+
+
+def batch_norm(input, running_mean, running_var, weight=None, bias=None, training=False, momentum=0.1, eps=1e-5):
+    r"""
+    Batch Normalization for input data and updated parameters.
+
+    Batch Normalization is widely used in convolutional neural networks. This operation
+    applies Batch Normalization over inputs to avoid internal covariate shift as described
+    in the paper `Batch Normalization: Accelerating Deep Network Training by Reducing Internal
+    Covariate Shift <https://arxiv.org/abs/1502.03167>`_. It rescales and recenters the
+    features using a mini-batch of data and the learned parameters can be described
+    in the following formula,
+
+    .. math::
+
+        y = \frac{x - mean}{\sqrt{variance + \epsilon}} * \gamma + \beta
+
+    where :math:`\gamma` is `weight`, :math:`\beta` is `bias`, :math:`\epsilon` is `eps`, :math:`mean` is the
+    mean of :math:`x`, :math:`variance` is the variance of :math:`x`.
+
+    .. warning::
+        - For Atlas 200/300/500 inference product,
+          the result accuracy fails to reach 1‰ due to the square root instruction.
+
+    Note:
+        - If `training` is `False`, `weight`, `bias`, `running_mean` and `running_var` are Tensors.
+        - If `training` is `True`, `weight`, `bias`, `running_mean` and `running_var` are Parameters.
+
+    Args:
+        input (Tensor): Tensor of shape :math:`(N, C, *)`, with bfloat16, float16 or float32 data type.
+        running_mean (Union[Tensor, Parameter]): The shape :math:`(C,)`, has the same data type with `weight`.
+        running_var (Union[Tensor, Parameter]): The shape :math:`(C,)`, has the same data type with `weight`.
+        weight (Union[Tensor, Parameter]): The shape :math:`(C,)`, with bfloat, float16 or float32 data type.
+        bias (Union[Tensor, Parameter]): The shape :math:`(C,)`, has the same data type with `weight`.
+        training (bool, optional): If `training` is `True`, `mean` and `variance` are computed during training.
+            If `training` is `False`, they're loaded from checkpoint during inference. Default: ``False`` .
+        momentum (float, optional): The hyper parameter to compute moving average for `running_mean` and `running_var`
+            (e.g. :math:`new\_running\_mean = (1 - momentum) * running\_mean + momentum * current\_mean`).
+            Default: ``0.1`` .
+        eps (float, optional): A small value added for numerical stability. Default: ``1e-5``.
+
+    Returns:
+        output_x (Tensor) - The same type and shape as the `input_x`. The shape is :math:`(N, C, *)`.
+
+    Raises:
+        TypeError: If `training` is not a bool.
+        TypeError: If dtype of `eps` or `momentum` is not float.
+        TypeError: If `input_x`, `weight`, `bias`, `running_mean` or `running_var` is not a Tensor.
+        TypeError: If dtype of `input_x`, `weight` is not bfloat16, float16 or float32.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input_x = Tensor([[1.0, 2.0], [3.0, 4.0]], mindspore.float32)
+        >>> running_mean = Tensor([0.5, 1.5], mindspore.float32)
+        >>> running_var = Tensor([0.1, 0.2], mindspore.float32)
+        >>> weight = Tensor([2.0, 2.0], mindspore.float32)
+        >>> bias = Tensor([-1.0, -1.0], mindspore.float32)
+        >>> output = ops.batch_norm(input_x, running_mean, running_var, weight, bias)
+        >>> print(output)
+        [[ 2.1621194  1.2360122]
+         [14.810596  10.180061 ]]
+    """
+    if weight is None:
+        weight = ops.ones([input.shape[1]], dtype=input.dtype)
+    if bias is None:
+        bias = ops.zeros([input.shape[1]], dtype=input.dtype)
+    batch_norm_op = BatchNormExt(training=training, momentum=momentum, eps=eps)
+    output = batch_norm_op(input, weight, bias, running_mean, running_var)
+    return output[0]
+
+
+
+__all__ = ['conv2d', 'max_pool2d', 'leaky_relu_ext', 'batch_norm']

mindspore/ops/function/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2022-2023 Huawei Technologies Co., Ltd
+# Copyright 2022-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.
@@ -99,6 +99,7 @@ from .array_func import (
     tensor_scatter_elements,
     scatter,
     scatter_add,
+    scatter_add_ext,
     scatter_mul,
     scatter_max,
     scatter_min,
@@ -129,6 +130,7 @@ from .array_func import (
     unsorted_segment_sum,
     col2im,
     split,
+    split_ext,
     tensor_split,
     vsplit,
     hsplit,
@@ -136,7 +138,6 @@ from .array_func import (
     index_fill,
     index_select,
     max,
-    argmax,
     min,
     population_count,
     topk,
@@ -163,6 +164,10 @@ from .array_func import (
     sort,
     top_k,
     deepcopy,
+    arange_ext,
+    zeros_like_ext,
+    ones_like_ext,
+    full_ext,
 )
 from .parameter_func import (
     assign,
@@ -175,6 +180,7 @@ from .math_func import (
     addn,
     absolute,
     abs,
+    argmax,
     argmin,
     angle,
     bincount,
@@ -194,6 +200,7 @@ from .math_func import (
     le,
     lerp,
     norm,
+    norm_ext,
     vector_norm,
     matrix_norm,
     round,
@@ -261,6 +268,7 @@ from .math_func import (
     matrix_determinant,
     det,
     linspace,
+    linspace_ext,
     lu_solve,
     matrix_solve,
     maximum,
@@ -366,6 +374,7 @@ from .math_func import (
     amin,
     amax,
     mean,
+    mean_ext,
     prod,
     all,
     any,
@@ -464,6 +473,7 @@ from .nn_func import (
     dropout3d,
     dense,
     deformable_conv2d,
+    embedding,
     fast_gelu,
     flip,
     fliplr,
@@ -479,6 +489,7 @@ from .nn_func import (
     interpolate,
     upsample,
     kl_div,
+    layer_norm,
     log_softmax,
     lrn,
     mish,
@@ -499,6 +510,7 @@ from .nn_func import (
     softplus,
     pdist,
     pad,
+    pad_ext,
     prelu,
     mirror_pad,
     nll_loss,
@@ -514,6 +526,7 @@ from .nn_func import (
     conv3d_transpose,
     conv1d,
     conv2d,
+    conv_transpose2d,
     sigmoid,
     logsigmoid,
     relu,
@@ -535,6 +548,8 @@ from .nn_func import (
     msort,
     channel_shuffle,
     hardsigmoid,
+    group_norm,
+    dropout_ext,
 )
 from .linalg_func import (
     cond,
@@ -585,6 +600,7 @@ from .random_func import (
     standard_laplace,
     random_categorical,
     uniform,
+    uniform_ext,
     standard_normal,
     random_gamma,
     uniform_candidate_sampler,
@@ -592,6 +608,7 @@ from .random_func import (
     log_uniform_candidate_sampler,
     shuffle,
     choice_with_mask,
+    normal_ext,
     normal,
     laplace,
     gamma,