mindspore 2.5.0__cp311-cp311-win_amd64.whl → 2.6.0rc1__cp311-cp311-win_amd64.whl

mindspore/mint/nn/functional.py

@@ -56,6 +56,7 @@ from mindspore.ops.function.nn_func import relu_
 # 14
 from mindspore.ops.function.nn_func import dropout_ext as dropout
 # 15
+from mindspore.ops.function.nn_func import conv1d_ext as 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
@@ -97,7 +98,7 @@ from mindspore.ops.function.nn_func import batch_norm_ext as batch_norm
 # 35
 
 # 36
-from mindspore.ops.functional import gelu
+from mindspore.ops.functional_overload import gelu
 # 37
 
 # 38
@@ -113,7 +114,7 @@ from mindspore.ops.functional import group_norm
 # 43
 
 # 44
-
+from mindspore.ops.auto_generate import soft_margin_loss
 # 45
 
 # 46
@@ -133,7 +134,7 @@ from mindspore.ops.functional import embedding
 # 53
 
 # 54
-
+from mindspore.ops.functional_overload import pixel_shuffle
 # 55
 
 # 56
@@ -175,7 +176,7 @@ from mindspore.ops.functional import embedding
 # 74
 
 # 75
-
+from mindspore.ops.function.nn_func import adaptive_max_pool2d
 # 76
 
 # 77
@@ -207,7 +208,7 @@ from mindspore.ops.auto_generate import avg_pool1d_ext as avg_pool1d
 # 90
 from mindspore.ops.function.nn_func import avg_pool2d_ext as avg_pool2d
 # 91
-
+from mindspore.ops.function.nn_func import avg_pool3d_ext as avg_pool3d
 # 92
 from mindspore.ops.auto_generate import leaky_relu_ext as leaky_relu
 # 93
@@ -242,6 +243,9 @@ from mindspore.ops.auto_generate import l1_loss_ext as l1_loss  # pylint: disabl
 #254
 from mindspore.ops.auto_generate import max_unpool2d_ext as max_unpool2d
 
+# 256
+from mindspore.ops.auto_generate import inplace_threshold as threshold_
+from mindspore.ops.auto_generate import threshold as threshold_op
 # 257
 
 # 258
@@ -251,7 +255,8 @@ from mindspore.ops.function.nn_func import mse_loss_ext as mse_loss
 # 323
 
 # 324
-from mindspore.ops.auto_generate import elu_ext as elu
+from mindspore.ops.auto_generate import elu_ext
+from mindspore.ops.auto_generate import inplace_elu
 
 # 421
 from mindspore.ops.auto_generate import flatten_ext as flatten
@@ -267,6 +272,8 @@ from mindspore.ops.function.nn_func import glu_ext as glu
 # 537
 from mindspore.ops.auto_generate import hardtanh as hardtanh_op
 from mindspore.ops.auto_generate import inplace_hardtanh as hardtanh_
+# 548
+from mindspore.ops.function.nn_func import kl_div_ext as kl_div
 # 556
 from mindspore.ops.function.nn_func import logsigmoid_ext as logsigmoid
 
@@ -277,53 +284,157 @@ from mindspore.ops.function.nn_func import cross_entropy_ext as cross_entropy
 from mindspore.ops.function.nn_func import nll_loss_ext as nll_loss
 
 
