mindspore 2.5.0__cp310-cp310-win_amd64.whl → 2.6.0__cp310-cp310-win_amd64.whl

mindspore/ops/tensor_method.py

@@ -21,10 +21,14 @@ from mindspore.ops import operations as P
 from mindspore.ops import functional as F
 from mindspore.ops.composite.multitype_ops import _compile_utils as utils
 from mindspore.ops.composite.multitype_ops._compile_utils import (
-    sequence_to_tensor, _tensor_sub, _tensor_pow, _tensor_div
+    sequence_to_tensor, _tensor_sub, _tensor_pow, _tensor_div, _tensor_floordiv
 )
 from mindspore.ops.auto_generate.gen_ops_prim import (
-    inplace_scatter_src_op, inplace_scatter_src_reduce_op, inplace_scatter_value_op, inplace_scatter_value_reduce_op
+    inplace_scatter_src_op, inplace_scatter_src_reduce_op, inplace_scatter_value_op, inplace_scatter_value_reduce_op,
+    inplace_copy_op
+)
+from mindspore.ops.auto_generate.gen_ops_prim import (
+    floor_div_op, floor_div_scalar_op
 )
 # 1 common import
 
@@ -34,8 +38,9 @@ from mindspore import Tensor
 from mindspore.common import dtype as mstype
 # 4 common import
 from mindspore.common import COOTensor
-# 5 common import
 
+# 5 common import
+from mindspore.ops.function.nn_func import gelu
 # 6 common import
 
 # 7 common import
@@ -232,7 +237,7 @@ from mindspore.ops.function.array_func import scatter
 # 92 scatter_add
 from mindspore.ops.function.array_func import tensor_scatter_add
 # 93 select
-from mindspore.ops.auto_generate import select, select_ext
+from mindspore.ops.auto_generate import select, select_ext_view
 # 94 sigmoid
 from mindspore.ops.auto_generate import sigmoid
 # 95 sin
@@ -268,7 +273,7 @@ from mindspore.ops.operations.manually_defined import tile
 # 110 topk
 from mindspore.ops.function.array_func import topk
 # 111 transpose
-from mindspore.ops.auto_generate import transpose, transpose_ext
+from mindspore.ops.auto_generate import transpose, transpose_ext_view
 # 112 tril
 from mindspore.ops.function.array_func import tril
 # 113 trunc
@@ -313,7 +318,7 @@ from mindspore.ops.function.array_func import where as where_func
 # 132 absolute
 
 # 133 bincount
-from mindspore.ops.function.math_func import bincount
+from mindspore.ops.function.math_func import bincount, roll
 
 # 134 diff
 
@@ -353,11 +358,10 @@ from mindspore.ops.auto_generate import isinf
 # 151 fmod
 from mindspore.ops.function.math_func import fmod
 # 152
-
+from mindspore.ops.auto_generate import logaddexp2
 # 153
 from mindspore.ops.auto_generate import acos_ext, acosh_ext, asin_ext, asinh_ext, atan_ext, dot
 # 154 isneginf
-from mindspore.ops.auto_generate import isneginf_ext
 
 # 155
 from mindspore.ops.function.math_func import median
@@ -365,7 +369,7 @@ from mindspore.ops.function.math_func import median
 # 156
 
 # 157
-from mindspore._c_expression import pyboost_empty
+from mindspore.ops.auto_generate import xlogy_op
 
 # 158
 
@@ -377,6 +381,8 @@ from mindspore.ops.function.math_func import frac
 
 # 161 bitwise_not
 from mindspore.ops.auto_generate.gen_ops_prim import bitwise_not_op
+from mindspore.ops.function.math_func import bitwise_or, bitwise_and, bitwise_xor
+from mindspore.ops.auto_generate import logical_xor_op
 
 # 162 log10
 from mindspore.ops.function.math_func import log10
@@ -391,6 +397,10 @@ from mindspore.ops.auto_generate import sinc
 from mindspore.ops.auto_generate import sinh
 from mindspore.ops.function.array_func import unsqueeze
 
