mindspore 2.6.0rc1__cp310-cp310-win_amd64.whl → 2.7.0rc1__cp310-cp310-win_amd64.whl

mindspore/_extends/parse/standard_method.py

@@ -27,9 +27,11 @@ from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.ops.composite.base import _append, _insert, _pop, _list_clear, _reverse, \
     _extend, _dict_setitem, _dict_clear, _haskey, _update, _fromkeys
 from mindspore.ops.operations._sequence_ops import TensorToTuple
-from mindspore.ops.auto_generate import trace_v2_op, inplace_addmm_op, inplace_index_put_op, inplace_normal_op, inplace_index_add_op
+from mindspore.ops.auto_generate import trace_v2_op, inplace_addmm_op, inplace_index_put_op, inplace_normal_op, \
+    inplace_index_add_op
 from mindspore.ops.auto_generate import inplace_copy_op, inplace_uniform_op, inplace_erfinv_op
 from mindspore.ops.auto_generate import inplace_scatter_add as inplace_scatter_add_
+from mindspore.ops.auto_generate import inplace_exponential_op
 
 from ... import _checkparam as validator
 from ..._checkparam import check_is_number, check_reshape_shp, check_axis_in_range, \
@@ -579,7 +581,7 @@ def transpose(x, *axis):
 
     Raises:
         TypeError: If input arguments have types not specified above.
-        ValueError: If the number of `axes` is not euqal to a.ndim.
+        ValueError: If the number of `axes` is not equal to a.ndim.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1232,7 +1234,7 @@ def pow(x, y):  # pylint: disable=redefined-builtin
     return F.pow(x, y)
 
 
-def put_(x, index, source, accumulate=False):  # pylint: disable=redefined-builtin
+def put_(x, index, source, accumulate=False):
     """
     Copies the elements from source into the positions specified by index.
     """
@@ -2131,14 +2133,14 @@ def _check_sum_to_size(size, input_dim, shape_input):
 
 
 @_primexpr
-def _count_axes(size, input_shape, shape_input):
+def _count_axes(size, input_shape, shape_input, pre_len, pre_axis):
     """Count the sum axes for sum_to_size."""
-    axes = []
+    axes = pre_axis
     for i in range(len(size)):
         element = size[i]
-        if element != input_shape[i] and element == 1:
-            axes.append(i)
-        elif element != input_shape[i]:
+        if element != input_shape[i + pre_len] and element == 1:
+            axes.append(i + pre_len)
+        elif element != input_shape[i + pre_len]:
             raise ValueError(f"For sum_to_size, size {size} is not expandable to the tensor size {shape_input}.")
     return axes
 
@@ -2151,13 +2153,15 @@ def sum_to_size(input, *size):
         size = size[0]
     shape_input = input.shape
     _check_sum_to_size(size, input.ndim, shape_input)
+    pre_len = 0
+    pre_axis = []
     if len(size) < input.ndim:
-        pre_axis = tuple(axis for axis in range(input.ndim - len(size)))
-        input = input.sum(pre_axis)
+        pre_len = input.ndim - len(size)
+        pre_axis = [axis for axis in range(pre_len)]
 
-    axes = _count_axes(size, input.shape, shape_input)
+    axes = _count_axes(size, input.shape, shape_input, pre_len, pre_axis)
     if axes:
-        return input.sum(tuple(axes), keepdims=True)
+        return input.sum(tuple(axes), keepdims=True).reshape(size)
     return input
 
 
@@ -4004,6 +4008,7 @@ def to_double(input_x):
     """
     return F.cast(input_x, mstype.float64)
 
+
 def to_bfloat16(input_x):
     r"""
     Converts input tensor dtype to bfloat16.