+def elu(input, alpha=1.0, inplace=False):
+    r"""
+    Exponential Linear Unit activation function
+
+    Applies the exponential linear unit function element-wise. The activation function is defined as:
+
+    .. math::
+        ELU_{i} =
+        \begin{cases}
+        x_i, &\text{if } x_i \geq 0; \cr
+        \alpha * (\exp(x_i) - 1), &\text{otherwise.}
+        \end{cases}
+
+    where :math:`x_i` represents the element of the input and :math:`\alpha` represents the `alpha` parameter, and
+    `alpha` represents the smoothness of the ELU.
+
+    ELU Activation Function Graph:
+
+    .. image:: ../images/ELU.png
+        :align: center
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input of ELU is a Tensor of any dimension.
+        alpha (float, optional): The alpha value of ELU, the data type is float. Default: ``1.0``.
+        inplace (bool, optional): Whether to use inplace mode, the data type is bool. Default: ``False``.
+
+    Returns:
+        Tensor, with the same shape and type as the `input`.
+
+    Raises:
+        RuntimeError: If the dtype of `input` is not float16, float32 or bfloat16.
+        TypeError: If the dtype of `alpha` is not float.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> import numpy as np
+        >>> input = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float32)
+        >>> output = mint.nn.functional.elu(input)
+        >>> print(output)
+        [-0.63212055  -0.86466473  0.  2.  1.]
+    """
+    if inplace:
+        return inplace_elu(input, alpha)
+    return elu_ext(input, alpha)
+
+
+def elu_(input, alpha=1.0):
+    r"""
+    Exponential Linear Unit activation function
+
+    Applies the exponential linear unit function inplace element-wise. The activation function is defined as:
+
+    .. math::
+        ELU_{i} =
+        \begin{cases}
+        x_i, &\text{if } x_i \geq 0; \cr
+        \alpha * (\exp(x_i) - 1), &\text{otherwise.}
+        \end{cases}
+
+    where :math:`x_i` represents the element of the input and :math:`\alpha` represents the `alpha` parameter, and
+    `alpha` represents the smoothness of the ELU.
+
+    ELU Activation Function Graph:
+
+    .. image:: ../images/ELU.png
+        :align: center
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input of ELU is a Tensor of any dimension.
+        alpha (float, optional): The alpha value of ELU, the data type is float and `alpha` should be
+            greater than 0. Default: ``1.0``.
+
+    Returns:
+        Tensor, with the same shape and type as the `input`.
+
+    Raises:
+        RuntimeError: If the dtype of `input` is not float16, float32 or bfloat16.
+        TypeError: If the dtype of `alpha` is not float.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> import numpy as np
+        >>> input = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float32)
+        >>> mint.nn.functional.elu_(input)
+        >>> print(input)
+        [-0.63212055  -0.86466473  0.  2.  1.]
+    """
+    return inplace_elu(input, alpha)
+
+
 def hardtanh(input, min_val=-1.0, max_val=1.0, inplace=False):
     r"""
-     Applies the hardtanh activation function element-wise. The activation function is defined as:
+    Applies the hardtanh activation function element-wise. The activation function is defined as:
 
-     .. math::
-         \text{hardtanh}(input) = \begin{cases}
-             max\_val, & \text{ if } input > max\_val \\
-             min\_val, & \text{ if } input < min\_val \\
-             input, & \text{ otherwise. }
-         \end{cases}
+    .. math::
+        \text{hardtanh}(input) = \begin{cases}
+            max\_val, & \text{ if } input > max\_val \\
+            min\_val, & \text{ if } input < min\_val \\
+            input, & \text{ otherwise. }
+        \end{cases}
 
-     Linear region range :math:`[min\_val, max\_val]` can be adjusted using `min_val` and `max_val`.
+    Linear region range :math:`[min\_val, max\_val]` can be adjusted using `min_val` and `max_val`.
 
-     Hardtanh Activation Function Graph:
+    Hardtanh Activation Function Graph:
 
-     .. image:: ../images/Hardtanh.png
-         :align: center
+    .. image:: ../images/Hardtanh.png
+        :align: center
 
     .. warning::
         This is an experimental optimizer API that is subject to change.
 
-     Args:
-         input (Tensor): Input Tensor.
-         min_val (Union[bool, int, float], optional): Minimum value of the linear region range. Default: ``-1.0`` .
-         max_val (Union[bool, int, float], optional): Maximum value of the linear region range. Default: ``1.0`` .
-         inplace (bool, optional): Whether to apply erasing inplace. Default: ``False``.
-
-     Returns:
-         Tensor, with the same dtype and shape as `input`.
-
-     Raises:
-         TypeError: If `input` is not a Tensor.
-         TypeError: If dtype of `input` is not one of: int8, int16, int32, int64, uint8, float16, float32, bfloat16.
-         TypeError: If dtype of `min_val` is neither float nor int.
-         TypeError: If dtype of `max_val` is neither float nor int.
-
-     Supported Platforms:
-         ``Ascend``
-
-     Examples:
-         >>> import mindspore
-         >>> from mindspore import Tensor, mint
-         >>> x = Tensor([-1, -2, 0, 2, 1], mindspore.float16)
-         >>> output = mint.nn.functional.hardtanh(x, min_val=-1.0, max_val=1.0, inplace=False)
-         >>> print(output)
-         [-1. -1.  0.  1.  1.]
-     """
+    Args:
+        input (Tensor): Input Tensor.
+        min_val (Union[bool, int, float], optional): Minimum value of the linear region range. Default: ``-1.0`` .
+        max_val (Union[bool, int, float], optional): Maximum value of the linear region range. Default: ``1.0`` .
+        inplace (bool, optional): Whether to apply erasing inplace. Default: ``False``.
+
+    Returns:
+        Tensor, with the same dtype and shape as `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If dtype of `input` is not one of: int8, int16, int32, int64, uint8, float16, float32, bfloat16.
+        TypeError: If dtype of `min_val` is neither float nor int.
+        TypeError: If dtype of `max_val` is neither float nor int.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> x = Tensor([-1, -2, 0, 2, 1], mindspore.float16)
+        >>> output = mint.nn.functional.hardtanh(x, min_val=-1.0, max_val=1.0, inplace=False)
+        >>> print(output)
+        [-1. -1.  0.  1.  1.]
+    """
     if inplace:
         return hardtanh_(input, min_val, max_val)
     return hardtanh_op(input, min_val, max_val)
@@ -551,8 +662,8 @@ def one_hot(tensor, num_classes=-1):
 
     Args:
         tensor (Tensor): A tensor of indices. Tensor of shape :math:`(X_0, \ldots, X_n)`.
-            Data type must be int32 or int64.
-        num_classes (int): A scalar defining the depth of the one-hot dimension, default: ``-1``.
+            Data type must be int32 or int64. Dimension cannot be greater than 7.
+        num_classes (int, optional): A scalar defining the depth of the one-hot dimension, default: ``-1``.
 
     Returns:
         Tensor, one-hot tensor.
@@ -685,8 +796,8 @@ def log_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:`NCHW`,
-    the channel feature map refers to a 2-dimensional feature map with the shape of :math:`HW`).
+    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].
@@ -706,9 +817,9 @@ def dropout2d(input, p=0.5, training=True):
     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): The dropping probability of a channel, between 0 and 1, e.g. `p` = 0.8,
+        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): If `training` is True, applying dropout, otherwise, not applying. Default: ``True`` .
+        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`.
@@ -831,27 +942,73 @@ def upsample(input, size=None, scale_factor=None, mode="nearest", align_corners=
     return interpolate(input, size, scale_factor, mode, align_corners)
 
 
+def threshold(input, threshold, value, inplace=False):  # pylint: disable=W0621
+    r"""
+    Compute the Threshold activation function element-wise.
+
+    The Threshold is defined as:
+
+    .. math::
+        y =
+        \begin{cases}
+        x, &\text{ if } x > \text{threshold} \\
+        \text{value}, &\text{ otherwise }
+        \end{cases}
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input Tensor.
+        threshold (Union[int, float]): The value of the threshold.
+        value (Union[int, float]): The value to replace with when element is less than threshold.
+        inplace (bool, optional): Whether to apply erasing inplace. Default: ``False``.
+
+    Returns:
+        Tensor, the same shape and data type as the input.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `threshold` is not a float or an int.
+        TypeError: If `value` is not a float or an int.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> inputs = mindspore.Tensor([0.0, 2, 3], mindspore.float32)
+        >>> outputs = mint.nn.functional.threshold(inputs, 1, 100)
+        >>> print(outputs)
+        [100.   2.   3.]
+    """
+    if inplace is True:
+        return threshold_(input, threshold, value)
+    return threshold_op(input, threshold, value)
+
+
 def adaptive_avg_pool3d(input, output_size):
     r"""
     Performs 3D adaptive average pooling on a multi-plane input signal.
     That is, for any input size, the size of the specified output is :math:`(D, H, W)`.
     The number of output features is equal to the number of input planes.
 
-    Suppose the last 3 dimension size of x is :math:`(inD, inH, inW)`, the last 3 dimension size of output is
-    :math:`(outD, outH, outW)`.
+    Suppose the last 3 dimension size of x is :math:`(D_{in}, H_{in}, W_{in})`, the last 3 dimension size of output is
+    :math:`(D_{out}, H_{out}, W_{out})`.
 
     .. math::
         \begin{array}{ll} \\
-            \forall \quad od \in [0,outD-1], oh \in [0,outH-1], ow \in [0,outW-1]\\
+            \forall \quad od \in [0, D_{out}-1], oh \in [0, H_{out}-1], ow \in [0, W_{out}-1] \\
             output[od,oh,ow] = \\
-            \qquad mean(x[istartD:iendD+1,istartH:iendH+1,istartW:iendW+1])\\
-            where,\\
-            \qquad istartD= \left\lceil \frac{od * inD}{outD} \right\rceil \\
-            \qquad iendD=\left\lfloor \frac{(od+1)* inD}{outD} \right\rfloor \\
-            \qquad istartH=\left\lceil \frac{oh * inH}{outH} \right\rceil \\
-            \qquad iendH=\left\lfloor \frac{(oh+1) * inH}{outH} \right\rfloor \\
-            \qquad istartW=\left\lceil \frac{ow * inW}{outW} \right\rceil \\
-            \qquad iendW=\left\lfloor \frac{(ow+1) * inW}{outW} \right\rfloor
+            \qquad mean(x[D_{istart}:D_{iend}+1,H_{istart}:H_{iend}+1,W_{istart}:W_{iend}+1]) \\
+            where, \\
+            \qquad D_{istart}= \left\lceil \frac{od * D_{in}}{D_{out}} \right\rceil \\
+            \qquad D_{iend}=\left\lfloor \frac{(od+1)* D_{in}}{D_{out}} \right\rfloor \\
+            \qquad H_{istart}=\left\lceil \frac{oh * H_{in}}{H_{out}} \right\rceil \\
+            \qquad H_{iend}=\left\lfloor \frac{(oh+1) * H_{in}}{H_{out}} \right\rfloor \\
+            \qquad W_{istart}=\left\lceil \frac{ow * W_{in}}{W_{out}} \right\rceil \\
+            \qquad W_{iend}=\left\lfloor \frac{(ow+1) * W_{in}}{W_{out}} \right\rfloor
         \end{array}
 
     .. warning::
@@ -908,6 +1065,53 @@ def adaptive_avg_pool3d(input, output_size):
     return adaptive_avg_pool3d_ext(input, output_size)
 
 
+def adaptive_max_pool1d(input, output_size, return_indices=False):
+    r"""
+    Performs 1D adaptive max pooling on a multi-plane input signal.
+    That is, for any input size, the size of the specified output is L.
+    The number of output features is equal to the number of input features.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input of adaptive_max_pool1d, which is a 2D or 3D tensor,
+            with float16, float32 or float64 data type.
+        output_size (int): The target output feature size. `output_size` is an integer.
+        return_indices (bool, optional): Whether to return the index of the maximum value. Default: ``False`` .
+
+    Returns:
+        Union(Tensor, tuple(Tensor, Tensor)).
+
+        - If `return_indices` is False, output is a Tensor, with shape :math:`(N, C, L_{out})`. It has the same data
+          type as `input`.
+        - If `return_indices` is True, output is a Tuple of 2 Tensors, representing the result and where the max
+          values are generated.
+
+    Raises:
+        TypeError: If `input` is not a tensor.
+        TypeError: If dtype of `input` is not float16, float32 or float64.
+        TypeError: If `output_size` is not int or tuple.
+        TypeError: If `return_indices` is not a bool.
+        ValueError: If `output_size` is a tuple and the length of `output_size` is not 1.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> input = Tensor([[2,3],[3,4]],dtype=mindspore.float16)
+        >>> output = mint.nn.functional.adaptive_max_pool1d(input, 3)
+        >>> print(output)
+        [[2.  3.  3. ]
+         [3.  4.  4. ]]
+    """
+    if return_indices:
+        return ops.auto_generate.gen_ops_prim.adaptive_max_pool1d_op(input, output_size)
+    return ops.auto_generate.gen_ops_prim.adaptive_max_pool1d_op(input, output_size)[0]
+
+
 __all__ = [
     'conv_transpose2d',
     'max_pool2d',
@@ -943,6 +1147,7 @@ __all__ = [
     # 14
     'dropout',
     # 15
+    'conv1d',
     'conv2d',
     # 16
     'log_softmax',
@@ -1002,7 +1207,7 @@ __all__ = [
     # 43
 
     # 44
-
+    'soft_margin_loss',
     # 45
 
     # 46
@@ -1022,7 +1227,7 @@ __all__ = [
     # 53
 
     # 54
-
+    'pixel_shuffle',
     # 55
 
     # 56
@@ -1090,7 +1295,7 @@ __all__ = [
     # 87
 
     # 88
-
+    'avg_pool3d',
     # 89
     'avg_pool1d',
     # 90
@@ -1119,6 +1324,12 @@ __all__ = [
     'adaptive_avg_pool3d',
     # 254
     'max_unpool2d',
+    # 256
+    'threshold',
+    'threshold_',
+
+    # 288
+    'adaptive_max_pool2d',
 
     # 312
     'normalize',
@@ -1127,13 +1338,14 @@ __all__ = [
 
     # 324
     'elu',
+    'elu_',
     # 325
 
     #556
     'logsigmoid',
 
     # 257
-
+    'adaptive_max_pool1d',
     # 258
     'mse_loss',
     # 259
@@ -1141,6 +1353,10 @@ __all__ = [
     'adaptive_avg_pool1d',
 
     'adaptive_avg_pool2d',
+
+    # 350
+    'conv1d',
+
     # 393
     'dropout2d',
     # 421
@@ -1151,4 +1367,6 @@ __all__ = [
     'hardtanh',
     'hardtanh_',
     'relu6',
+    # 548
+    'kl_div',
 ]

mindspore/mint/nn/layer/__init__.py

@@ -30,7 +30,9 @@ from mindspore.mint.nn.layer.normalization import LayerNorm
 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
 from mindspore.mint.nn.layer.pooling import AdaptiveAvgPool3d
@@ -45,8 +47,10 @@ __all__ = [
     'LogSigmoid',
     'SiLU',
     'Dropout2d',
+    'AdaptiveMaxPool1d',
     'AdaptiveAvgPool1d',
     'AdaptiveAvgPool2d',
     'AdaptiveAvgPool3d',
     'SyncBatchNorm',
+    'Threshold',
 ]

mindspore/mint/nn/layer/_functions.py

@@ -1,14 +1,17 @@
 import mindspore
 from mindspore import Tensor
 from mindspore import context
+import mindspore.communication
+import mindspore.communication.comm_func
 from mindspore.nn.cell import Cell
 from mindspore.ops.auto_generate.gen_ops_prim import BatchNormReduceGrad
 from mindspore.ops.auto_generate.gen_ops_prim import BatchNormElemtGrad
 from mindspore.communication import GlobalComm
 from mindspore.ops import ReduceOp
-from mindspore._c_expression import Tensor as Tensor_
+from mindspore._c_expression import TensorPy as Tensor_
 from mindspore.communication._comm_helper import _get_size_helper, HCCL_WORLD_COMM_GROUP
 from mindspore.ops._primitive_cache import _get_cache_prim
+from mindspore.communication.comm_func import all_gather_into_tensor as all_gather_into_tensor_dy
 from mindspore.ops import operations as P
 from mindspore import ops, mint
 
@@ -111,7 +114,8 @@ def bprop_pynative(input_x, weight, bias, running_mean, running_var, eps, moment
         num_channels = sum_dy_shape[0]
         combined = mint.cat([sum_dy, sum_dy_xmu], dim=0)
 
-        new_combined = all_reduce(combined, group=process_group)
+        new_combined, _ = mindspore.communication.comm_func.all_reduce(
+            combined, group=process_group)
 
         sum_dy, sum_dy_xmu = mint.split(new_combined, num_channels)
 
@@ -227,7 +231,7 @@ def construct_pynative(input, weight, bias, running_mean, running_var, eps, mome
     # batch_norm_gather_stats_with_counts calculates global mean & invstd based on
     # all gathered mean, invstd and count.
     # world_size * (2C + 1)
-    combined = all_gather_into_tensor(combined, process_group)
+    combined, _ = all_gather_into_tensor_dy(combined, process_group)
     combined = ops.reshape(combined, [world_size, -1])
     # world_size * (2C + 1) -> world_size * C, world_size * C, world_size * 1
     mean_val_all, invstd_val_all, count_val_all = mint.split(