mindspore 2.7.0__cp310-cp310-macosx_11_0_arm64.whl → 2.7.0rc1__cp310-cp310-macosx_11_0_arm64.whl

mindspore/.commit_id

@@ -1 +1 @@
-__commit_id__ = ''[sha1]:7edec76e,[branch]:(HEAD,origin/r2.7,r2.7)''
+__commit_id__ = ''[sha1]:e69e001d,[branch]:(HEAD,origin/r2.7.rc1,r2.7.rc1)''

mindspore/__init__.py

@@ -19,7 +19,7 @@ from mindspore.run_check import run_check
 from mindspore import common, dataset, mindrecord, train, log, amp, device_manager
 from mindspore import profiler, communication, numpy, parallel, hal, runtime, device_context
 from mindspore.common import *
-from mindspore.common import _tensor_docs, bool, int, float
+from mindspore.common import _tensor_docs
 del _tensor_docs
 from mindspore.mindrecord import *
 from mindspore.ops import _op_impl, grad, value_and_grad, vjp, jvp, jacfwd, jacrev, vmap, get_grad, constexpr

mindspore/_checkparam.py

@@ -787,9 +787,9 @@ def check_astype_dtype(dtype):
     if isinstance(dtype, str):
         if dtype.lower() not in all_types:
             raise TypeError(f"For Tensor.astype, the input type must be one of {all_types}, but got '{dtype}'.")
-        dtype = mstype._pytype_to_dtype(np.dtype(dtype.lower()))  # pylint:disable=protected-access
+        dtype = mstype.pytype_to_dtype(np.dtype(dtype.lower()))
     elif isinstance(dtype, type):
-        dtype = mstype._pytype_to_dtype(dtype)  # pylint:disable=protected-access
+        dtype = mstype.pytype_to_dtype(dtype)
     elif not dtype in mstype.number_type + (mstype.bool_,):
         raise TypeError(f"For Tensor.astype, the input type must be one of {mstype.number_type + (mstype.bool_,)}," \
                         f" but got '{dtype}'.")

mindspore/_extends/builtin_operations.py

@@ -19,7 +19,7 @@ from mindspore.ops import functional as F
 from mindspore.ops import composite as C
 from mindspore.common.tensor import Tensor
 import mindspore.common.dtype as mstype
-from mindspore.common.dtype import _dtype_to_nptype, _get_py_obj_dtype
+from mindspore.common.dtype import dtype_to_nptype, get_py_obj_dtype
 from mindspore._c_expression import TensorPy as CTensor
 
 
@@ -164,7 +164,7 @@ def Load(value, u=None):
 
 def scalar_cast(x, t):
     """Implement scalar_cast."""
-    np_type = _dtype_to_nptype(t)  # pylint:disable=protected-access
+    np_type = dtype_to_nptype(t)
     value = np_type(x)
     cast_value = np.ndarray.item(value)
     return cast_value
@@ -172,7 +172,7 @@ def scalar_cast(x, t):
 
 def typeof(x):
     """Implement typeof."""
-    return _get_py_obj_dtype(x)  # pylint:disable=protected-access
+    return get_py_obj_dtype(x)
 
 
 def tuple_to_array(x):

mindspore/_extends/parallel_compile/akg_compiler/gen_custom_op_files.py

@@ -81,7 +81,7 @@ def gen_custom_op_files(config_dir, dsl_dir):
             f.write(json.dumps(ops_info, indent=4))
 
     # custom akg op dsl file
-    custom_py = os.path.join(cur_path, "custom.py")
+    custom_py = os.path.join(cur_path, "../../../../../lite/tools/kernel_builder/ascend/akg/custom.py")
     if not os.path.isfile(custom_py):
         raise RuntimeError("custom.py path is invalid: {}".format(custom_py))
     shutil.copy(custom_py, dsl_dir)