@@ -4486,10 +4491,20 @@ def uniform_(input, from_=0, to=1, *, generator=None):
     """
     if generator is None:
         generator = default_generator
-    seed, offset = generator._step(generator_step_) # pylint: disable=protected-access
+    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
     return inplace_uniform_op(input, from_, to, seed, offset)
 
 
+def exponential_(input, lambd=1, *, generator=None):
+    r"""
+        Fills `self` tensor with elements drawn from the exponential distribution:
+    """
+    if generator is None:
+        generator = default_generator
+    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
+    return inplace_exponential_op(input, lambd, seed, offset)
+
+
 def amin(input, axis=None, keep_dims=False):
     r"""
     For details, please refer to :func:`mindspore.ops.amin`.
@@ -4592,3 +4607,18 @@ def zero_(input):
     Return a tensor filled with zeros.
     """
     return F.zero_(input)
+
+
+def slice_get_start(slice_node):
+    """Using SliceGetItem to get slice_node.start"""
+    return F.SliceGetItem(slice_node, "start")
+
+
+def slice_get_stop(slice_node):
+    """Using SliceGetItem to get slice_node.stop"""
+    return F.SliceGetItem(slice_node, "stop")
+
+
+def slice_get_step(slice_node):
+    """Using SliceGetItem to get slice_node.step"""
+    return F.SliceGetItem(slice_node, "step")

mindspore/_extends/parse/trope.py

@@ -37,6 +37,12 @@ from functools import (  # noqa
     partial
 )
 
+from mindspore.ops.composite.multitype_ops.add_impl import augassign_add
+from mindspore.ops.composite.multitype_ops.sub_impl import augassign_sub
+from mindspore.ops.composite.multitype_ops.mul_impl import augassign_mul
+from mindspore.ops.composite.multitype_ops.div_impl import augassign_div
+from mindspore.ops.composite.multitype_ops.floordiv_impl import augassign_floordiv
+
 from ...common import mutable
 
 __all__ = ['add', 'sub', 'mul', 'truediv', 'floordiv', 'mod', 'eq', 'ne', 'lt', 'gt', 'le', 'ge', 'pos', 'neg',
@@ -44,7 +50,8 @@ __all__ = ['add', 'sub', 'mul', 'truediv', 'floordiv', 'mod', 'eq', 'ne', 'lt',
            'matmul', 'getitem', 'setitem',
            'bool', 'getattr', 'setattr', 'hasattr', 'len', 'iter', 'next', 'pow', 'range', 'map', 'zip',
            'partial', 'print', 'enumerate', 'isinstance', 'filter', 'abs', 'round', 'mutable',
-           'max', 'min', 'sum', 'list', 'tuple']
+           'max', 'min', 'sum', 'list', 'tuple',
+           'augassign_add', 'augassign_sub', 'augassign_mul', 'augassign_div', 'augassign_floordiv']
 
 
 def MakeTuple(*elts):  # pragma: no cover

mindspore/_extends/pijit/__init__.py

@@ -16,8 +16,7 @@
 Helper module for pijit analyze
 """
 
+__all__ = ['pijit_func_white_list_map', "get_tensor_method_name"]
 
 from .pijit_func_white_list import _func_map as pijit_func_white_list_map
 from .tensor_func_list import get_tensor_method_name
-
-__all__ = ['pijit_func_white_list_map', "get_tensor_method_name"]

mindspore/amp.py