+# 186
+from mindspore.ops.function.math_func import addcdiv
+from mindspore.ops.auto_generate import addcdiv_ext_op
+
 # 204 erfc
 from mindspore.ops.auto_generate import erfc
 
@@ -410,18 +420,31 @@ from mindspore.ops.auto_generate import log1p
 from mindspore.ops.function.math_func import addbmm
 # 502
 from mindspore.ops.function.math_func import addmm
+# 846
+from mindspore.ops.function.math_func import count_nonzero
+
 # 880
 from mindspore.ops.auto_generate import lerp, lerp_scalar
 
 # 790 addmv
 from mindspore.ops.function.math_func import addmv
 
+# 916 index_add
+from mindspore.ops.primitive import constexpr
+from mindspore._checkparam import check_is_number
+
 # 1028
 from mindspore.ops.function.math_func import var_ext
 
 # 1029 exp_
 from mindspore.ops.auto_generate.gen_ops_prim import inplace_exp_op
 
+# 1030 log_
+from mindspore.ops.auto_generate.gen_ops_prim import inplace_log_op
+
+from .._checkparam import check_axis_in_range
+from ..ops.composite.multitype_ops import _compile_utils as compile_utils
+
 
 ########################################functions########################################
 def place_holder():
@@ -431,6 +454,8 @@ def place_holder():
 
 unique_dim_ = UniqueDim()
 unique2_ = Unique2()
+tuple_slice = validator.tuple_slice
+expanded_shape = validator.expanded_shape
 
 
 # 1 to
@@ -514,7 +539,7 @@ def deprecated_tensor_argmin(input, axis=None, keepdims=False):
 
 
 # 12 argsort
-def tensor_argsort(input, dim=-1, descending=False):
+def tensor_argsort(input, dim=-1, descending=False, stable=False):
     return argsort(input, dim, descending)
 
 
@@ -675,6 +700,10 @@ def tensor_greater_equal(input, other):
     return greater_equal(input, other)
 
 
+def deprecated_tensor_greater_equal(input, other):
+    return greater_equal(input, other)
+
+
 # 41 gt
 
 # 42 half
@@ -920,6 +949,9 @@ def deprecated_tensor_remainder(input, divisor):
 
 
 # 86 repeat
+def tensor_repeat(input, *repeats):
+    raise RuntimeError("'repeat' is not supported on this device.")
+
 
 # 87 repeat_interleave
 def deprecated_tensor_repeat_interleave(input, repeats, dim=None):
@@ -966,7 +998,7 @@ def deprecated_tensor_scatter_add(input, indices, updates):
 
 # 93 select
 def tensor_select_ext(input, dim, index):
-    return select_ext(input, dim, index)
+    return select_ext_view(input, dim, index)
 
 
 def deprecated_tensor_select(input, condition, y):
@@ -1138,7 +1170,7 @@ def deprecated_tensor_topk(input, k, dim=None, largest=True, sorted=True):
 
 # 111 transpose
 def tensor_transpose_ext(input, dim0, dim1):
-    return transpose_ext(input, dim0, dim1)
+    return transpose_ext_view(input, dim0, dim1)
 
 
 def deprecated_tensor_transpose(input, *axes):
@@ -1242,6 +1274,10 @@ def tensor_inplace_fill_tensor_empty(input, value):
     raise ValueError("should not come here for fill_tensor method.")
 
 
+def tensor_inplace_fill_diagonal(input, fill_value, wrap=False):
+    raise ValueError("should not come here for fill_diagonal method.")
+
+
 # 125 floor_
 
 # 126 masked_fill_
@@ -1272,12 +1308,16 @@ def tensor_bincount(input, weights=None, minlength=0):
     return bincount(input, weights, minlength)
 
 
+def tensor_roll(input, shifts, dims=None):
+    return roll(input, shifts, dims)
+
 # 134 diff
 
 # 135 double
 
 # 136 lcm
 
