msadapter 0.1.0b0__py3-none-any.whl

msadapter/__init__.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from msadapter import pytorch
+from msadapter.utils import unsupported_attr, pynative_mode_condition

msadapter/pytorch/__init__.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Register MSAdapter Tensor/Parameter to MindSpore, it should be executed at the top of all.
+from msadapter.pytorch._register import *
+from msadapter.pytorch.common import *
+from msadapter.pytorch.tensor import *
+from msadapter.pytorch import nn
+from msadapter.pytorch import optim
+from msadapter.pytorch.functional import *
+from msadapter.pytorch.utils import data
+from msadapter.pytorch._ref import *
+from msadapter.pytorch import cuda
+from msadapter.pytorch.conflict_functional import *
+import msadapter.pytorch.fft as fft
+from msadapter.pytorch import autograd
+from msadapter.pytorch.package_info import __version__, VERSION, version
+from msadapter.pytorch.random import *
+from msadapter.pytorch.storage import *
+from msadapter.pytorch.serialization import *
+import msadapter.pytorch.linalg as linalg
+from msadapter.pytorch.linalg import *
+
+def _assert(condition, message):
+    assert condition, message
+
+def is_tensor(obj):
+    r"""Returns True if `obj` is a msadapter.pytorch tensor.
+
+    Note that this function is simply doing ``isinstance(obj, Tensor)``.
+    Using that ``isinstance`` check is better for typechecking with mypy,
+    and more explicit - so it's recommended to use that instead of
+    ``is_tensor``.
+    """
+    return isinstance(obj, Tensor)
+
+def is_floating_point(obj):
+    if not is_tensor(obj):
+        raise TypeError("is_floating_point(): argument 'input' (position 1) must be Tensor, not {}.".format(type(obj)))
+
+    return obj._dtype in (mstype.float16, mstype.float32, mstype.float64)
+
+class Size(tuple):
+    def __new__(cls, shape):
+        if isinstance(shape, Tensor):
+            _shape = shape.tolist()
+        else:
+            _shape = shape
+        if not isinstance(_shape, (tuple, list)):
+            raise TypeError("{} object is not supportted.".format(type(shape)))
+
+        return tuple.__new__(Size, _shape)

msadapter/pytorch/_ref/__init__.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from msadapter.pytorch.tensor import Tensor
+
+def typename(o):
+    if isinstance(o, Tensor):
+        return o.type()
+
+    module = ''
+    class_name = ''
+    if hasattr(o, '__module__') and o.__module__ != 'builtins' \
+            and o.__module__ != '__builtin__' and o.__module__ is not None:
+        module = o.__module__ + '.'
+
+    if hasattr(o, '__qualname__'):
+        class_name = o.__qualname__
+    elif hasattr(o, '__name__'):
+        class_name = o.__name__
+    else:
+        class_name = o.__class__.__name__
+
+    return module + class_name