mindspore/_extends/parse/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2025 Huawei Technologies Co., Ltd
+# Copyright 2020-2024 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -30,7 +30,7 @@ from .parser import (Parser, create_instance, is_supported_create_instance_type,
                      get_obj_defined_from_obj_type, is_from_third_party_library, get_const_abs, get_const_round,
                      get_const_len, convert_to_namedtuple, check_attrs, generate_lambda_object,
                      check_is_subclass, check_attr_is_property, get_method_info, can_constant_fold,
-                     convert_to_mutable, get_ast_augassign_namespace_symbol, hook_wrapper)
+                     convert_to_mutable, get_ast_augassign_namespace_symbol)
 
 __all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'generate_scope', 'get_attr_from_object',
            'get_bprop_method_of_class', 'get_class_instance_type', 'get_class_member_namespace_symbol',
@@ -45,4 +45,4 @@ __all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'ge
            'is_class_member_recursive', 'get_obj_defined_from_obj_type',
            'is_from_third_party_library', 'get_const_abs', 'get_const_round', 'get_const_len', 'get_method_info',
            'convert_to_namedtuple', 'check_attrs', 'generate_lambda_object', 'check_is_subclass', 'check_attr_is_property',
-           'can_constant_fold', 'convert_to_mutable', 'get_ast_augassign_namespace_symbol', 'hook_wrapper']
+           'can_constant_fold', 'convert_to_mutable', 'get_ast_augassign_namespace_symbol']

mindspore/_extends/parse/deprecated/deprecated_tensor_method.py

@@ -338,6 +338,7 @@ deprecated_tensor_method_map = {
     "atan": "deprecated_tensor_atan",
     "arctan": "deprecated_tensor_arctan",
     "dot": "deprecated_tensor_dot",
+    "copy_": "deprecated_tensor_copy_",
 
     # 153
     "logsumexp": "deprecated_tensor_logsumexp",

mindspore/_extends/parse/parser.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2020-2025 Huawei Technologies Co., Ltd
+# Copyright 2020-2024 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -103,6 +103,17 @@ parse_expr_statement_white_list = (
     "append", "insert", "clear", "reverse", "extend", "update", "register_hook",
 )
 
+# Methods that need to reorder after it's caller is used before
+# e.g. We need to reorder `x.register_hook` after x is used in `out = x + 1` when `register_hook` is called.
+# def construct(x):
+#     out = x + 1
+#     x.register_hook(hook_fn)
+#     return out
+# equals to:
+# def construct(x):
+#     x = x.register_hook(hook_fn) # register_hook will return itself when it is called in the graph (in `GRAPH_MODE`).
+#     out = x + 1
+#     return out
 _need_reorder_methods = (
     "register_hook",
 )
@@ -114,6 +125,10 @@ _unsupported_python_builtin_type = (
     set, dict, slice, complex, reversed, type,
 )
 
+# Unsupported python builtin type in JIT Fallback.
+_fallback_unsupported_python_builtin_type = (
+    compile, eval, exec
+)
 
 _global_params = {}
 
@@ -182,7 +197,10 @@ def get_parse_method_of_class(obj, parse_method=None):
     if parse_method is not None:
         method_name = parse_method
     elif isinstance(obj, nn.Cell):
-        method_name = "construct"
+        if obj._backward_hook:
+            method_name = "_backward_hook_construct"
+        else:
+            method_name = "construct"
 
     return get_attr_from_object(obj, method_name)
 
@@ -787,12 +805,6 @@ def eval_script(exp_str, params):
     local_params = params[1]
     try:
         local_params = _convert_python_data(local_params)
-        # There are two sources of scripts:
-        # 1. The user's original Python script code, which is directly passed back to Python for execution,
-        #    and its behavior is guaranteed by the user.
-        # 2. Internally provided Python expression code, similar to
-        #    `__iternal_sequence_input__[__internal_sequence_index__]`.
-        # In addition, MindIR load and export do not involve the use of the `eval_script` function.
         res = eval(exp_str, global_params, local_params)
     except Exception as e:
         error_info = f"When eval '{exp_str}' by using JIT Fallback feature, an error occurred: " + str(e)