+
 # 137 mm
 def tensor_mm(input, mat2):
     return F.mm(input, mat2)
@@ -1333,8 +1373,8 @@ def tensor_triu(input, diagonal=0):
 
 # 150 __eq__
 
-# 151 scatter_
 
+# 151 scatter_
 def tensor_inplace_scatter_src(input, dim, index, src):
     return inplace_scatter_src_op(input, dim, index, src)
 
@@ -1409,6 +1449,14 @@ def tensor_atanh(input):
     return F.atanh(input)
 
 
+def tensor_copy_(input, src):
+    raise ValueError("should not come here for copy_ method")
+
+
+def deprecated_tensor_copy_(input, src, non_blocking=False):
+    return inplace_copy_op(input, src)
+
+
 def tensor_tan(input):
     return F.tan(input)
 
@@ -1421,9 +1469,21 @@ def deprecated_tensor_dot(input, other):
     return F.dot(input, other)
 
 
+def deprecated_tensor_logsumexp(input, dim, keepdim=False):
+    return F.logsumexp(input, dim, keepdim)
+
+
 # 154
 def tensor_isneginf(input):
-    return isneginf_ext(input)
+    inf_tensor = isinf(input)
+    neg_tensor = input < 0
+    return logical_and(inf_tensor, neg_tensor)
+
+
+def deprecated_tensor_isneginf(input):
+    inf_tensor = isinf(input)
+    neg_tensor = input < 0
+    return logical_and(inf_tensor, neg_tensor)
 
 
 # 155
@@ -1440,14 +1500,33 @@ def tensor_median_dim(input, dim=-1, keepdim=False):
 
 
 # 156
+def tensor_logaddexp2(input, other):
+    return logaddexp2(input, other)
+
+
+def deprecated_tensor_logaddexp2(input, other):
+    return F.logaddexp2(input, other)
+
 
 # 157
 def tensor_empty(*size, dtype=None, device=None):
-    return pyboost_empty(size, dtype, device)
+    logger.error(
+        "This is a function for empty not should be called. Please check the implementation.")
+
+
+def deprecated_tensor_logaddexp(input, other):
+    return F.logaddexp(input, other)
+
+
+def tensor_xlogy(input, other):
+    if isinstance(other, (float, int, bool)):
+        other = F.scalar_to_tensor(other)
+    return xlogy_op(input, other)
 
 
 # 158
 
+
 # 159 histc
 def tensor_histc(input, bins=100, min=0, max=0):
     return histc(input, bins, min, max)
@@ -1458,16 +1537,45 @@ def tensor_frac(input):
     return frac(input)
 
 
-# 161 bitwise_not
+# 161 bitwise_not baddbmm bitwise_or bitwise_and bitwise_xor logical_xor
+def deprecated_baddbmm(input, batch1, batch2, *, beta=1, alpha=1):
+    return F.baddbmm(input, batch1, batch2, beta=beta, alpha=alpha)
+
+
 def tensor_bitwise_not(input):
     return bitwise_not_op(input)
 
 
+def deprecated_bitwise_or(input, other):
+    return bitwise_or(input, other)
+
+
+def deprecated_bitwise_and(input, other):
+    return bitwise_and(input, other)
+
+
+def deprecated_bitwise_xor(input, other):
+    return bitwise_xor(input, other)
+
+
+def tensor_logical_xor(input, other):
+    return logical_xor_op(input, other)
+
+
 # 162
 def tensor_log10(input):
     return log10(input)
 
 
+# 186
+def deprecated_tensor_addcdiv(input, tensor1, tensor2, value=1):
+    return addcdiv(input, tensor1, tensor2, value=value)
+
+
+def tensor_addcdiv_ext(input, tensor1, tensor2, *, value=1):
+    return addcdiv_ext_op(input, tensor1, tensor2, value=value)
+
+
 # 501
 def tensor_addbmm(input, batch1, batch2, *, beta=1, alpha=1):
     return addbmm(input, batch1, batch2, beta=beta, alpha=alpha)