msadapter/pytorch/_register/__init__.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from mindspore.common.api import set_adapter_config
+from mindspore._extends.parse import trope as T
+from mindspore._extends.parse.resources import convert_object_map
+
+from msadapter.pytorch.tensor import Tensor
+from msadapter.pytorch.nn import Parameter
+from msadapter.pytorch._register import register_multitype_ops
+from msadapter.pytorch._register import register_standard_method as S
+
+
+convert_object_map[T.add] = register_multitype_ops.add              # x+y
+convert_object_map[T.sub] = register_multitype_ops.sub              # x-y
+convert_object_map[T.mul] = register_multitype_ops.mul              # x*y
+convert_object_map[T.truediv] = register_multitype_ops.div          # x/y
+convert_object_map[T.getitem] = register_multitype_ops.getitem      # x[0]
+convert_object_map[T.setitem] = register_multitype_ops.setitem      # x[0]=y
+convert_object_map[T.floordiv] = register_multitype_ops.floordiv    # x//y
+convert_object_map[T.mod] = register_multitype_ops.mod              # x%y
+convert_object_map[T.pow] = register_multitype_ops.pow_             # x**y
+convert_object_map[T.and_] = register_multitype_ops.bitwise_and     # x&y
+convert_object_map[T.or_] = register_multitype_ops.bitwise_or       # x|y
+convert_object_map[T.xor] = register_multitype_ops.bitwise_xor      # x^y
+convert_object_map[T.neg] = register_multitype_ops.negative         # -x
+convert_object_map[T.not_] = register_multitype_ops.logical_not     # not x
+convert_object_map[T.eq] = register_multitype_ops.equal             # x==y
+convert_object_map[T.ne] = register_multitype_ops.not_equal         # x!=y
+convert_object_map[T.lt] = register_multitype_ops.less              # x < y
+convert_object_map[T.gt] = register_multitype_ops.greater           # x > y
+convert_object_map[T.le] = register_multitype_ops.less_equal        # x <= y
+convert_object_map[T.ge] = register_multitype_ops.greater_equal     # x >= y
+convert_object_map[T.contains] = register_multitype_ops.in_         # x in y
+convert_object_map[T.not_contains] = register_multitype_ops.not_in_ # x not in y
+convert_object_map[T.matmul] = S.adapter_matmul                     # x @ y
+convert_object_map[T.invert] = S.adapter_invert                     # ~x
+convert_object_map[T.abs] = S.adapter_abs                           # abs(x)
+convert_object_map[T.round] = S.adapter_round                       # round(x)
+convert_object_map[T.max] = S.adapter_max                           # max(x)
+convert_object_map[T.min] = S.adapter_min                           # min(x)
+convert_object_map[T.sum] = S.adapter_sum                           # sum(x)
+
+
+def register_msadapter_tensor():
+    adapter_config = {"Tensor": Tensor, "convert_object_map": convert_object_map}
+    set_adapter_config(adapter_config)
+
+register_msadapter_tensor()

msadapter/pytorch/_register/getitem_impl.py

@@ -0,0 +1,45 @@
+
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import mindspore as ms
+from mindspore import dtype as mstype
+from mindspore.ops.composite.multitype_ops import _compile_utils as compile_utils
+
+
+def _tensor_getitem_by_tensor(data, tensor_index):
+    if tensor_index.dtype == mstype.bool_:
+        ms_shape_len = len(data.shape)
+        index_shape_len = len(tensor_index.shape)
+        out_shape = [-1]
+        while index_shape_len < ms_shape_len:
+            out_shape.append(data.shape[index_shape_len])
+            tensor_index = tensor_index.expand_dims(-1)
+            index_shape_len += 1
+        out = ms.ops.masked_select(data, tensor_index)
+        if len(out_shape) > 1:
+            out = out.reshape(out_shape)
+    else:
+        out = compile_utils.tensor_index_by_tensor(data, tensor_index)
+    return out
+
+
+def _tensor_getitem_by_number(data, number_index):
+    if isinstance(number_index, bool):
+        if number_index:
+            return data.expand_dims(0)
+        else:
+            index = ms.Tensor(False)
+            out = ms.ops.masked_select(data, index)
+            return out
+    return compile_utils.tensor_index_by_number(data, number_index)
+
+
+def _tensor_getitem_by_tuple(data, tuple_index):
+    if isinstance(tuple_index[0], bool):
+        if False in tuple_index:
+            index = ms.Tensor(False)
+            out = ms.ops.masked_select(data, index)
+            return out
+        else:
+            return data.expand_dims(0)
+    return compile_utils.tensor_index_by_tuple(data, tuple_index)