@@ -899,26 +911,6 @@ def can_constant_fold(obj):
     return obj in constant_fold_functions
 
 
-def hook_wrapper(hook_fn):
-    """
-    Decorator wrapper for gradient hook functions.
-    Handles custom logic when the hook returns None to ensure execution dependencies.
-
-    Args:
-        hook_fn (function): The original hook function to be wrapped.
-
-    Returns:
-        function: Wrapped inner hook function with dependency handling logic.
-    """
-    def inner(dout):
-        fdout = hook_fn(dout)
-        if fdout is None:
-            dout = ops.Depend()(dout, fdout)
-            return dout
-        return fdout
-    return inner
-
-
 class Parser:
     """
     Parser python code to ast tree.
@@ -952,6 +944,8 @@ class Parser:
         """To check if not supported for namespace"""
         unsupported = isinstance(value, _builtin_function_or_method_type) and value not in convert_object_map
         logger.debug(f"'{value}' unsupported: {unsupported}.")
+        if unsupported and value in _fallback_unsupported_python_builtin_type:
+            raise TypeError(f"'{value}' is not supported both in JIT Fallback and graph mode.")
         return unsupported
 
     @staticmethod

mindspore/_extends/parse/standard_method.py

@@ -1114,7 +1114,7 @@ def copy_(self, src, non_blocking=False):
     """
     Copies the elements from src into self tensor and returns self.
     """
-    return inplace_copy_op(self, src, non_blocking)
+    return inplace_copy_op(self, src)
 
 
 def max(input, axis=None, keepdims=False, *, initial=None,  # pylint: disable=redefined-builtin
@@ -3709,13 +3709,6 @@ def bernoulli(input, *, generator=None):
     return F.bernoulli_ext(input, generator=generator)
 
 
-def bernoulli_(input, p=0.5, *, generator=None):
-    """
-    Randomly draws binary numbers from a Bernoulli distribution.
-    """
-    return F.bernoulli_(input, p, generator=generator)
-
-
 def gather_nd(input_x, indices):
     r"""
     Gathers slices from a tensor by indices.
@@ -4542,13 +4535,6 @@ def index_put(input, indices, values, accumulate=False):
     return _index_put(input, values, indices)
 
 
