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

mindspore/ops/operations/nn_ops.py

@@ -30,15 +30,14 @@ from mindspore.ops.primitive import Primitive
 from mindspore.ops.primitive import PrimitiveWithInfer
 from mindspore.ops.primitive import PrimitiveWithCheck
 from mindspore.ops.primitive import prim_attr_register
-from ..auto_generate import (CeLU, Flatten, LogSoftmax, ReLU, ReLU6, Dense, Tanh,
+from ..auto_generate import (CeLU, Flatten, LogSoftmax, ReLU, ReLU6, Dense,
                              Elu, Sigmoid, Softmax, SoftplusExt, HSwish, HSigmoid, AvgPool, BiasAdd,
-                             NLLLoss, OneHot, GeLU, FastGeLU, PReLU, RmsNorm,
+                             NLLLoss, OneHot, GeLU, FastGeLU, PReLU,
                              GridSampler3D, GridSampler2D, LayerNorm, LayerNormExt, HShrink, AdamWeightDecay, Dropout,
                              ApplyRotaryPosEmb, PagedAttention, PagedAttentionMask, ReshapeAndCache,
                              FlashAttentionScore, Embedding, UpsampleNearest1D, UpsampleNearest2D,
                              UpsampleNearest3D, UpsampleTrilinear3D,
-                             UpsampleBilinear2D, UpsampleLinear1D,
-                             BinaryCrossEntropy, BCEWithLogitsLoss)
+                             UpsampleBilinear2D, UpsampleLinear1D)
 from .manually_defined import BatchNorm
 
 
@@ -569,6 +568,36 @@ class SeLU(Primitive):
         self.init_prim_io_names(inputs=['input_x'], outputs=['output'])
 
 
+class Tanh(Primitive):
+    r"""
+    Computes hyperbolic tangent of input element-wise.
+
+    Refer to :func:`mindspore.ops.tanh` for more details.
+
+    Inputs:
+        - **input_x** (Tensor) - Input Tensor of any dimension.
+
+    Outputs:
+        Tensor, with the same type and shape as the `input_x`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``  ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
+        >>> tanh = ops.Tanh()
+        >>> output = tanh(input_x)
+        >>> print(output)
+        [0.7615941 0.9640276 0.9950547 0.9993293 0.9999092]
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize Tanh"""
+        self.init_prim_io_names(inputs=['x'], outputs=['y'])
 
 
 class FusedBatchNorm(Primitive):
@@ -3207,6 +3236,105 @@ class SigmoidCrossEntropyWithLogits(Primitive):
         self.init_prim_io_names(inputs=['predict', 'target'], outputs=['loss'])
 
 