msadapter/pytorch/_register/register_multitype_ops.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from mindspore.ops.composite.multitype_ops.add_impl import add
+from mindspore.ops.composite.multitype_ops.sub_impl import sub
+from mindspore.ops.composite.multitype_ops.mul_impl import mul
+from mindspore.ops.composite.multitype_ops.div_impl import div
+from mindspore.ops.composite.multitype_ops.floordiv_impl import floordiv
+from mindspore.ops.composite.multitype_ops.mod_impl import mod
+from mindspore.ops.composite.multitype_ops.pow_impl import pow_
+from mindspore.ops.composite.multitype_ops.bitwise_and_impl import bitwise_and
+from mindspore.ops.composite.multitype_ops.bitwise_or_impl import bitwise_or
+from mindspore.ops.composite.multitype_ops.bitwise_xor_impl import bitwise_xor
+from mindspore.ops.composite.multitype_ops.negative_impl import negative
+from mindspore.ops.composite.multitype_ops.logic_not_impl import logical_not
+from mindspore.ops.composite.multitype_ops.equal_impl import equal
+from mindspore.ops.composite.multitype_ops.not_equal_impl import not_equal
+from mindspore.ops.composite.multitype_ops.less_impl import less
+from mindspore.ops.composite.multitype_ops.greater_impl import greater
+from mindspore.ops.composite.multitype_ops.less_equal_impl import less_equal
+from mindspore.ops.composite.multitype_ops.greater_equal_impl import greater_equal
+from mindspore.ops.composite.multitype_ops.in_impl import in_
+from mindspore.ops.composite.multitype_ops.not_in_impl import not_in_
+from mindspore.ops.composite.multitype_ops.getitem_impl import getitem
+from mindspore.ops.composite.multitype_ops.setitem_impl import setitem
+from msadapter.pytorch._register import register_utils as utils
+from msadapter.pytorch._register.getitem_impl import _tensor_getitem_by_tensor, _tensor_getitem_by_number, \
+    _tensor_getitem_by_tuple
+
+
+# multitype_ops.add
+utils.update_multitype_ops_tensor_tensor(add)
+utils.update_multitype_ops_number_tensor(add)
+utils.update_multitype_ops_tensor_number(add)
+utils.update_multitype_ops_tuple_tensor(add)
+utils.update_multitype_ops_tensor_tuple(add)
+utils.update_multitype_ops_list_tensor(add)
+utils.update_multitype_ops_tensor_list(add)
+
+# multitype_ops.sub
+utils.update_multitype_ops_tensor_tensor(sub)
+utils.update_multitype_ops_number_tensor(sub)
+utils.update_multitype_ops_tensor_number(sub)
+utils.update_multitype_ops_tuple_tensor(sub)
+utils.update_multitype_ops_tensor_tuple(sub)
+utils.update_multitype_ops_list_tensor(sub)
+utils.update_multitype_ops_tensor_list(sub)
+
+# multitype_ops.mul
+utils.update_multitype_ops_tensor_tensor(mul)
+utils.update_multitype_ops_number_tensor(mul)
+utils.update_multitype_ops_tensor_number(mul)
+utils.update_multitype_ops_tuple_tensor(mul)
+utils.update_multitype_ops_tensor_tuple(mul)
+utils.update_multitype_ops_list_tensor(mul)
+utils.update_multitype_ops_tensor_list(mul)
+
+# multitype_ops.div
+utils.update_multitype_ops_tensor_tensor(div)
+utils.update_multitype_ops_number_tensor(div)
+utils.update_multitype_ops_tensor_number(div)
+utils.update_multitype_ops_tuple_tensor(div)
+utils.update_multitype_ops_tensor_tuple(div)
+utils.update_multitype_ops_list_tensor(div)
+utils.update_multitype_ops_tensor_list(div)
+
+# multitype_ops.floordiv
+utils.update_multitype_ops_tensor_tensor(floordiv)
+utils.update_multitype_ops_number_tensor(floordiv)
+utils.update_multitype_ops_tensor_number(floordiv)
+utils.update_multitype_ops_tuple_tensor(floordiv)
+utils.update_multitype_ops_tensor_tuple(floordiv)
+utils.update_multitype_ops_list_tensor(floordiv)
+utils.update_multitype_ops_tensor_list(floordiv)
+
+# multitype_ops.mod
+utils.update_multitype_ops_tensor_tensor(mod)
+utils.update_multitype_ops_number_tensor(mod)
+utils.update_multitype_ops_tensor_number(mod)
+utils.update_multitype_ops_tuple_tensor(mod)
+utils.update_multitype_ops_tensor_tuple(mod)
+utils.update_multitype_ops_list_tensor(mod)
+utils.update_multitype_ops_tensor_list(mod)
+
+# multitype_ops.pow_
+utils.update_multitype_ops_tensor_tensor(pow_)
+utils.update_multitype_ops_number_tensor(pow_)
+utils.update_multitype_ops_tensor_number(pow_)
+utils.update_multitype_ops_tuple_tensor(pow_)
+utils.update_multitype_ops_tensor_tuple(pow_)
+utils.update_multitype_ops_list_tensor(pow_)
+utils.update_multitype_ops_tensor_list(pow_)
+
+# multitype_ops.bitwise_and
+utils.update_multitype_ops_tensor_tensor(bitwise_and)
+utils.update_multitype_ops_number_tensor(bitwise_and)
+utils.update_multitype_ops_tensor_number(bitwise_and)
+
+# multitype_ops.bitwise_or
+utils.update_multitype_ops_tensor_tensor(bitwise_or)
+utils.update_multitype_ops_number_tensor(bitwise_or)
+utils.update_multitype_ops_tensor_number(bitwise_or)
+
+# multitype_ops.bitwise_xor
+utils.update_multitype_ops_tensor_tensor(bitwise_xor)
+utils.update_multitype_ops_number_tensor(bitwise_xor)
+utils.update_multitype_ops_tensor_number(bitwise_xor)
+
+# multitype_ops.negative
+utils.update_multitype_ops_tensor(negative)
+
+# multitype_ops.logical_not
+# LogicalNot only support Tensor[Bool].
+utils.update_multitype_ops_tensor(logical_not)
+
+# multitype_ops.equal
+utils.update_multitype_ops_tensor_tensor(equal)
+utils.update_multitype_ops_number_tensor(equal)
+utils.update_multitype_ops_tensor_number(equal)
+
+# multitype_ops.not_equal
+utils.update_multitype_ops_tensor_tensor(not_equal)
+utils.update_multitype_ops_number_tensor(not_equal)
+utils.update_multitype_ops_tensor_number(not_equal)
+
+# multitype_ops.less
+utils.update_multitype_ops_tensor_tensor(less)
+utils.update_multitype_ops_number_tensor(less)
+utils.update_multitype_ops_tensor_number(less)
+
+# multitype_ops.greater
+utils.update_multitype_ops_tensor_tensor(greater)
+utils.update_multitype_ops_number_tensor(greater)
+utils.update_multitype_ops_tensor_number(greater)
+
+# multitype_ops.less_equal
+utils.update_multitype_ops_tensor_tensor(less_equal)
+utils.update_multitype_ops_number_tensor(less_equal)
+utils.update_multitype_ops_tensor_number(less_equal)
+
+# multitype_ops.greater_equal
+utils.update_multitype_ops_tensor_tensor(greater_equal)
+utils.update_multitype_ops_number_tensor(greater_equal)
+utils.update_multitype_ops_tensor_number(greater_equal)
+
+# multitype_ops.in_
+utils.update_multitype_ops_tensor_tuple(in_)
+utils.update_multitype_ops_tensor_list(in_)
+
+# multitype_ops.not_in_
+utils.update_multitype_ops_tensor_tuple(not_in_)
+utils.update_multitype_ops_tensor_list(not_in_)
+
+# multitype_ops.getitem
+utils.update_multitype_ops_tensor_list(getitem)
+utils.update_multitype_ops_tensor_none(getitem)
+utils.update_multitype_ops_tensor_slice(getitem)
+utils.update_multitype_ops_tensor_tensor_with_fn(getitem, _tensor_getitem_by_tensor)
+utils.update_multitype_ops_tensor_number_with_fn(getitem, _tensor_getitem_by_number)
+utils.update_multitype_ops_tensor_tuple_with_fn(getitem, _tensor_getitem_by_tuple)
+
+# multitype_ops.setitem
+utils.update_multitype_ops_setitem_tensor(setitem)