-def move_to(input, to, blocking=True):
-    r"""
-        Copy Tensor to target device synchronously or asynchronously, default synchronously. only support PyNative mode.
-    """
-    raise ValueError(f"The method 'move_to' is not supported in jit.")
-
-
 def index_put_(input, indices, values, accumulate=False):
     r"""
     For details, please refer to :func:`mindspore.Tensor.index_put_`.

mindspore/_extends/pijit/pijit_func_white_list.py

@@ -37,7 +37,7 @@ from mindspore.common.initializer import Zero
 from mindspore.ops.function import array_func
 from mindspore.ops import operations as P
 from mindspore.ops import functional as F
-from mindspore._c_expression.np_dtypes import np_dtype_valid
+from mindspore._c_expression.np_dtypes import np_version_valid
 from mindspore.common.dtype import type_size_in_bytes
 from mindspore.communication._comm_helper import _is_initialized, _get_rank_helper, _get_local_rank_helper, \
     _get_size_helper, _get_local_size_helper, _get_world_rank_from_group_rank_helper, _get_group_ranks, \
@@ -129,6 +129,7 @@ from mindspore.dataset.vision.transforms import AdjustBrightness, AdjustContrast
     ResizeWithBBox as VResizeWithBBox, Rotate as VRotate, SlicePatches as VSlicePatches, Solarize, ToTensor,\
     TrivialAugmentWide, UniformAugment as VUniformAugment, VerticalFlip as VVerticalFlip
 from mindspore.profiler.profiler import Profiler
+from mindspore.communication._hccl_management import get_rank_size, get_rank_id
 from mindspore.communication._comm_helper import _create_group_helper, _destroy_group_helper
 from mindspore.communication.management import _set_rank_from_mpi, init as cinit, release as crelease
 from mindspore.hal.stream import Stream, synchronize, set_cur_stream, current_stream, default_stream
@@ -491,11 +492,13 @@ _func_map = {
     function_id(validator.check_is_int): FUNC_KEY_PIJIT_CONSTEXPR,
     function_id(validator.check_is_number): FUNC_KEY_PIJIT_CONSTEXPR,
     function_id(validator.check_positive_int_sequence): FUNC_KEY_PIJIT_CONSTEXPR,
-    function_id(np_dtype_valid): FUNC_KEY_PIJIT_CONSTEXPR,
+    function_id(np_version_valid): FUNC_KEY_PIJIT_CONSTEXPR,
     function_id(_is_initialized): FUNC_KEY_PIJIT_CONSTEXPR,
     function_id(_set_elegant_exit_handle): FUNC_KEY_PIJIT_CONSTEXPR,
     function_id(_cost_model_context.get_cost_model_context): FUNC_KEY_PIJIT_CONSTEXPR,
     function_id(Stream.__repr__): FUNC_KEY_PIJIT_CONSTEXPR,
+    function_id(get_rank_size): FUNC_KEY_PIJIT_CONSTEXPR,
+    function_id(get_rank_id): FUNC_KEY_PIJIT_CONSTEXPR,
     function_id(offload_context): FUNC_KEY_PIJIT_CONSTEXPR,
     function_id(_is_in_data_parallel_mode): FUNC_KEY_PIJIT_CONSTEXPR,
     function_id(check_version_and_env_config): FUNC_KEY_PIJIT_CONSTEXPR,

mindspore/_extends/remote/kernel_build_server_ascend.py

@@ -0,0 +1,75 @@
+# Copyright 2020-2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""kernel build server for ascend"""
+import sys
+import warnings
+import json
+
+from mindspore._extends.parallel_compile.tbe_compiler.tbe_job_manager import TbeJobManager
+from mindspore._extends.remote.kernel_build_server import Messager, get_logger, AkgBuilder
+
+
+class AscendMessager(Messager):
+    """
+    Ascend Messager
+    It works as a server, communicating with c++ client.
+    """
+
+    def __init__(self, fdin, fdout):
+        super().__init__(fdin, fdout)
+        get_logger().info("[TRACE] Ascend Messager init...")
+        self.tbe_builder = TbeJobManager()
+        self.akg_builder = AkgBuilder("ASCEND")
+
+    def handle(self):
+        """
+        Communicate with remote client.
+        Reference protocol between them at PR#3821 and PR#3935
+        """
+        arg = self.get_message()
+        if arg.startswith('AKG'):
+            self.akg_builder.handle(self, arg)
+        else:
+            job_json = dict()
+            try:
+                job_json = json.loads(arg)
+            except json.decoder.JSONDecodeError:
+                get_logger().error("[TRACE] Request is not a json message: {}".format(arg))
+                self.send_ack(False)
+                self.exit()
+            finally:
+                pass
+
+            if "job_type" in job_json:
+                res = self.tbe_builder.job_handler(arg)
+                self.send_res(res)
+            else:
+                get_logger().error("[TRACE] Request is not a TBE Job message: {}".format(arg))
+                self.send_ack(False)
+                self.exit()
+
+    def exit(self):
+        self.tbe_builder.reset()
+        get_logger().info("[TRACE] Ascend Messager Exit...")
+        exit()
+
+
+if __name__ == '__main__':
+    warnings.simplefilter("ignore")
+    if len(sys.argv) != 3:
+        raise Exception('Incorrect argv: {}'.format(sys.argv))
+    get_logger().debug(f"[TRACE] argv: {str(sys.argv)}")
+    messager = AscendMessager(int(sys.argv[1]), int(sys.argv[2]))
+    messager.run()

mindspore/amp.py

@@ -167,6 +167,9 @@ def all_finite(inputs):
         >>> x = (Tensor(np.array([np.log(-1), 1, np.log(0)])), Tensor(np.array([1.0])))
         >>> output = amp.all_finite(x)
 