+class BCEWithLogitsLoss(PrimitiveWithInfer):
+    r"""
+    Adds sigmoid activation function to input `logits`, and uses the given logits to compute binary cross entropy
+    between the logits and the label.
+
+    Sets input logits as :math:`X`, input label as :math:`Y`, input weight as :math:`W`, output as :math:`L`. Then,
+
+    .. math::
+
+        \begin{array}{ll} \\
+            p_{ij} = sigmoid(X_{ij}) = \frac{1}{1 + e^{-X_{ij}}} \\
+            L_{ij} = -[Y_{ij}log(p_{ij}) + (1 - Y_{ij})log(1 - p_{ij})]
+        \end{array}
+
+    :math:`i` indicates the :math:`i^{th}` sample, :math:`j` indicates the category. Then,
+
+    .. math::
+        \ell(x, y) = \begin{cases}
+        L, & \text{if reduction} = \text{'none';}\\
+        \operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
+        \operatorname{sum}(L),  & \text{if reduction} = \text{'sum'.}
+        \end{cases}
+
+    :math:`\ell` indicates the method of calculating the loss. There are three methods:
+    the first method is to provide the loss value directly,
+    the second method is to calculate the average value of all losses,
+    and the third method is to calculate the sum of all losses.
+
+    This operator will multiply the output by the corresponding weight.
+    The tensor `weight` assigns different weights to each piece of data in the batch,
+    and the tensor `pos_weight` adds corresponding weights to the positive examples of each category.
+
+    In addition, it can trade off recall and precision by adding weights to positive examples.
+    In the case of multi-label classification the loss can be described as:
+
+    .. math::
+        \begin{array}{ll} \\
+            p_{ij,c} = sigmoid(X_{ij,c}) = \frac{1}{1 + e^{-X_{ij,c}}} \\
+            L_{ij,c} = -[P_{c}Y_{ij,c} * log(p_{ij,c}) + (1 - Y_{ij,c})log(1 - p_{ij,c})]
+        \end{array}
+
+    where c is the class number (c>1 for multi-label binary classification, c=1 for single-label binary classification),
+    n is the number of the sample in the batch and :math:`P_c` is the weight of the positive answer for the class c.
+    :math:`P_c>1` increases the recall, :math:`P_c<1` increases the precision.
+
+    Args:
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the weighted mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
+
+    Inputs:
+        - **logits** (Tensor) - Input logits. Data type must be float16 or float32.
+          Tensor of shape :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
+        - **label** (Tensor) - Ground truth label, has the same shape as `logits`.
+          Data type must be float16 or float32.
+        - **weight** (Tensor) - A rescaling weight applied to the loss of each batch element. It can be
+          broadcast to a tensor with shape of `logits`. Data type must be float16 or float32.
+        - **pos_weight** (Tensor) - A weight of positive examples. Must be a vector with length equal to the
+          number of classes. It can be broadcast to a tensor with shape of `logits`.
+          Data type must be float16 or float32.
+
+    Outputs:
+        Tensor or Scalar, if `reduction` is ``'none'``, it's a tensor with the same shape and type as input `logits`.
+        Otherwise, the output is a scalar.
+
+    Raises:
+        TypeError: If any input is not Tensor.
+        TypeError: If data type of any input is neither float16 nor float32.
+        TypeError: If data type of `reduction` is not string.
+        ValueError: If `weight` or `pos_weight` can not be broadcast to a tensor with shape of `logits`.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'`` or ``'sum'``.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> logits = Tensor(np.array([[-0.8, 1.2, 0.7], [-0.1, -0.4, 0.7]]), mindspore.float32)
+        >>> label = Tensor(np.array([[0.3, 0.8, 1.2], [-0.6, 0.1, 2.2]]), mindspore.float32)
+        >>> weight = Tensor(np.array([1.0, 1.0, 1.0]), mindspore.float32)
+        >>> pos_weight = Tensor(np.array([1.0, 1.0, 1.0]), mindspore.float32)
+        >>> loss = ops.BCEWithLogitsLoss()
+        >>> output = loss(logits, label, weight, pos_weight)
+        >>> print(output)
+        0.3463612
+    """
+
+    @prim_attr_register
+    def __init__(self, reduction='mean'):
+        """Initialize BCEWithLogitsLoss"""
+        super().__init__("BCEWithLogitsLoss")
+        self.reduction = validator.check_string(reduction, ['none', 'sum', 'mean'], 'reduction', self.name)
+
+
 class Pad(Primitive):
     r"""
     Pads the input tensor according to the paddings.
@@ -3520,9 +3648,8 @@ class ROIAlign(Primitive):
 
 
     Inputs:
-        - **features** (Tensor) - The input features, whose shape must be :math:`(N, C, H, W)`, with data type of
-          float16 or float32.
-        - **rois** (Tensor) - The shape is :math:`(rois\_n, 5)`, with data type of float16 or float32.
+        - **features** (Tensor) - The input features, whose shape must be :math:`(N, C, H, W)`.
+        - **rois** (Tensor) - The shape is :math:`(rois\_n, 5)`. With data type of float16 or float32.
           `rois_n` represents the number of RoI. The size of the second dimension must be `5` and the `5` colunms
           are :math:`(image\_index, top\_left\_x, top\_left\_y, bottom\_right\_x, bottom\_right\_y)`.
           `image_index` represents the index of image. `top_left_x` and `top_left_y` represent the `x, y`
@@ -4313,6 +4440,86 @@ class KLDivLoss(Primitive):
         self.reduction = validator.check_string(reduction, support_mode, 'reduction', self.name)
 
 
+class BinaryCrossEntropy(Primitive):
+    r"""
+    Computes the binary cross entropy between the logits and the labels.
+
+    Sets logits as :math:`x`, labels as :math:`y`, output as :math:`\ell(x, y)`.
+    Let,
+
+    .. math::
+        L = \{l_1,\dots,l_N\}^\top, \quad
+        l_n = - w_n \left[ y_n \cdot \log x_n + (1 - y_n) \cdot \log (1 - x_n) \right]
+
+    In which, :math:`L` indicates the loss of all batch_sizes, :math:`l` indicates the loss of one batch_size,
+    and n indicates one batch_size in the 1-N range, :math:`w_n` indicates the
+    weight of :math:`n`-th batch of binary cross entropy. Then,
+
+    .. math::
+        \ell(x, y) = \begin{cases}
+        L, & \text{if reduction} = \text{'none';}\\
+        \operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
+        \operatorname{sum}(L),  & \text{if reduction} = \text{'sum'.}
+        \end{cases}
+
+    .. warning::
+        - The value of :math:`x` must range from 0 to 1.
+
+    Args:
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the weighted mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
+
+    Inputs:
+        - **logits** (Tensor) - The predictive value whose data type must be float16 or float32,
+          The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
+        - **labels** (Tensor) - The target value which has the same shape and data type as `logits`.
+        - **weight** (Tensor, optional) - A rescaling weight applied to the loss of each batch element.
+          And it must have the same shape and data type as `logits`. Default: ``None`` .
+
+    Outputs:
+        Tensor or Scalar. Returns Tensor that has the same dtype and shape as `logits` if `reduction` is 'none'.
+        Otherwise, returns a scalar Tensor.
+
+    Raises:
+        TypeError: If dtype of `logits`, `labels` or `weight` (if given) is neither float16 nor float32.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'`` or ``'sum'``.
+        ValueError: If shape of `labels` is not the same as `logits` or `weight` (if given).
+        TypeError: If `logits`, `labels` or `weight` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, nn, ops
+        >>> class Net(nn.Cell):
+        ...     def __init__(self):
+        ...         super(Net, self).__init__()
+        ...         self.binary_cross_entropy = ops.BinaryCrossEntropy()
+        ...     def construct(self, logits, labels, weight):
+        ...         result = self.binary_cross_entropy(logits, labels, weight)
+        ...         return result
+        ...
+        >>> net = Net()
+        >>> logits = Tensor(np.array([0.2, 0.7, 0.1]), mindspore.float32)
+        >>> labels = Tensor(np.array([0., 1., 0.]), mindspore.float32)
+        >>> weight = Tensor(np.array([1, 2, 2]), mindspore.float32)
+        >>> output = net(logits, labels, weight)
+        >>> print(output)
+        0.38240486
+    """
+
+    @prim_attr_register
+    def __init__(self, reduction='mean'):
+        """Initialize BinaryCrossEntropy."""
+        self.reduction = validator.check_string(reduction, ['none', 'mean', 'sum'], 'reduction', self.name)
+
+
 class ApplyAdaMax(Primitive):
     r"""
     Updates relevant entries according to the adamax scheme.