msadapter/pytorch/_register/register_standard_method.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from mindspore import dtype as mstype
+from mindspore._extends.parse import trope as T
+from mindspore._extends.parse.resources import convert_object_map
+from msadapter.pytorch.tensor import Tensor as adapter_Tensor
+from msadapter.pytorch._register.register_utils import convert_to_ms_tensor, convert_to_adapter_tensor
+
+
+matmul_fn = convert_object_map.get(T.matmul)
+invert_fn = convert_object_map.get(T.invert)
+abs_fn = convert_object_map.get(T.abs)
+round_fn = convert_object_map.get(T.round)
+max_fn = convert_object_map.get(T.max)
+min_fn = convert_object_map.get(T.min)
+sum_fn = convert_object_map.get(T.sum)
+
+
+def adapter_matmul(x, y):
+    if isinstance(x, adapter_Tensor) and isinstance(y, adapter_Tensor):
+        x = convert_to_ms_tensor(x)
+        y = convert_to_ms_tensor(y)
+        out = matmul_fn(x, y)
+        out = convert_to_adapter_tensor(out)
+    else:
+        out = matmul_fn(x, y)
+    return out
+
+
+def adapter_invert(x):
+    if isinstance(x, adapter_Tensor):
+        x = convert_to_ms_tensor(x)
+        if x.dtype != mstype.bool_:
+            out = - 1 - x
+        else:
+            out = invert_fn(x)
+        out = convert_to_adapter_tensor(out)
+    else:
+        out = invert_fn(x)
+    return out
+
+
+def adapter_abs(x):
+    if isinstance(x, adapter_Tensor):
+        x = convert_to_ms_tensor(x)
+        out = abs_fn(x)
+        out = convert_to_adapter_tensor(out)
+    else:
+        out = abs_fn(x)
+    return out
+
+
+def adapter_round(*data):
+    if (len(data) == 1 and isinstance(data[0], adapter_Tensor)) or \
+      (len(data) == 2 and isinstance(data[0], adapter_Tensor) and data[1] is None):
+        x = data[0]
+        x = convert_to_ms_tensor(x)
+        out = round_fn(x)
+        out = convert_to_adapter_tensor(out)
+    else:
+        out = round_fn(*data)
+    return out
+
+
+def _has_adapter_tensor(*data):
+    if len(data) == 1 and isinstance(data[0], adapter_Tensor):
+        return True
+    for elem in data:
+        if isinstance(elem, adapter_Tensor):
+            return True
+    return False
+
+
+def adapter_max(*data):
+    if _has_adapter_tensor(*data):
+        out = max_fn(*data)
+        out = convert_to_adapter_tensor(out)
+    else:
+        out = max_fn(*data)
+    return out
+
+
+def adapter_min(*data):
+    if _has_adapter_tensor(*data):
+        out = min_fn(*data)
+        out = convert_to_adapter_tensor(out)
+    else:
+        out = min_fn(*data)
+    return out
+
+
+def adapter_sum(*data):
+    if _has_adapter_tensor(*data):
+        out = sum_fn(*data)
+        out = convert_to_adapter_tensor(out)
+    else:
+        out = sum_fn(*data)
+    return out