@@ -327,10 +327,10 @@ class DynamicLossScaler(LossScaler):
     r"""
     Manager for dynamically adjusting the loss scaling factor.
 
-    Dynamic loss scaling tries to determine the largest loss scale value that
-    will keep gradients finite. It does this by increasing the loss scale every
-    `scale_window` steps by `factor` if the grads remain finite, otherwise it reduces
-    the loss scale by `1 / factor` and resets the counter.
+    Dynamic loss scaling attempts to determine the largest loss scale `scale_value` while keeping
+    the gradients finite. If the gradients remain finite for `scale_window` consecutive steps,
+    it increases the loss scale `scale_value` by `scale_factor`, otherwise it decreases the loss
+    scale `scale_value` by `1 / scale_factor` and resets the counter.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.

mindspore/boost/adasum.py

@@ -168,7 +168,7 @@ class AdaSum(Cell):
     @staticmethod
     def _hash(step, target, weights_index):
         target = "tag" + str(step) + str(target) + str(weights_index)
-        target_hash = hashlib.sha1(target.encode()).hexdigest()
+        target_hash = hashlib.sha256(target.encode()).hexdigest()
         max_num_hash = 2 ** 31
         hash_res = int(int(target_hash, 16) % max_num_hash)
         return hash_res

mindspore/boost/boost_cell_wrapper.py

@@ -507,10 +507,10 @@ class BoostTrainOneStepWithLossScaleCell(BoostTrainOneStepCell):
         self.reduce_sum = P.ReduceSum(keep_dims=False)
         self.less_equal = P.LessEqual()
         self.allreduce = P.AllReduce()
-        self.is_distributed = (self.parallel_mode != ParallelMode.STAND_ALONE)
-        self.gpu_target = (context.get_context("device_target") == "GPU")
-        self.ascend_910a_target = (MSContext.get_instance().get_ascend_soc_version() == 'ascend910')
-        self.ascend_910b_target = (MSContext.get_instance().get_ascend_soc_version() in ['ascend910b', 'ascend910_93'])
+        self.is_distributed = self.parallel_mode != ParallelMode.STAND_ALONE
+        self.gpu_target = context.get_context("device_target") == "GPU"
+        self.ascend_910a_target = MSContext.get_instance().get_ascend_soc_version() == 'ascend910'
+        self.ascend_910b_target = MSContext.get_instance().get_ascend_soc_version() in ['ascend910b', 'ascend910_93']
         self.loss_scaling_manager = None
         self._ascend_check_overflow_mode = os.environ.get('MS_ASCEND_CHECK_OVERFLOW_MODE')
 

mindspore/common/__init__.py

@@ -22,7 +22,8 @@ from mindspore.common.dtype import Type, int8, byte, int16, short, int32, intc,
     float32, single, float64, bfloat16, double, bool_, float_, list_, tuple_, int_, \
     uint, number, tensor_type, string, type_none, TensorType, Int, \
     complex64, complex128, dtype_to_nptype, _null, _NullType, \
-    dtype_to_pytype, pytype_to_dtype, get_py_obj_dtype, QuantDtype, qint4x2
+    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.parameter import Parameter, ParameterTuple
 from mindspore.common.seed import set_seed, get_seed
@@ -41,6 +42,29 @@ from mindspore.common.generator import (
 from mindspore.ops.function.array_func import is_tensor, from_numpy
 from mindspore.common._grad_function import _Function
 
+try:
+    import triton
+    if isinstance(getattr(triton.runtime.jit, "type_canonicalisation_dict", None), dict):
+        ms_type_canonicalisation_dict = {
+            "Bool": "i1",
+            "Float16": "fp16",
+            "BFloat16": "bf16",
+            "Float32": "fp32",
+            "Float64": "fp64",
+            "Int8": "i8",
+            "Int16": "i16",
+            "Int32": "i32",
+            "Int64": "i64",
+            "UInt8": "u8",
+            "UInt16": "u16",
+            "UInt32": "u32",
+            "UInt64": "u64",
+        }
+        triton.runtime.jit.type_canonicalisation_dict.update(ms_type_canonicalisation_dict)
+
+except ImportError:
+    pass
+
 # symbols from dtype
 __all__ = [
     "int8", "byte",
@@ -66,7 +90,8 @@ __all__ = [
     # __method__ from dtype
     "dtype_to_nptype", "dtype_to_pytype",
     "pytype_to_dtype", "get_py_obj_dtype",
-    "bfloat16", "qint4x2"
+    "bfloat16", "qint4x2",
+    "float8_e4m3fn", "float8_e5m2", "hifloat8"
 ]
 
 __all__.extend([

mindspore/common/_grad_function.py

@@ -15,11 +15,12 @@
 
 """Defines custom autograd function with functional form."""
 
+__all__ = ['_Function']
+
 from typing import Any
 from mindspore._c_expression import FunctionBase as FunctionBase_
 from mindspore.common.tensor import Tensor
 
-__all__ = ['_Function']
 
 class _Function(FunctionBase_):
     """