@@ -8163,7 +8370,7 @@ class ApplyAdamWithAmsgradV2(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
         >>> import numpy as np
@@ -9658,12 +9865,38 @@ class IncreFlashAttention(Primitive):
                                 outputs=["attention_out"])
 
 
-class AllFinite(Primitive):
+class RmsNorm(Primitive):
     r"""
-    Check all gradients is finite.
+    The RmsNorm operator is a normalization operation, and its formula is:
+
+    .. math::
+        y=\frac{x_i}{\sqrt{\frac{1}{n}}\sum_{i=1}^{n}{ x_i^2}+\varepsilon  }\gamma_i
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        epsilon (float): prevent division by 0, default value is `1e-6`
+
+    Inputs:
+        - **input_x** (Tensor) - Input data of RmsNorm, support data type: float16, float32, bfloat16.
+        - **gamma** (Tensor) - Support data type: float16, float32, bfloat16.
+
+    Outputs:
+        - **y** (Tensor) - Has the same type and shape with `input_x`.
+        - **rstd** (Tensor) - Has the same type with `input_x`, used by gradient calculation.
+
+    Raises:
+        TypeError: If data type of `input_x` is not one of the following: float16, float32, bfloat16.
+        TypeError: If data type of `gamma` is not one of the following: float16, float32, bfloat16.
+        TypeError: If data type of "input_x" is not the same with the data type of "gamma"
+
+    Supported Platforms:
+        ``Ascend``
     """