+    Tutorial Examples:
+        - `Automatic Mix Precision - Loss Scaling
+          <https://mindspore.cn/tutorials/en/master/beginner/mixed_precision.html#loss-scaling>`_
     """
     inputs = mutable(inputs)
     _check_overflow_mode = os.environ.get('MS_ASCEND_CHECK_OVERFLOW_MODE')
@@ -182,6 +185,9 @@ class LossScaler(ABC):
     to scale and unscale the loss value and gradients to avoid overflow, `adjust` is used to update the
     loss scale value.
 
+    For more information, refer to the `tutorials  <https://mindspore.cn/tutorials/en/master/beginner/
+    mixed_precision.html#loss-scaling>`_.
+
     .. warning::
         This is an experimental API that is subject to change or deletion.
 
@@ -371,6 +377,10 @@ class DynamicLossScaler(LossScaler):
 
         Returns:
             Union(Tensor, tuple(Tensor)), the scaled value.
+
+        Tutorial Examples:
+            - `Automatic Mix Precision - Loss Scaling
+              <https://mindspore.cn/tutorials/en/master/beginner/mixed_precision.html#loss-scaling>`_
         """
         inputs = mutable(inputs)
         return _grad_scale_map(self.scale_value, inputs)
@@ -384,6 +394,10 @@ class DynamicLossScaler(LossScaler):
 
         Returns:
             Union(Tensor, tuple(Tensor)), the unscaled value.
+
+        Tutorial Examples:
+            - `Automatic Mix Precision - Loss Scaling
+              <https://mindspore.cn/tutorials/en/master/beginner/mixed_precision.html#loss-scaling>`_
         """
         inputs = mutable(inputs)
         return _grad_unscale_map(self.scale_value, inputs)
@@ -394,6 +408,10 @@ class DynamicLossScaler(LossScaler):
 
         Args:
             grads_finite (Tensor): a scalar bool Tensor indicating whether the grads are finite.
+
+        Tutorial Examples:
+            - `Automatic Mix Precision - Loss Scaling
+              <https://mindspore.cn/tutorials/en/master/beginner/mixed_precision.html#loss-scaling>`_
         """
         one = ops.ones((), self.scale_value.dtype)
         scale_mul_factor = self.scale_value * self.scale_factor

mindspore/common/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2025 Huawei Technologies Co., Ltd
+# Copyright 2020-2024 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,15 +17,14 @@ from __future__ import absolute_import
 from mindspore.common import dtype
 from mindspore.common.api import ms_memory_recycle, jit, jit_class, _no_grad, \
     flops_collection, set_recursion_limit
-from mindspore.common.dtype import Type, int8, byte, int16, short, int, int32, intc, long, int64, intp, \
+from mindspore.common.dtype import Type, int8, byte, int16, short, int32, intc, int64, intp, \
     uint8, ubyte, uint16, ushort, uint32, uintc, uint64, uintp, float16, half, \
-    float, float32, single, float64, bfloat16, double, bool, bool_, float_, list_, tuple_, int_, \
+    float32, single, float64, bfloat16, double, bool_, float_, list_, tuple_, int_, \
     uint, number, tensor_type, string, type_none, TensorType, Int, \
-    cfloat, complex64, cdouble, complex128, dtype_to_nptype, _null, _NullType, \
+    complex64, complex128, dtype_to_nptype, _null, _NullType, \
     dtype_to_pytype, pytype_to_dtype, get_py_obj_dtype, QuantDtype, qint4x2, \
     float8_e4m3fn, float8_e5m2, hifloat8
 from mindspore.common.dump import set_dump
-from mindspore.common.file_system import set_mindio_server_info, mindio_preload
 from mindspore.common.parameter import Parameter, ParameterTuple
 from mindspore.common.seed import set_seed, get_seed
 from mindspore.common.tensor import Tensor, tensor
@@ -42,7 +41,6 @@ from mindspore.common.generator import (
     Generator, default_generator, seed, manual_seed, initial_seed, get_rng_state, set_rng_state)
 from mindspore.ops.function.array_func import is_tensor, from_numpy
 from mindspore.common._grad_function import _Function