mindspore/common/_pijit_context.py

@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-"""Define pijit context"""
-# pylint: disable=missing-docstring
+
+"""Define pijit context."""
+
 import inspect
 import types
 import functools
@@ -37,14 +38,22 @@ def _update_graph_executor_config(jit_config):
     GraphExecutor_.get_instance().set_jit_config(JitConfig(**valid_config).jit_config_dict)
 
 
+class Unsupported(RuntimeError):
+    """If using @jit(fullgraph=True), pijit will raise an Unsupported exception when encountering a graph break."""
+
+    # pylint: disable=useless-super-delegation
+    def __init__(self, msg: str):
+        super().__init__(msg)
+
+
 class PIJitCaptureContext:
     """
     Context manager for pijit graph capture
     """
 
-    def __init__(self, jit_config=None, input_signature=None):
+    def __init__(self, fullgraph=False, jit_config=None, input_signature=None):
         _update_graph_executor_config(jit_config)
-        config = {}
+        config = {'fullgraph': fullgraph}
         if isinstance(jit_config, JitConfig):
             config.update(jit_config.jit_config_dict)
         elif jit_config is not None:
@@ -74,6 +83,9 @@ class PIJitCaptureContext:
             or inspect.isasyncgenfunction(fn) or inspect.isawaitable(fn)
 
     def _wrapper(self):
+        """
+        pijit wrapper of fn.
+        """
         def _fn(*args, **kwds):
             PreJit(args, kwds)
             disable_pijit = self.config.get('_disable_pijit', None)
@@ -82,21 +94,27 @@ class PIJitCaptureContext:
             with self:
                 self.ret = self.fn(*args, **kwds)
                 return self.ret
+
         return _fn
 
     def __call__(self, fn):
+        """
+        :raises Unsupported: If using @jit(fullgraph=True), will raise exception when encountering a graph break.
+        """
         if isinstance(fn, type) and issubclass(fn, mindspore.nn.Cell):
             fn.construct = self(fn.construct)
             return fn
         if isinstance(fn, mindspore.nn.Cell):
-            type(fn).construct = self(type(fn).construct)
-            return fn
+            return types.MethodType(self(fn.construct.__func__), fn)
         if isinstance(fn, types.MethodType):
             return types.MethodType(self(fn.__func__), fn.__self__)
         if not isinstance(fn, types.FunctionType) or self._is_unsupported(fn):
             logger.warning("unsupported function type" + str(fn))
             return fn
 
+        if hasattr(fn, "__wrapped_by_jit__"):
+            logger.warning(f"The fn {fn} should be wrapped by jit only once.")
+
         module = inspect.getmodule(fn.__code__)
         if module is not None and module.__name__.startswith("mindspore"):
             if fn.__code__.co_name != 'after_grad':
@@ -107,7 +125,9 @@ class PIJitCaptureContext:
         if fn.__code__ is _fn.__code__:
             fn = fn.__closure__[0].cell_contents.fn
         self.fn = fn
-        return functools.wraps(fn)(_fn)
+        wrap_fn = functools.wraps(fn)(_fn)
+        setattr(wrap_fn, "__wrapped_by_jit__", True)
+        return wrap_fn
 
     def __enter__(self):
         pi_jit_set_context(self.fn, *self._init_arg)
@@ -122,6 +142,7 @@ def _get_skip_files():
     """
     Get skip files by SKIP_RULES
     """