+
     @prim_attr_register
-    def __init__(self):
-        """Initialize"""
-        self.init_prim_io_names(inputs=['gradients'],
-                                outputs=["is_finite"])
+    def __init__(self, epsilon=1e-6):
+        """Initialize Dense."""
+        validator.check_value_type("epsilon", epsilon, [float], self.name)
+        self.init_prim_io_names(inputs=['x', 'gamma'], outputs=["y", "rstd"])

mindspore/ops/operations/other_ops.py

@@ -430,7 +430,7 @@ class Partial(Primitive):
 
     Examples:
         >>> from mindspore import Tensor
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> def show_input(x, y, z):
         ...     return x, y, z
         >>> partial = ops.Partial()
@@ -487,7 +487,7 @@ class Depend(Primitive):
         >>> import numpy as np
         >>> import mindspore
         >>> import mindspore.nn as nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> class Net(nn.Cell):
         ...     def __init__(self):
@@ -561,7 +561,7 @@ class StopGradient(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> from mindspore import dtype as mstype
         >>> def net(x, y):

mindspore/ops/operations/random_ops.py

@@ -813,7 +813,7 @@ class RandomChoiceWithMask(Primitive):
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> rnd_choice_mask = ops.RandomChoiceWithMask()
-        >>> input_x = Tensor(np.ones(shape=[240000, 4]).astype(np.bool_))
+        >>> input_x = Tensor(np.ones(shape=[240000, 4]).astype(np.bool))
         >>> output_y, output_mask = rnd_choice_mask(input_x)
         >>> result = output_y.shape
         >>> print(result)

mindspore/ops/operations/sparse_ops.py

@@ -584,7 +584,7 @@ class SparseTensorDenseAdd(Primitive):
 
     Examples:
         >>> from mindspore import Tensor
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import dtype as mstype
         >>> x1_indices = Tensor([[0, 0], [0, 1]], dtype=mstype.int64)
         >>> x1_values = Tensor([1, 1], dtype=mstype.float32)

mindspore/ops/primitive.py

@@ -21,8 +21,7 @@ import numpy as np
 from mindspore.common.api import _wrap_func
 from mindspore.log import _LogActionOnce
 from mindspore import context, log as logger
-from mindspore.parallel._utils import _is_in_auto_parallel_mode, _is_in_data_parallel_mode, \
-    _is_in_hybrid_parallel_mode, SUPPORTED_TUPLE_IN_TUPLE_STRATEGY
+from mindspore.parallel._utils import _is_in_auto_parallel_mode, _is_in_data_parallel_mode, _is_in_hybrid_parallel_mode
 from mindspore.parallel._ps_context import _is_ps_mode, _is_role_sched
 from mindspore.parallel.shard import Layout
 from mindspore.common.api import _pynative_executor
@@ -74,7 +73,7 @@ class Primitive(Primitive_):
             value (Any): Attribute value.
 
         Examples:
-            >>> from mindspore import ops
+            >>> import mindspore.ops as ops
             >>> a = ops.Add()
             >>> a = a.add_prim_attr("attr",1)
             >>> out = a.attrs["attr"]
@@ -112,7 +111,7 @@ class Primitive(Primitive_):
             device_target (str): The target device to run, support "Ascend", "GPU", and "CPU".
 
         Examples:
-            >>> from mindspore import ops
+            >>> import mindspore.ops as ops
             >>> a = ops.Add()
             >>> a = a.set_device("GPU")
             >>> print(a.primitive_target)
@@ -168,7 +167,7 @@ class Primitive(Primitive_):
                 raise TypeError(f'The element of strategy must be tuple/Layout type, but got:{type(in_ele)}')
             if isinstance(in_ele, tuple):
                 for in_value in in_ele:
-                    if not isinstance(in_value, int) and self.name not in SUPPORTED_TUPLE_IN_TUPLE_STRATEGY:
+                    if not isinstance(in_value, int):
                         raise TypeError(f'The {log_info}: {strategy} of {self.name} is not valid,'
                                         f' the value of strategy must be int type, but got:{type(in_value)}')
                 is_layout.append(False)
@@ -222,7 +221,7 @@ class Primitive(Primitive_):
         Args:
             name (str): Attribute Name.
         Examples:
-            >>> from mindspore import ops
+            >>> import mindspore.ops as ops
             >>> a = ops.Add()
             >>> a = a.add_prim_attr("attr",1)
             >>> a = a.del_prim_attr("attr")
@@ -331,7 +330,7 @@ class Primitive(Primitive_):
             instance_name (str): Instance name of primitive operator set by user.
 
         Examples:
-            >>> from mindspore import ops
+            >>> import mindspore.ops as ops
             >>> a = ops.Add()
             >>> a = a.set_prim_instance_name("add")
             >>> print(a.instance_name)
@@ -416,7 +415,7 @@ class Primitive(Primitive_):
             inputs (list[str]): list of inputs names.
             outputs (list[str]): list of outputs names.
         Examples:
-            >>> from mindspore import ops
+            >>> import mindspore.ops as ops
             >>> a = ops.Add()
             >>> a.init_prim_io_names(["x","y"],["sum"])
             >>> print(a.input_names)
@@ -504,7 +503,7 @@ class Primitive(Primitive_):
 
         Examples:
             >>> from mindspore import context
-            >>> from mindspore import ops
+            >>> import mindspore.ops as ops
             >>> context.set_context(mode=context.GRAPH_MODE)
             >>> matmul = ops.MatMul()
             >>> matmul.place('MS_WORKER', 0)

mindspore/ops/silent_check.py

@@ -31,10 +31,10 @@ NPU_ASD_ENABLE = 'NPU_ASD_ENABLE'
 
 class ASDBase:
     """
-    ASDBase is the base class of operator with feature value detection in python.
+    ASDBase is the base class of operator with accuracy-sensitive detection feature in python.
 
     Args:
-        cls (Primitive): Original operator requiring feature value detection.
+        cls (Primitive): Original operator requiring accuracy-sensitive detection feature.
         args (tuple):  A variable parameter tuple to the original operator.
         kwargs (dict): A variable parameter dictionary passed the original operator.
 
@@ -90,11 +90,11 @@ class ASDBase:
 
     def generate_params(self):
         """
-        Generate support params for feature value detection.
+        Generate support params for accuracy-sensitive detection.
 
         Returns:
             tuple consisting of four elements.
-            The derived class initializes the parameters required for feature value detection by calling
+            The derived class initializes the parameters required for accuracy-sensitive detection by calling
             this function.
 
         Examples:
@@ -103,7 +103,7 @@ class ASDBase:
             >>> class LayerNormASD(ASDBase):
             ...     def __init__(self, *args, **kwargs):
             ...         super().__init__(OriginLayerNorm, *args, **kwargs)
-            ...         # init parameters for feature value detection by calling the base class function
+            ...         # init parameters for accuracy-sensitive detection by calling the base class function
             ...         self.pre_val, self.min_val, self.max_val, self.cnt = self.generate_params()
         """
         pre_val = Parameter(Tensor(0, mstype.float32),

mindspore/ops_generate/arg_dtype_cast.py

@@ -20,18 +20,25 @@ import mindspore as ms
 from mindspore import ops
 from mindspore.common.tensor import Tensor
 from mindspore.ops.operations._sequence_ops import TensorToScalar, TensorToTuple
-from mindspore.ops_generate.gen_ops_inner_prim import TupleToList, ListToTuple
+from mindspore.ops_generate.gen_ops_inner_prim import TupleToList
 from mindspore._c_expression import OpDtype
 
 tensor_to_tuple_ = TensorToTuple()
 tuple_to_list = TupleToList()
-list_to_tuple = ListToTuple()
 
 
 def int_to_float(data):
     return float(data)
 
 
+def list_to_tuple(data):
+    # tuple() currently does not support Any from JIT Fallback.
+    res = ()
+    for element in data:
+        res += (element,)
+    return res
+
+
 def scalar_to_tuple(data):
     return (data,)
 

mindspore/ops_generate/arg_handler.py

@@ -18,8 +18,6 @@ from mindspore.ops_generate.gen_ops_inner_prim import DtypeToEnum, StringToEnum
 # Enum Class:
 from mindspore._c_expression import FormatEnum as Format
 from mindspore._c_expression import ReductionEnum as Reduction
-from mindspore.common import Tensor
-from mindspore.common import dtype as mstype
 
 
 def arg_invalid_info(op_name, arg_name, arg_val):
@@ -29,17 +27,6 @@ def arg_invalid_info(op_name, arg_name, arg_val):
     return f"For '{op_name}', the value of '{arg_name}' is invalid: '{arg_val}'."
 
 
-def to_pair(op_name, arg_name, arg_val):
-    """
-    convert arg_val: int/tuple[int*2] -> tuple[int*2].
-    """
-    if isinstance(arg_val, (int, float)):
-        return (arg_val, arg_val)
-    if isinstance(arg_val, (list, tuple)):
-        return arg_val
-    raise ValueError(arg_invalid_info(op_name, arg_name, arg_val))
-
-
 def to_kernel_size(op_name, arg_name, kernel_size):
     """
     convert kernel_size: int/tuple[int*4] -> tuple[int*2].
@@ -176,19 +163,6 @@ def to_3d_paddings(op_name, arg_name, pad):
         return pad
     raise ValueError(arg_invalid_info(op_name, arg_name, pad))
 
-
-def generator_handler(op_name, arg_name, inputs):
-    """
-    convert constant value in tuple to tensor
-    """
-    new_inputs = []
-    for input_ in inputs:
-        if isinstance(input_, int):
-            new_inputs.append(Tensor(input_, mstype.int64))
-        else:
-            new_inputs.append(input_)
-    return tuple(new_inputs)
-
 dtype_to_type_id = DtypeToEnum()
 
 # string to enum

mindspore/ops_generate/gen_aclnn_implement.py

@@ -172,7 +172,7 @@ def generate(op_name, class_name, op_yaml, h_and_cc, need_update_shape):
     gen_cc(op_name, class_name, op_yaml, h_and_cc, need_update_shape)
 
 
-def gen_aclnn_kernel(op_name, yaml_str, need_update_shape=False, auto=False):
+def gen_aclnn_kernel(op_name, need_update_shape=False, auto=False):
     """gen_aclnn_kernel function"""
     if check_op_registed(op_name) and not auto:
         logging.warning("Kernel {%s} is already registered.", op_name)
@@ -180,7 +180,10 @@ def gen_aclnn_kernel(op_name, yaml_str, need_update_shape=False, auto=False):
     current_path = os.path.dirname(os.path.abspath(__file__))
     work_path = os.path.join(current_path, '../../../../')
 
+    # get ops yaml
+    ops_yaml_path = os.path.join(work_path, 'mindspore/python/mindspore/ops_generate/ops.yaml')
     aclnn_path = 'mindspore/ccsrc/plugin/device/ascend/kernel/opapi/aclnn/'
+    yaml_str = gen_utils.safe_load_yaml(ops_yaml_path)
     # merge inner ops
     op_yaml = yaml_str.get(op_name)
     class_name = ''.join(word.capitalize() for word in op_name.split('_'))

mindspore/ops_generate/gen_ops.py

@@ -22,7 +22,7 @@ import pathlib
 import logging
 import gen_utils
 from gen_utils import (py_licence_str, cc_license_str, check_change_and_replace_file, merge_files,
-                       merge_files_append, safe_load_yaml, convert_dtype_str, write_file)
+                       safe_load_yaml, convert_dtype_str, write_file)
 from pyboost_utils import get_pyboost_name, is_pyboost_enable, AclnnUtils, get_dtypes
 import template
 from template import CppTemplate