@@ -1492,18 +1600,74 @@ def deprecated_tensor_addmm(input, mat1, mat2, *, beta=1, alpha=1):
     return addmm(input, mat1, mat2, beta=beta, alpha=alpha)
 
 
+# 543
+def tensor_put_(input, index, source, accumulate=False):
+    raise RuntimeError(f"There is no branch to go function tensor_put_!")
+
+
 # 790
 def tensor_addmv(input, mat, vec, *, beta=1, alpha=1):
     return addmv(input, mat, vec, beta=beta, alpha=alpha)
 
 
-def deprecated_tensor_addmv(input, mat, vec, *, beta=1, alpha=1):
+def deprecated_tensor_addmv(input, mat, vec, beta=1, alpha=1):
     r"""
     For details, please refer to :func:`mindspore.ops.addmv`.
     """
     return addmv(input, mat, vec, beta=beta, alpha=alpha)
 
 
+# 846
+def deprecated_tensor_count_nonzero(input,
+                                    axis=(),
+                                    keep_dims=False,
+                                    dtype=None):
+    if dtype is None:
+        return count_nonzero(input,
+                             axis=axis,
+                             keep_dims=keep_dims,
+                             dtype=mstype.int32)
+    return count_nonzero(input, axis=axis, keep_dims=keep_dims, dtype=dtype)
+
+
+# 732
+def tensor_take(input, index):
+    return deprecated_tensor_take(input, index)
+
+
+def deprecated_tensor_take(x, indices, axis=None, mode='clip'):
+    """
+    Takes elements from a tensor along an axis.
+    """
+    if mode not in ('raise', 'wrap', 'clip'):
+        raise ValueError(f"For 'Tensor.take', the argument 'mode' should be one of in ['raise', 'wrap', 'clip'],"
+                         f" but got {mode}.")
+    if axis is None:
+        a = x.ravel()
+        axis = 0
+    else:
+        a = x
+    ndim = a.ndim
+    axis = check_axis_in_range(axis, ndim)
+
+    shape_a = a.shape
+    shape_indices = indices.shape
+    size_indices = indices.size
+    indices = compile_utils.check_indices(shape_a[axis], indices, mode)
+
+    # reshapes indices to shape (Ni..., Nj..., Nk)
+    shape_ni = tuple_slice(shape_a, None, axis)
+    shape_nk = tuple_slice(shape_a, axis + 1, None)
+    shape_out = shape_ni + shape_indices + shape_nk
+    shape_indices = expanded_shape(ndim, size_indices, axis)
+    indices = indices.reshape(shape_indices)
+    shape_indices = shape_ni + (indices.size,) + shape_nk
+    indices = F.broadcast_to(indices, shape_indices)
+
+    res = F.gather_d(a, axis, indices)
+    return res.reshape(shape_out)
+
+
 def tensor_clone(input):
     return clone(input)
 
@@ -1570,6 +1734,32 @@ def tensor_log1p(input):
     return log1p(input)
 
 
+def tensor_diag(input, diagonal=0):
+    if diagonal != 0:
+        raise ValueError(f"For 'Tensor.diag', the argument 'diagonal' should be '0', but got {diagonal}.")
+    return F.diag(input)
+
+
+def deprecated_tensor_diag(input):
+    return F.diag(input)
+
+
+# 916 index_add
+@constexpr
+def _check_index_add_alpha(alpha):
+    check_is_number(alpha, (int, float))
+
+
+def tensor_index_add(input, dim, index, source, *, alpha=1):
+    _check_index_add_alpha(alpha)
+    source = source * alpha
+    return F.index_add(input, indices=index, y=source, axis=dim)
+
+
+def deprecated_tensor_index_add(input, indices, y, axis, use_lock=True, check_index_bound=True):
+    return F.index_add(input, indices, y, axis, use_lock, check_index_bound)
+
+
 # 1028
 def tensor_var(input, dim=None, *, correction=1, keepdim=False):
     return var_ext(input, dim, correction=correction, keepdim=keepdim)