+
     def _filter(path: str):
         if path.endswith("__init__.py"):
             return path[0:-11]

mindspore/common/_stub_tensor.py

@@ -14,213 +14,5 @@
 # ============================================================================
 """Stub Tensor implementation."""
 
-import inspect
-from functools import reduce
-from mindspore.common.tensor import Tensor
-from mindspore.common.dtype import type_size_in_bytes
-import mindspore._c_expression as c_expression
-from mindspore._c_expression import TensorNode, SequenceNode, NoneTypeNode, AnyTypeNode
-from mindspore._c_expression import TensorPy as Tensor_
-from mindspore.common.api import _convert_python_data
-from mindspore.common._tensor_cpp_method import tensor_cpp_methods
-
-
-def _stub_member(var, init):
-    """handle stub tensor's member, use a member cache to improve performance"""
-    def getx(stub):
-        if stub.tensor is not None:
-            return getattr(stub.tensor, var)
-        if hasattr(stub, "member_cache"):
-            return stub.member_cache.get(var, init)
-        return init
-
-    def setx(stub, value):
-        if stub.tensor is not None:
-            setattr(stub.tensor, var, value)
-        else:
-            if not hasattr(stub, "member_cache"):
-                stub.member_cache = {}
-            stub.member_cache[var] = value
-    return property(getx, setx)
-
-
-def _stub_method(method):
-    def fun(*arg, **kwargs):
-        stub = arg[0]
-        arg = (stub.stub_sync(),) + arg[1:]
-        return method(*arg, **kwargs)
-    return fun
-
-
 class StubTensor:
-    """stub tensor for async op run."""
-    const_arg = _stub_member("const_arg", None)
-    init = _stub_member("init", None)
-    init_finished = _stub_member("init_finished", False)
-    virtual_flag = _stub_member("virtual_flag", False)
-    parent_tensor_ = _stub_member("parent_tensor_", None)
-    index_of_parent_ = _stub_member("index_of_parent_", None)
-    slice_num_of_persistent_data_ = _stub_member("slice_num_of_persistent_data_", None)
-    slice_shape_of_persistent_data_ = _stub_member("slice_shape_of_persistent_data_", None)
-
-    def __init__(self, stub=None, tensor=None):
-        self.stub = stub
-        self.tensor = tensor
-
-    __str__ = _stub_method(Tensor.__str__)
-    __repr__ = _stub_method(Tensor.__repr__)
-    __setitem__ = _stub_method(Tensor.__setitem__)
-
-    __lt__ = Tensor.__lt__
-    __le__ = Tensor.__le__
-    __gt__ = Tensor.__gt__
-    __ge__ = Tensor.__ge__
-    __eq__ = Tensor.__eq__
-    __ne__ = Tensor.__ne__
-
-    @property
-    def shape(self):
-        """shape stub."""
-        if self.stub:
-            if not hasattr(self, "stub_shape"):
-                self.stub_shape = self.stub.get_shape()
-            return self.stub_shape
-        return self.tensor.shape
-
-    @property
-    def dtype(self):
-        """dtype stub."""
-        if self.stub:
-            if not hasattr(self, "stub_dtype"):
-                self.stub_dtype = self.stub.get_dtype()
-            return self.stub_dtype
-        return self.tensor.dtype
-
-    @property
-    def size(self):
-        """size stub."""
-        shape = self.shape
-        return reduce((lambda x, y: x * y), shape) if shape else 1
-
-    @property
-    def itemsize(self):
-        """itemsize stub."""
-        return type_size_in_bytes(self.dtype)
-
-    @property
-    def nbytes(self):
-        """nbytes stub."""
-        return self.size * self.itemsize
-
-    @property
-    def ndim(self):
-        """ndim stub."""
-        return len(self.shape)
-
-    @property
-    def strides(self):
-        """strides stub."""
-        return self.stub_sync().strides
-
-    @property
-    def has_init(self):
-        """has_init stub."""
-        return False
-
-    def ndimension(self):
-        r"""
-        Alias for :func:`mindspore.Tensor.ndim`.
-        """
-        return self.ndim
-
-    def dim(self):
-        r"""
-        Alias for :func:`mindspore.Tensor.ndim`.
-        """
-        return self.ndim
-
-
-    def is_contiguous(self):
-        if self.stub:
-            return self.stub.get_value().is_contiguous()
-        return self.tensor.is_contiguous()
-
-    def set_cast_dtype(self):
-        if self.stub:
-            return self.stub.get_value().set_cast_dtype()
-        return self.tensor.set_cast_dtype()
-
-    def storage_offset(self):
-        if self.stub:
-            return self.stub.get_value().storage_offset()
-        return self.tensor.storage_offset()
-
-    def _need_contiguous(self):
-        if self.stub:
-            return self.stub.get_value()._need_contiguous()  # pylint: disable=protected-access
-        return self.tensor._need_contiguous()  # pylint: disable=protected-access
-
-    asnumpy = _stub_method(Tensor.asnumpy)
-    is_persistent_data = _stub_method(Tensor.is_persistent_data)
-    asnumpy_of_slice_persistent_data = _stub_method(Tensor.asnumpy_of_slice_persistent_data)
-    slice_num_of_persistent_data = _stub_method(Tensor.slice_num_of_persistent_data)
-    slice_shape_of_persistent_data = _stub_method(Tensor.slice_shape_of_persistent_data)
-    flush_from_cache = _stub_method(Tensor.flush_from_cache)
-    register_hook = _stub_method(Tensor.register_hook)
-
-    def stub_sync(self):
-        """sync real tensor."""
-        if self.stub:
-            val = self.stub.get_value()
-            self.tensor = Tensor(val)
-            if hasattr(self, "member_cache"):
-                for k, v in self.member_cache.items():
-                    setattr(self.tensor, k, v)
-            self.stub = None
-        return self.tensor
-
-    def __getstate__(self):
-        state = {}
-        value = self.stub.get_value() if self.stub else self.tensor.__getstate__()
-        state["value"] = value
-        return state
-
-    def __setstate__(self, state):
-        value = state.pop("value")
-        self.stub = None
-        self.tensor = Tensor(value)
-
-no_stub_sync_cpp_api = ["set_cast_dtype", "storage_offset", "is_contiguous", "_need_contiguous"]
-
-def _init_stub_tensor_api():
-    """adapt to python tensor and cpp tensor api"""
-    need_init_func = set(dir(Tensor)) - set(dir(StubTensor))
-    cpp_tensor_func = dir(Tensor_)
-    for attr in need_init_func:
-        func = inspect.getattr_static(Tensor, attr)
-        if attr in cpp_tensor_func and attr not in tensor_cpp_methods:
-            # for cpp tensor api, we always need to sync for real tensor first
-            setattr(StubTensor, attr, _stub_method(func))
-        elif attr not in no_stub_sync_cpp_api:
-            setattr(StubTensor, attr, func)
-
-
-_init_stub_tensor_api()
-c_expression.addStubTensorMethods()
-
-def _convert_stub(stub):
-    "convert stub to StubNode or Value"
-    if isinstance(stub, TensorNode):
-        return StubTensor(stub)
-    if isinstance(stub, tuple):
-        return tuple(_convert_stub(e) for e in stub)
-    if isinstance(stub, SequenceNode):
-        elements = stub.get_elements()
-        return tuple(_convert_stub(e) for e in elements)
-    if isinstance(stub, NoneTypeNode):
-        val = stub.get_real_value()
-        return _convert_python_data(val)
-    if isinstance(stub, AnyTypeNode):
-        val = stub.get_real_node()
-        return _convert_stub(val)
-    return _convert_python_data(stub)
+    """Remove this class when other modules are adapted."""

mindspore/common/_tensor_cpp_method.py

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