@@ -707,14 +707,8 @@ namespace mindspore::ops {
             dtype = get_dtype(arg_info)
             if dtype == "str":
                 dtype = "std::string"
-            if dtype in ("tuple[str]", "list[str]"):
-                dtype = "std::vector<std::string>"
-            if dtype in ("tuple[int]", "list[int]"):
+            if dtype == "tuple[int]":
                 dtype = "std::vector<int64_t>"
-            if dtype in ("tuple[float]", "list[float]"):
-                dtype = "std::vector<float>"
-            if dtype in ("tuple[bool]", "list[bool]"):
-                dtype = "std::vector<bool>"
             if dtype == "int":
                 dtype = "int64_t"
             lite_ops_h_gen += f"""  void set_{arg_name}(const {dtype} &{arg_name});\n"""
@@ -762,14 +756,6 @@ std::unordered_map<std::string, OpDefPtr> gOpDefTable = {{"""
             dispatch = "true"
         enable_dispatch_str = f"""{dispatch}"""
 
-        is_view = operator_data.get('view')
-        if is_view:
-            is_view = "true"
-        else:
-            is_view = "false"
-        is_view_str = f"""{is_view}"""
-
-
         gen_include += f"""\n#include "ops/ops_func_impl/{operator_name}.h\""""
         cc_index_str = ''
         gen_opdef_map += f"""\n  {{"{class_name}", &g{class_name}}},"""
@@ -811,8 +797,7 @@ std::unordered_map<std::string, OpDefPtr> gOpDefTable = {{"""
 
         op_def_cc = template.OP_PROTO_TEMPLATE.replace(class_name=class_name, input_args=input_args_str,
                                                        return_args=return_args_str, signatures=signature_code,
-                                                       indexes=cc_index_str, enable_dispatch=enable_dispatch_str,
-                                                       is_view=is_view_str)
+                                                       indexes=cc_index_str, enable_dispatch=enable_dispatch_str)
         gen_cc_code += op_def_cc
     gen_opdef_map += f"""\n}};"""
     gen_cc_code += gen_opdef_map
@@ -969,11 +954,6 @@ def generate_create_instance_helper_file(work_path, yaml_str):
 
 def generate_aclnn_reg_code(yaml_data):
     """generate aclnn register code"""
-    current_path = os.path.dirname(os.path.abspath(__file__))
-    work_path = os.path.join(current_path, '../../../../')
-    ops_yaml_path = os.path.join(work_path, 'mindspore/python/mindspore/ops_generate/ops.yaml')
-    yaml_str = gen_utils.safe_load_yaml(ops_yaml_path)
-
     reg_code = f"""
 #include "plugin/device/ascend/kernel/opapi/aclnn_kernel_mod.h"
 
@@ -989,7 +969,7 @@ namespace kernel {{
             continue
         _, _, none_tensor_exist = get_dtypes(operator_data)
         if none_tensor_exist:
-            gen_aclnn_kernel(operator_name, yaml_str, auto=True)
+            gen_aclnn_kernel(operator_name, auto=True)
             continue
         class_name = ''.join(word.capitalize() for word in operator_name.split('_'))
         op_class = operator_data.get("class")
@@ -1046,10 +1026,8 @@ def main():
     doc_yaml_path = os.path.join(work_path, 'mindspore/python/mindspore/ops_generate/ops_doc.yaml')
 
     ops_yaml_dir_path = os.path.join(work_path, 'mindspore/core/ops/ops_def/')
-    infer_ops_yaml_dir_path = os.path.join(work_path, 'mindspore/core/ops/ops_def/infer/')
     doc_yaml_dir_path = os.path.join(work_path, 'mindspore/core/ops/ops_def/doc/')
     merge_files(ops_yaml_dir_path, ops_yaml_path, '*op.yaml')
-    merge_files_append(infer_ops_yaml_dir_path, ops_yaml_path, '*op.yaml')
     merge_files(doc_yaml_dir_path, doc_yaml_path, '*doc.yaml')
 
     # make auto_generate dir