@@ -1605,6 +1795,10 @@ def deprecated_tensor_var(input, axis=None, ddof=0, keepdims=False):
     return _tensor_div(x_sum, nums - ddof)
 
 
+def tensor_kthvalue(input, k, dim=-1, keepdim=False):
+    raise ValueError("should not come here for kthvalue py_method.")
+
+
 def tensor_sub_empty_(input, other, alpha=1):
     raise ValueError("should not come here for sub_ method.")
 
@@ -1646,6 +1840,10 @@ def all_gather_matmul(
     raise NotImplementedError('all_gather_matmul only supports Ascend.')
 
 
+def tensor_floor_divide_(input, other):
+    return _tensor_floordiv(input, other)
+
+
 def matmul_reduce_scatter(
         input,
         x2,
@@ -1664,6 +1862,34 @@ def matmul_reduce_scatter(
     raise NotImplementedError('matmul_reduce_scatter only supports Ascend.')
 
 
+# 1030
+def tensor_log_(input):
+    return inplace_log_op(input)
+
+
+def tensor_floor_div(input, other):
+    return floor_div_op(input, other)
+
+
+def tensor_floor_div_scalar(input, other):
+    return floor_div_scalar_op(input, other)
+
+
 # 1029
 def tensor_exp_(input):
     return inplace_exp_op(input)
+
+
+def tensor_gelu(input, *, approximate):
+    return gelu(input, approximate)
+
+
+def deprecated_pixel_shuffle(input, upscale_factor):
+    return F.pixel_shuffle(input, upscale_factor)
+
+
+def tensor_gmm(x, weight, *, bias=None, group_list=None, group_type=0, group_list_type=0):
+    raise NotImplementedError("gmm has not been implemented by python.")
+
+def raise_func(*args, **kwargs):
+    raise NotImplementedError("this func has not been implemented.")

mindspore/ops_generate/__init__.py

@@ -19,9 +19,4 @@ Primitive operator classes and operator functional.
 A collection of operators to build neural networks or to compute functions.
 """
 
-from . import (arg_dtype_cast, arg_handler)
-
-from .arg_dtype_cast import *
-from .arg_handler import *
-
 __all__ = []

mindspore/ops_generate/{aclnn_kernel_register_auto_cc_generator.py → aclnn/aclnn_kernel_register_auto_cc_generator.py}

@@ -20,21 +20,32 @@ import os
 import logging
 import re
 
-import gen_constants as K
-import gen_utils
-import pyboost_utils
+import common.gen_constants as K
+import common.gen_utils as gen_utils
+import common.template as template
+from common.base_generator import BaseGenerator
+from pyboost import pyboost_utils
+from aclnn.gen_aclnn_implement import gen_aclnn_kernel
+from resources.resource_list import ResourceType
 
-import template
 
-from base_generator import BaseGenerator
-from gen_aclnn_implement import gen_aclnn_kernel
+ACLNN_REG_CODE = """
+#include "$ops_gen_kernel_path/ascend/opapi/aclnn_kernel_mod.h"
+
+namespace mindspore {
+namespace kernel {
+
+$aclnn_reg_code
+}  // namespace kernel
+}  // namespace mindspore
+"""
 
 
 class AclnnKernelRegisterAutoCcGenerator(BaseGenerator):
     """Generates ACL NN kernel registration code for Ascend devices."""
 
     def __init__(self):
-        self.aclnn_reg_code_template = template.Template(K.ACLNN_REG_CODE)
+        self.aclnn_reg_code_template = template.Template(ACLNN_REG_CODE)
 
     def generate(self, work_path, op_protos):
         """
@@ -51,10 +62,12 @@ class AclnnKernelRegisterAutoCcGenerator(BaseGenerator):
         for op_proto in op_protos:
             if not op_proto.op_dispatch or not op_proto.op_dispatch.enable:
                 continue
-            if op_proto.op_dispatch.ascend != 'default':  # KernelMod is provided by yaml, don't auto generate it.
+            # KernelMod is provided by yaml, don't auto generate it.
+            if op_proto.op_dispatch.ascend != 'default':
                 continue
-            if check_op_registed(op_proto.op_name):
-                logging.warning("Kernel {%s} is already registered.", op_proto.op_name)
+            if check_op_registed(op_proto.op_name, True):
+                logging.warning(
+                    "Kernel {%s} is already registered.", op_proto.op_name)
                 continue
             _, _, none_tensor_exist = pyboost_utils.get_dtypes(op_proto)
             if none_tensor_exist:
@@ -63,8 +76,10 @@ class AclnnKernelRegisterAutoCcGenerator(BaseGenerator):
                 continue
 
             class_name = op_proto.op_class.name
-            inputs_outputs_num = len(op_proto.op_args) + len(op_proto.op_returns)
-            aclnn_name = pyboost_utils.AclnnUtils.get_aclnn_interface(class_name)
+            inputs_outputs_num = len(op_proto.op_args) + \
+                len(op_proto.op_returns)
+            aclnn_name = pyboost_utils.AclnnUtils.get_aclnn_interface(
+                class_name)
             aclnn_reg_code.append(
                 f"MS_ACLNN_COMMON_KERNEL_FACTORY_REG({class_name}, {aclnn_name}, {inputs_outputs_num});\n")
 
@@ -72,7 +87,8 @@ class AclnnKernelRegisterAutoCcGenerator(BaseGenerator):
                                                         aclnn_reg_code=aclnn_reg_code)
         res_str = template.CC_LICENSE_STR + reg_code
 
-        save_path = os.path.join(work_path, f"{K.MS_OPS_KERNEL_PATH}/ascend/opapi/auto_generate")
+        save_path = os.path.join(
+            work_path, f"{K.MS_OPS_KERNEL_PATH}/ascend/opapi/auto_generate")
         file_name = "aclnn_kernel_register_auto.cc"
         gen_utils.save_file(save_path, file_name, res_str)
 
@@ -80,9 +96,7 @@ class AclnnKernelRegisterAutoCcGenerator(BaseGenerator):
 def get_registed_ops(file_path=f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/'):
     '''get registered ops by search files'''
     # default search in 'ops/kernel/ascend/opapi/'
-    current_path = os.path.dirname(os.path.realpath(__file__))
-    work_path = os.path.join(current_path, '../../../../')
-    search_path = os.path.join(work_path, file_path)
+    search_path = os.path.join(K.WORK_DIR, file_path)
     ret = []
     try:
         for root_path, _, files in os.walk(search_path):
@@ -91,7 +105,8 @@ def get_registed_ops(file_path=f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/'):
                     continue
                 with open(os.path.join(root_path, file_name), "r") as f:
                     file_context = f.read()
-                    search_re = re.search(r"(?<=KERNEL_FACTORY_REG\()\w+(?=,)", file_context)
+                    search_re = re.search(
+                        r"(?<=KERNEL_FACTORY_REG\()\w+(?=,)", file_context)
                     if search_re:
                         ret.append(search_re.group())
     except OSError:
@@ -101,10 +116,20 @@ def get_registed_ops(file_path=f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/'):
 
 
 registed_ops = get_registed_ops()
-manual_registed_ops = get_registed_ops(f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/')
+manual_registed_ops = get_registed_ops(
+    f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/')
 
 
 def check_op_registed(op_name, manual=False):
     '''if op already registered return true'''
     class_name = ''.join(word.capitalize() for word in op_name.split('_'))
     return (class_name in manual_registed_ops) if manual else (class_name in registed_ops)
+
+
+def generate_aclnn_reg_file(resource_mgr):
+    """
+    Generate nnacl kernelmod register
+    """
+    op_protos = resource_mgr.get_resource(ResourceType.OP_PROTO)
+    generator = AclnnKernelRegisterAutoCcGenerator()
+    generator.generate(K.WORK_DIR, op_protos)