msadapter/pytorch/_register/register_utils.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import mindspore as ms
+from mindspore import dtype as mstype
+from mindspore.ops.operations import _inner_ops as inner
+from msadapter.pytorch.tensor import Tensor as adapter_Tensor
+
+
+def convert_to_ms_tensor(x):
+    return inner.convert_to_ms_tensor(x)
+
+
+def convert_to_adapter_tensor(x):
+    return inner.convert_to_adapter_tensor(x)
+
+
+def convert_output(out):
+    if isinstance(out, ms.Tensor):
+        out = convert_to_adapter_tensor(out)
+    return out
+
+
+def get_registed_fn(ops, *type_names):
+    types = tuple(map(mstype.typing.str_to_type, type_names))
+    for sigs, fn in ops.entries:
+        if len(sigs) != len(types):
+            continue
+        if any(not mstype._issubclass_(type_, sig) for sig, type_ in zip(sigs, types)):
+            continue
+        return fn
+    raise ValueError(f"For 'MultitypeFuncGraph', cannot find fn match given types: {types}.")
+
+
+def _multitype_ops_tensor_calcu(ops, func1, func2):
+    @ops.register("Tensor")
+    def _tensor(x):
+        if isinstance(x, adapter_Tensor):
+            x = convert_to_ms_tensor(x)
+            out = func1(x)
+            out = convert_output(out)
+        else:
+            out = func2(x)
+        return out
+
+def update_multitype_ops_tensor_with_fn(ops, func1):
+    func2 = get_registed_fn(ops, "Tensor")
+    _multitype_ops_tensor_calcu(ops, func1, func2)
+
+def update_multitype_ops_tensor(ops):
+    func = get_registed_fn(ops, "Tensor")
+    _multitype_ops_tensor_calcu(ops, func, func)
+
+
+def _multitype_ops_tensor_tensor_calcu(ops, func1, func2):
+    @ops.register("Tensor", "Tensor")
+    def _tensor_and_tensor(x, y):
+        if isinstance(x, adapter_Tensor) and isinstance(y, adapter_Tensor):
+            x = convert_to_ms_tensor(x)
+            y = convert_to_ms_tensor(y)
+            out = func1(x, y)
+            out = convert_output(out)
+        else:
+            out = func2(x, y)
+        return out
+
+def update_multitype_ops_tensor_tensor_with_fn(ops, func1):
+    func2 = get_registed_fn(ops, "Tensor", "Tensor")
+    _multitype_ops_tensor_tensor_calcu(ops, func1, func2)
+
+def update_multitype_ops_tensor_tensor(ops):
+    func = get_registed_fn(ops, "Tensor", "Tensor")
+    _multitype_ops_tensor_tensor_calcu(ops, func, func)
+
+
+def _multitype_ops_number_tensor_calcu(ops, func1, func2):
+    @ops.register("Number", "Tensor")
+    def _number_and_tensor(x, y):
+        if isinstance(y, adapter_Tensor):
+            y = convert_to_ms_tensor(y)
+            out = func1(x, y)
+            out = convert_output(out)
+        else:
+            out = func2(x, y)
+        return out
+
+def update_multitype_ops_number_tensor_with_fn(ops, func1):
+    func2 = get_registed_fn(ops, "Number", "Tensor")
+    _multitype_ops_number_tensor_calcu(ops, func1, func2)
+
+def update_multitype_ops_number_tensor(ops):
+    func = get_registed_fn(ops, "Number", "Tensor")
+    _multitype_ops_number_tensor_calcu(ops, func, func)
+
+
+def _multitype_ops_tensor_number_calcu(ops, func1, func2):
+    @ops.register("Tensor", "Number")
+    def _tensor_and_number(x, y):
+        if isinstance(x, adapter_Tensor):
+            x = convert_to_ms_tensor(x)
+            out = func1(x, y)
+            out = convert_output(out)
+        else:
+            out = func2(x, y)
+        return out
+
+def update_multitype_ops_tensor_number_with_fn(ops, func1):
+    func2 = get_registed_fn(ops, "Tensor", "Number")
+    _multitype_ops_tensor_number_calcu(ops, func1, func2)
+
+def update_multitype_ops_tensor_number(ops):
+    func = get_registed_fn(ops, "Tensor", "Number")
+    _multitype_ops_tensor_number_calcu(ops, func, func)
+
+
+def _multitype_ops_tuple_tensor_calcu(ops, func1, func2):
+    @ops.register("Tuple", "Tensor")
+    def _tuple_and_tensor(x, y):
+        if isinstance(y, adapter_Tensor):
+            y = convert_to_ms_tensor(y)
+            out = func1(x, y)
+            out = convert_output(out)
+        else:
+            out = func2(x, y)
+        return out
+
+
+def update_multitype_ops_tuple_tensor_with_fn(ops, func1):
+    func2 = get_registed_fn(ops, "Tuple", "Tensor")
+    _multitype_ops_tuple_tensor_calcu(ops, func1, func2)
+
+def update_multitype_ops_tuple_tensor(ops):
+    func = get_registed_fn(ops, "Tuple", "Tensor")
+    _multitype_ops_tuple_tensor_calcu(ops, func, func)
+
+
+def _multitype_ops_tensor_tuple_calcu(ops, func1, func2):
+    @ops.register("Tensor", "Tuple")
+    def _tensor_and_tuple(x, y):
+        if isinstance(x, adapter_Tensor):
+            x = convert_to_ms_tensor(x)
+            out = func1(x, y)
+            out = convert_output(out)
+        else:
+            out = func2(x, y)
+        return out
+
+
+def update_multitype_ops_tensor_tuple_with_fn(ops, func1):
+    func2 = get_registed_fn(ops, "Tensor", "Tuple")
+    _multitype_ops_tensor_tuple_calcu(ops, func1, func2)
+
+def update_multitype_ops_tensor_tuple(ops):
+    func = get_registed_fn(ops, "Tensor", "Tuple")
+    _multitype_ops_tensor_tuple_calcu(ops, func, func)
+
+
+def _multitype_ops_list_tensor_calcu(ops, func1, func2):
+    @ops.register("List", "Tensor")
+    def _list_and_tensor(x, y):
+        if isinstance(y, adapter_Tensor):
+            y = convert_to_ms_tensor(y)
+            out = func1(x, y)
+            out = convert_output(out)
+        else:
+            out = func2(x, y)
+        return out
+
+def update_multitype_ops_list_tensor_with_fn(ops, func1):
+    func2 = get_registed_fn(ops, "List", "Tensor")
+    _multitype_ops_list_tensor_calcu(ops, func1, func2)
+
+def update_multitype_ops_list_tensor(ops):
+    func = get_registed_fn(ops, "List", "Tensor")
+    _multitype_ops_list_tensor_calcu(ops, func, func)
+
+
+def _multitype_ops_tensor_list_calcu(ops, func1, func2):
+    @ops.register("Tensor", "List")
+    def _tensor_and_list(x, y):
+        if isinstance(x, adapter_Tensor):
+            x = convert_to_ms_tensor(x)
+            out = func1(x, y)
+            out = convert_output(out)
+        else:
+            out = func2(x, y)
+        return out
+
+def update_multitype_ops_tensor_list_with_fn(ops, func1):
+    func2 = get_registed_fn(ops, "Tensor", "List")
+    _multitype_ops_tensor_list_calcu(ops, func1, func2)
+
+def update_multitype_ops_tensor_list(ops):
+    func = get_registed_fn(ops, "Tensor", "List")
+    _multitype_ops_tensor_list_calcu(ops, func, func)
+
+
+def _multitype_ops_tensor_none_calcu(ops, func1, func2):
+    @ops.register("Tensor", "None")
+    def _tensor_and_none(x, y):
+        if isinstance(x, adapter_Tensor):
+            x = convert_to_ms_tensor(x)
+            out = func1(x, y)
+            out = convert_output(out)
+        else:
+            out = func2(x, y)
+        return out
+
+def update_multitype_ops_tensor_none_with_fn(ops, func1):
+    func2 = get_registed_fn(ops, "Tensor", "None")
+    _multitype_ops_tensor_none_calcu(ops, func1, func2)
+
+def update_multitype_ops_tensor_none(ops):
+    func = get_registed_fn(ops, "Tensor", "None")
+    _multitype_ops_tensor_none_calcu(ops, func, func)
+
+
+def _multitype_ops_tensor_slice_calcu(ops, func1, func2):
+    @ops.register("Tensor", "Slice")
+    def _tensor_and_slice(x, y):
+        if isinstance(x, adapter_Tensor):
+            x = convert_to_ms_tensor(x)
+            out = func1(x, y)
+            out = convert_output(out)
+        else:
+            out = func2(x, y)
+        return out
+
+def update_multitype_ops_tensor_slice_with_fn(ops, func1):
+    func2 = get_registed_fn(ops, "Tensor", "Slice")
+    _multitype_ops_tensor_slice_calcu(ops, func1, func2)
+
+def update_multitype_ops_tensor_slice(ops):
+    func = get_registed_fn(ops, "Tensor", "Slice")
+    _multitype_ops_tensor_slice_calcu(ops, func, func)
+
+def update_multitype_ops_setitem_tensor(ops):
+    def register_for_setitem(sigs, fn):
+        @ops.register(*sigs)
+        def _tensor_setitem(data, index, value):
+            if isinstance(data, adapter_Tensor):
+                data = convert_to_ms_tensor(data)
+                out = fn(data, index, value)
+                out = convert_to_adapter_tensor(out)
+            else:
+                out = fn(data, index, value)
+            return out
+
+    entries = ops.entries.copy()
+    for sigs, fn in entries:
+        if mstype._issubclass_(sigs[0], mstype.tensor):
+            register_for_setitem(sigs, fn)

msadapter/pytorch/_six.py

@@ -0,0 +1 @@
+string_classes = (str, bytes)