-from mindspore.common.dynamic_shape.enable_dynamic import enable_dynamic
 
 try:
     import triton
@@ -68,13 +66,11 @@ except ImportError:
     pass
 
 # symbols from dtype
-# bool, int, float are not defined in __all__ to avoid conflict with built-in types.
 __all__ = [
-    "bool_",
     "int8", "byte",
     "int16", "short",
     "int32", "intc",
-    "int64", "long", "intp",
+    "int64", "intp",
     "uint8", "ubyte",
     "uint16", "ushort",
     "uint32", "uintc",
@@ -82,20 +78,20 @@ __all__ = [
     "float16", "half",
     "float32", "single",
     "float64", "double",
-    "float_", "list_", "tuple_",
+    "bool_", "float_",
+    "list_", "tuple_",
     "int_", "uint",
     "number", "tensor_type",
     "string", "type_none",
     "_null",
     "TensorType", "QuantDtype",
     "Type", "Int", "_NullType",
-    "complex64", "cfloat",
-    "complex128", "cdouble",
-    "bfloat16", "qint4x2",
-    "float8_e4m3fn", "float8_e5m2", "hifloat8",
+    "complex64", "complex128",
     # __method__ from dtype
     "dtype_to_nptype", "dtype_to_pytype",
-    "pytype_to_dtype", "get_py_obj_dtype"
+    "pytype_to_dtype", "get_py_obj_dtype",
+    "bfloat16", "qint4x2",
+    "float8_e4m3fn", "float8_e5m2", "hifloat8"
 ]
 
 __all__.extend([
@@ -108,13 +104,11 @@ __all__.extend([
     "ms_memory_recycle",
     "set_recursion_limit",
     "mutable", "JitConfig",
-    "enable_dynamic",
     "flops_collection",
     "lazy_inline", "load_mindir", "save_mindir",
     "no_inline",
     "Symbol",
     "recompute",
-    "is_tensor", "from_numpy", "_Function",
-    "set_mindio_server_info", "mindio_preload"
+    "is_tensor", "from_numpy", "_Function"
 ])
 __all__.extend(generator.__all__)

mindspore/common/_tensor_cpp_method.py

@@ -14,4 +14,4 @@
 # ============================================================================
 """Add tensor cpp methods for stub tensor"""
 
-tensor_cpp_methods = ['atan2', 'arctan2', 'greater_equal', 'ge', 'acos', 'arccos', 'argmin', 'index_select', 'erfc', 'addcdiv', 'matmul', 'eq', 'put_', 'floor', 'addmv', 'type_as', 'reshape', 'nansum', 'logical_xor', 'logsumexp', 'topk', 'view_as', 'scatter_add', 'tan', 'narrow', 'sin', 'unique', 'copy_', 'baddbmm', 'logical_or', 'scatter_', 'logical_and', 'fill_diagonal_', 'frac', 't', 'median', 'square', 'masked_fill', 'less_equal', 'le', 'true_divide', 'outer', 'sigmoid', 'sinc', 'clamp', 'clip', 'argmax', 'atanh', 'arctanh', 'std', 'div_', '__itruediv__', 'sinh', 'subtract', '_to', 'sub', '__sub__', 'floor_divide', 'rsqrt', 'not_equal', 'ne', 'dot', 'max', 'clone', 'acosh', 'arccosh', 'unsqueeze', 'lerp', 'masked_fill_', 'ceil', 'masked_select', 'index_add', 'mul_', '__imul__', 'chunk', 'unbind', 'log10', 'fmod', 'scatter', 'transpose', 'mm', 'min', 'bitwise_or', '__or__', 'diag', 'greater', 'gt', 'cumsum', 'expm1', 'abs', 'absolute', '__abs__', 'logical_not', 'log', 'gather', 'sqrt', 'where', 'inverse', 'bitwise_and', '__and__', 'new_full', 'flatten', 'argsort', 'xlogy', 'triu', 'tril', 'neg', 'negative', 'erf', 'isfinite', 'repeat', 'add', '__add__', 'logaddexp', 'div', 'divide', 'floor_divide_', '__ifloordiv__', 'bincount', 'sum', 'new_zeros', 'roll', 'var', 'exp_', 'nan_to_num', 'isneginf', 'addbmm', 'minimum', 'remainder_', '__imod__', 'isinf', 'exp', 'pow', '__pow__', 'tanh', 'gcd', 'add_', '__iadd__', 'log1p', 'expand_as', 'isclose', 'allclose', 'bitwise_xor', '__xor__', 'histc', 'cosh', 'asin', 'arcsin', 'new_empty', 'maximum', 'atan', 'arctan', 'any', 'asinh', 'arcsinh', 'masked_scatter', 'trunc', 'mul', 'select', 'bitwise_not', 'fill_', 'all', 'mean', 'sort', 'hardshrink', 'kthvalue', 'addmm', 'remainder', 'reciprocal', 'round', 'log_', 'cos', 'split', 'tile', 'new_ones', 'logaddexp2', '__mod__', 'log2', 'prod', 'less', 'lt', 'sub_', '__isub__', 'take', 'count_nonzero', 'repeat_interleave']
+tensor_cpp_methods = ['atan2', 'arctan2', 'greater_equal', 'ge', 'acos', 'arccos', 'argmin', 'index_select', 'erfc', 'addcdiv', 'matmul', 'eq', 'put_', 'floor', 'addmv', 'type_as', 'reshape', 'nansum', 'logical_xor', 'logsumexp', 'topk', 'view_as', 'scatter_add', 'tan', 'narrow', 'sin', 'unique', 'copy_', 'baddbmm', 'logical_or', 'scatter_', 'logical_and', 'fill_diagonal_', 'frac', 't', 'median', 'square', 'masked_fill', 'less_equal', 'le', 'true_divide', 'outer', 'sigmoid', 'sinc', 'clamp', 'clip', 'argmax', 'atanh', 'arctanh', 'std', 'div_', '__itruediv__', 'sinh', 'subtract', '_to', 'sub', '__sub__', 'floor_divide', 'rsqrt', 'not_equal', 'ne', 'dot', 'max', 'clone', 'acosh', 'arccosh', 'unsqueeze', 'lerp', 'masked_fill_', 'ceil', 'masked_select', 'index_add', 'mul_', '__imul__', 'chunk', 'unbind', 'log10', 'fmod', 'scatter', 'transpose', 'mm', 'min', 'bitwise_or', '__or__', 'diag', 'greater', 'gt', 'cumsum', 'expm1', 'abs', 'absolute', '__abs__', 'logical_not', 'log', 'gather', 'sqrt', 'where', 'inverse', 'bitwise_and', '__and__', 'new_full', 'flatten', 'argsort', 'xlogy', 'triu', 'tril', 'neg', 'negative', 'erf', 'isfinite', 'repeat', 'add', '__add__', 'logaddexp', 'div', 'divide', 'floor_divide_', '__ifloordiv__', 'bincount', 'sum', 'new_zeros', 'roll', 'var', 'exp_', 'nan_to_num', 'isneginf', 'addbmm', 'minimum', 'isinf', 'exp', 'pow', '__pow__', 'tanh', 'gcd', 'add_', '__iadd__', 'log1p', 'expand_as', 'isclose', 'allclose', 'bitwise_xor', '__xor__', 'histc', 'cosh', 'asin', 'arcsin', 'new_empty', 'maximum', 'atan', 'arctan', 'any', 'asinh', 'arcsinh', 'trunc', 'mul', 'select', 'bitwise_not', 'fill_', 'all', 'mean', 'sort', 'hardshrink', 'kthvalue', 'addmm', 'remainder', 'reciprocal', 'round', 'log_', 'cos', 'split', 'tile', 'new_ones', 'logaddexp2', '__mod__', 'log2', 'prod', 'less', 'lt', 'sub_', '__isub__', 'take', 'count_nonzero', 'repeat_interleave']