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

mindspore/amp.py

@@ -167,9 +167,6 @@ 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')
@@ -185,9 +182,6 @@ 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.
 
@@ -327,10 +321,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.
@@ -377,10 +371,6 @@ 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)
@@ -394,10 +384,6 @@ 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)
@@ -408,10 +394,6 @@ 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/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

@@ -1,4 +1,4 @@
-# Copyright 2020-2024 Huawei Technologies Co., Ltd
+# Copyright 2020-2025 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,13 +17,15 @@ 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, int32, intc, int64, intp, \
+from mindspore.common.dtype import Type, int8, byte, int16, short, int, int32, intc, long, int64, intp, \
     uint8, ubyte, uint16, ushort, uint32, uintc, uint64, uintp, float16, half, \
-    float32, single, float64, bfloat16, double, bool_, float_, list_, tuple_, int_, \
+    float, float32, single, float64, bfloat16, double, bool, 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
+    cfloat, complex64, cdouble, 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
@@ -40,13 +42,39 @@ 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
+    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
+# bool, int, float are not defined in __all__ to avoid conflict with built-in types.
 __all__ = [
+    "bool_",
     "int8", "byte",
     "int16", "short",
     "int32", "intc",
-    "int64", "intp",
+    "int64", "long", "intp",
     "uint8", "ubyte",
     "uint16", "ushort",
     "uint32", "uintc",
@@ -54,19 +82,20 @@ __all__ = [
     "float16", "half",
     "float32", "single",
     "float64", "double",
-    "bool_", "float_",
-    "list_", "tuple_",
+    "float_", "list_", "tuple_",
     "int_", "uint",
     "number", "tensor_type",
     "string", "type_none",
     "_null",
     "TensorType", "QuantDtype",
     "Type", "Int", "_NullType",
-    "complex64", "complex128",
+    "complex64", "cfloat",
+    "complex128", "cdouble",
+    "bfloat16", "qint4x2",
+    "float8_e4m3fn", "float8_e5m2", "hifloat8",
     # __method__ from dtype
     "dtype_to_nptype", "dtype_to_pytype",
-    "pytype_to_dtype", "get_py_obj_dtype",
-    "bfloat16", "qint4x2"
+    "pytype_to_dtype", "get_py_obj_dtype"
 ]
 
 __all__.extend([
@@ -79,11 +108,13 @@ __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"
+    "is_tensor", "from_numpy", "_Function",
+    "set_mindio_server_info", "mindio_preload"
 ])
 __all__.extend(generator.__all__)

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_scatter', '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', 'remainder_', '__imod__', '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__']