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

mindspore/_install_custom.py

@@ -1,43 +0,0 @@
-# Copyright 2023 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.
-# ============================================================================
-"""install custom op files"""
-
-import os
-import platform
-import importlib.util
-from mindspore import log as logger
-
-
-def _install_custom():
-    """install custom op files"""
-    if platform.system() != "Linux":
-        return
-    custom_op_path = os.environ.get("MS_DEV_CUSTOM_OPP_PATH")
-    if not custom_op_path:
-        return
-    if not os.path.isdir(custom_op_path):
-        logger.warning("The path set in env 'MS_DEV_CUSTOM_OPP_PATH' is not a directory: '{}'".format(custom_op_path))
-    else:
-        for file_name in os.listdir(custom_op_path):
-            file_path = os.path.join(custom_op_path, file_name)
-            if os.path.isfile(file_path) and file_name.endswith(".py") and file_name != "__init__.py":
-                logger.info("start import file: '{}'".format(file_path))
-                mod_spec = importlib.util.spec_from_file_location(os.path.splitext(file_name)[0], file_path)
-                mod = importlib.util.module_from_spec(mod_spec)
-                mod_spec.loader.exec_module(mod)
-    os.environ.pop("MS_DEV_CUSTOM_OPP_PATH")
-
-
-_install_custom()

mindspore/common/_register_for_adapter.py

@@ -1,74 +0,0 @@
-# Copyright 2022-2023 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.
-# ============================================================================
-
-"""Registry MSAdapter config."""
-
-
-class Registry:
-    """Registry class for ms adapter."""
-
-    def __init__(self):
-        self.is_registered = False
-        self._tensor = None
-        self._parameter = None
-        self._convert_map = {}
-        self.convert_adapter_tensor_map = {}
-
-    @property
-    def tensor(self):
-        """Return the registered tensor."""
-        if self._tensor is None:
-            raise ValueError("Before using Tensor in MSAdapter, please call 'set_adapter_config'.")
-        return self._tensor
-
-    @property
-    def parameter(self):
-        """Return the registered parrameter."""
-        if self._parameter is None:
-            raise ValueError("Before using Parameter in MSAdapter, please call 'set_adapter_config'.")
-        return self._parameter
-
-    @property
-    def convert_map(self):
-        """Return the registered convert map."""
-        return self._convert_map
-
-    def register_tensor(self, value):
-        """Register the tensor of ms adapter."""
-        if self._tensor is not None:
-            raise ValueError("Repeated registration of tensor in ms adapter config.")
-        self._tensor = value
-        self.is_registered = True
-
-    def register_parameter(self, value):
-        """Register the parameter of ms adapter."""
-        if self._parameter is not None:
-            raise ValueError("Repeated registration of Parameter in ms adapter config.")
-        self._parameter = value
-
-    def register_convert_map(self, value):
-        """Register the convert map of ms adapter."""
-        if not isinstance(value, dict):
-            raise ValueError(f"Expect a dict type, but got {type(value)}.")
-        self._convert_map = value
-
-    def register_convert_adapter_tensor_map(self, value):
-        """Register the convert map for adapter tensor."""
-        if not isinstance(value, dict):
-            raise ValueError(f"Expect a dict type, but got {type(value)}.")
-        self.convert_adapter_tensor_map = value
-
-
-ms_adapter_registry = Registry()

mindspore/ops/auto_generate/gen_arg_dtype_cast.py

@@ -1,252 +0,0 @@
-# This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
-#
-# Copyright 2023-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.
-# 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.
-# ============================================================================
-"""Operator argument data type cast function."""
-
-import mindspore as ms
-from mindspore import ops
-from mindspore.common.tensor import Tensor
-from mindspore.ops.operations._sequence_ops import TensorToScalar, TensorToTuple
-from mindspore.ops_generate.gen_ops_inner_prim import TupleToList, ListToTuple
-from mindspore._c_expression import OpDtype
-
-tensor_to_tuple_ = TensorToTuple()
-tuple_to_list = TupleToList()
-list_to_tuple = ListToTuple()
-
-
-def int_to_float(data):
-    return float(data)
-
-
-def scalar_to_tuple(data):
-    return (data,)
-
-
-def tensor_to_tuple(data):
-    # Since tuple is not supported for precision conversion during KernelSelect, the original int32 tensor input cases
-    # would be failed. Thus, the tuple precision is raised from int32 to int64 at frontend. But sequence data type cast
-    # must be adapted in future version.
-    if data.dtype == ms.int32:
-        data = ops.cast(data, ms.int64)
-    return tensor_to_tuple_(data)
-
-
-def scalar_to_tensor(data):
-    if isinstance(data, bool):
-        return ops.scalar_to_tensor(data, ms.bool_)
-    if isinstance(data, int):
-        return ops.scalar_to_tensor(data, ms.int32)
-    if isinstance(data, float):
-        return ops.scalar_to_tensor(data, ms.float32)
-    return ops.scalar_to_tensor(data)
-
-
-def tuple_to_tensor(data):
-    return ops.tuple_to_array(data)
-
-
-def list_to_tensor(data):
-    return ops.tuple_to_array(list_to_tuple(data))
-
-
-# There will be some problems in using OpDtype.xxx directly in GRAPH_MODE, so convert it to int.
-# type
-DT_TYPE_VAL = int(OpDtype.DT_TYPE)
-# scalar
-DT_INT_VAL = int(OpDtype.DT_INT)
-DT_FLOAT_VAL = int(OpDtype.DT_FLOAT)
-DT_BOOL_VAL = int(OpDtype.DT_BOOL)
-DT_NUMBER_VAL = int(OpDtype.DT_NUMBER)
-# tuple
-DT_TUPLE_BOOL_VAL = int(OpDtype.DT_TUPLE_BOOL)
-DT_TUPLE_INT_VAL = int(OpDtype.DT_TUPLE_INT)
-DT_TUPLE_FLOAT_VAL = int(OpDtype.DT_TUPLE_FLOAT)
-DT_TUPLE_NUMBER_VAL = int(OpDtype.DT_TUPLE_NUMBER)
-DT_TUPLE_TENSOR_VAL = int(OpDtype.DT_TUPLE_TENSOR)
-DT_TUPLE_STR_VAL = int(OpDtype.DT_TUPLE_STR)
-DT_TUPLE_ANY_VAL = int(OpDtype.DT_TUPLE_ANY)
-# list
-DT_LIST_BOOL_VAL = int(OpDtype.DT_LIST_BOOL)
-DT_LIST_INT_VAL = int(OpDtype.DT_LIST_INT)
-DT_LIST_FLOAT_VAL = int(OpDtype.DT_LIST_FLOAT)
-DT_LIST_NUMBER_VAL = int(OpDtype.DT_LIST_NUMBER)
-DT_LIST_TENSOR_VAL = int(OpDtype.DT_LIST_TENSOR)
-DT_LIST_STR_VAL = int(OpDtype.DT_LIST_STR)
-DT_LIST_ANY_VAL = int(OpDtype.DT_LIST_ANY)
-# tensor
-DT_TENSOR_VAL = int(OpDtype.DT_TENSOR)
-
-dtype_to_string = {
-    DT_INT_VAL: "int",
-    DT_FLOAT_VAL: "float",
-    DT_BOOL_VAL: "bool",
-    DT_NUMBER_VAL: "number",
-    DT_TENSOR_VAL: "Tensor",
-    DT_TUPLE_BOOL_VAL: "tuple of bool",
-    DT_TUPLE_INT_VAL: "tuple of int",
-    DT_TUPLE_FLOAT_VAL: "tuple of float",
-    DT_TUPLE_NUMBER_VAL: "tuple of number",
-    DT_TUPLE_TENSOR_VAL: "tuple of tensor",
-    DT_TUPLE_STR_VAL: "tuple of string",
-    DT_TUPLE_ANY_VAL: "tuple of Any",
-    DT_LIST_BOOL_VAL: "list of bool",
-    DT_LIST_INT_VAL: "list of int",
-    DT_LIST_FLOAT_VAL: "list of float",
-    DT_LIST_NUMBER_VAL: "list of number",
-    DT_LIST_TENSOR_VAL: "list of Tensor",
-    DT_LIST_STR_VAL: "list of string",
-    DT_LIST_ANY_VAL: "list of Any"
-}
-
-
-def is_tuple(type_id):
-    """
-    Check type id is tuple.
-    """
-    return type_id in (DT_TUPLE_BOOL_VAL, DT_TUPLE_INT_VAL, DT_TUPLE_FLOAT_VAL, DT_TUPLE_NUMBER_VAL,
-                       DT_TUPLE_TENSOR_VAL, DT_TUPLE_STR_VAL, DT_TUPLE_ANY_VAL)
-
-
-def is_list(type_id):
-    """
-    Check type id is list.
-    """
-    return type_id in (DT_LIST_BOOL_VAL, DT_LIST_INT_VAL, DT_LIST_FLOAT_VAL, DT_LIST_NUMBER_VAL,
-                       DT_LIST_TENSOR_VAL,
-                       DT_LIST_STR_VAL, DT_LIST_ANY_VAL)
-
-
-def is_number(type_id):
-    """
-    Check type id is number.
-    """
-    return type_id in (DT_INT_VAL, DT_FLOAT_VAL, DT_BOOL_VAL, DT_NUMBER_VAL)
-
-
-def is_instance_of(data, type_id):
-    """
-    Instead isinstance(obj, type).
-    """
-    if type_id == DT_INT_VAL:
-        return isinstance(data, int)
-    if type_id == DT_FLOAT_VAL:
-        return isinstance(data, float)
-    if type_id == DT_BOOL_VAL:
-        return isinstance(data, bool)
-    if is_number(type_id):
-        return isinstance(data, (int, float, bool))
-    if is_tuple(type_id):
-        return isinstance(data, tuple)
-    if is_list(type_id):
-        return isinstance(data, list)
-    if type_id == DT_TENSOR_VAL:
-        return isinstance(data, Tensor)
-    return False
-
-
-def is_instance_in(data, type_id):
-    """
-    Instead isinstance(obj, tuple_types).
-    """
-    if not isinstance(type_id, tuple):
-        return is_instance_of(data, type_id)
-    for type_id_i in type_id:
-        if is_instance_of(data, type_id_i):
-            return True
-    return False
-
-
-def get_support_dtype_list(src_type, dst_type):
-    """
-    Get support dtype list.
-    """
-    support_list = ""
-    if isinstance(src_type, tuple):
-        for dtype in src_type:
-            support_list += dtype_to_string.get(dtype) + ", "
-    else:
-        support_list += dtype_to_string.get(src_type) + ", "
-    support_list += dtype_to_string.get(dst_type)
-    return support_list
-
-
-def to_py_number(data, dst_type):
-    """Convert tensor to python number"""
-    if dst_type == DT_INT_VAL:
-        data = ops.cast(data, ms.int64)
-    elif dst_type == DT_FLOAT_VAL:
-        data = ops.cast(data, ms.float32)
-    elif dst_type == DT_NUMBER_VAL:
-        src_type = data.dtype
-        if src_type in (ms.uint8, ms.uint16, ms.uint32, ms.uint64,
-                        ms.int8, ms.int16, ms.int32, ms.int64):
-            data = ops.cast(data, ms.int64)
-        elif src_type in (ms.bfloat16, ms.float16, ms.float32, ms.float64):
-            data = ops.cast(data, ms.float32)
-    return TensorToScalar()(data)
-
-
-def do_type_cast(data, dst_type):
-    """Type conversion."""
-    if is_instance_of(data, dst_type):
-        return data
-    if dst_type == DT_FLOAT_VAL:
-        if isinstance(data, int):
-            return int_to_float(data)
-    elif is_tuple(dst_type):
-        if isinstance(data, (int, float, bool)):
-            return scalar_to_tuple(data)
-        if isinstance(data, list):
-            return list_to_tuple(data)
-        if isinstance(data, Tensor):
-            return tensor_to_tuple(data)
-    elif is_list(dst_type):
-        if isinstance(data, (int, float, bool)):
-            return tuple_to_list(scalar_to_tuple(data))
-        if isinstance(data, tuple):
-            return tuple_to_list(data)
-        if isinstance(data, Tensor):
-            return tuple_to_list(tensor_to_tuple(data))
-    elif dst_type == DT_TENSOR_VAL:
-        if isinstance(data, (int, float, bool)):
-            return scalar_to_tensor(data)
-        if isinstance(data, tuple):
-            return tuple_to_tensor(data)
-        if isinstance(data, list):
-            return list_to_tensor(data)
-    elif is_number(dst_type):
-        if isinstance(data, Tensor):
-            return to_py_number(data, dst_type)
-    raise TypeError("Type conversion failed.")
-
-
-def type_it(op_name, arg_name, data, src_type, dst_type):
-    """
-    cast operator argument data type.
-    """
-    if isinstance(data, type(None)):
-        return data
-    if not isinstance(src_type, tuple):
-        src_type = int(src_type)
-    else:
-        src_type = tuple((int(t) for t in src_type))
-    dst_type = int(dst_type)
-    if not is_instance_in(data, src_type) and not is_instance_of(data, dst_type):
-        support_list = get_support_dtype_list(src_type, dst_type)
-        raise TypeError(f"For '{op_name}', the type of '{arg_name}' should be one of '[{support_list}]', "
-                        f"but got {type(data)}.")
-    return do_type_cast(data, dst_type)

mindspore/ops/auto_generate/gen_arg_handler.py

@@ -1,136 +0,0 @@
-# Copyright 2023 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.
-# ============================================================================
-"""Operator argument handle function."""
-
-from mindspore.ops_generate.gen_ops_inner_prim import DtypeToEnum, StringToEnum
-# Enum Class:
-from mindspore._c_expression import FormatEnum as Format
-from mindspore._c_expression import ReductionEnum as Reduction
-from mindspore.common import Tensor
-from mindspore.common import dtype as mstype
-
-
-def arg_invalid_info(op_name, arg_name, arg_val):
-    """
-    generate invalid msg.
-    """
-    return f"For '{op_name}', the value of '{arg_name}' is invalid: '{arg_val}'."
-
-
-def to_pair(op_name, arg_name, arg_val):
-    """
-    convert arg_val: int/tuple[int*2] -> tuple[int*2].
-    """
-    if isinstance(arg_val, (int, float)):
-        return (arg_val, arg_val)
-    if isinstance(arg_val, (list, tuple)):
-        return arg_val
-    raise ValueError(arg_invalid_info(op_name, arg_name, arg_val))
-
-
-def to_kernel_size(op_name, arg_name, kernel_size):
-    """
-    convert kernel_size: int/tuple[int*4] -> tuple[int*2].
-    """
-    if isinstance(kernel_size, int):
-        return (kernel_size, kernel_size)
-    if isinstance(kernel_size, (tuple, list)):
-        if len(kernel_size) == 4:
-            return (kernel_size[2], kernel_size[3])
-        return kernel_size
-    raise ValueError(arg_invalid_info(op_name, arg_name, kernel_size))
-
-
-def to_strides(op_name, arg_name, stride):
-    """
-    convert strides: int/tuple[int*4] -> tuple[int*2].
-    """
-    if isinstance(stride, int):
-        return (stride, stride)
-    if isinstance(stride, (tuple, list)):
-        if len(stride) == 4:
-            return (stride[2], stride[3])
-        return stride
-    raise ValueError(arg_invalid_info(op_name, arg_name, stride))
-
-
-def to_rates(op_name, arg_name, rates):
-    """
-    convert rates: int/tuple[int*4] -> tuple[int*2].
-    """
-    if isinstance(rates, int):
-        return (rates, rates)
-    if isinstance(rates, (tuple, list)):
-        if len(rates) == 4:
-            return (rates[2], rates[3])
-        return rates
-    raise ValueError(arg_invalid_info(op_name, arg_name, rates))
-
-
-def to_dilations(op_name, arg_name, dilation):
-    """
-    convert dilations: int/tuple[int*4] -> tuple[int*2].
-    """
-    if isinstance(dilation, int):
-        return (dilation, dilation)
-    if isinstance(dilation, (tuple, list)):
-        if len(dilation) == 4:
-            return (dilation[2], dilation[3])
-        return dilation
-    raise ValueError(arg_invalid_info(op_name, arg_name, dilation))
-
-
-def to_output_padding(op_name, arg_name, output_padding):
-    """
-    convert output_padding: int/tuple[int*4] -> tuple[int*2].
-    """
-    if isinstance(output_padding, int):
-        return (output_padding, output_padding)
-    if isinstance(output_padding, (tuple, list)):
-        if len(output_padding) == 4:
-            return (output_padding[2], output_padding[3])
-        return output_padding
-    raise ValueError(arg_invalid_info(op_name, arg_name, output_padding))
-
-
-def to_2d_paddings(op_name, arg_name, pad):
-    """
-    convert paddings: int -> tuple[int*2].
-    """
-    if isinstance(pad, int):
-        return (pad,) * 2
-    if isinstance(pad, (tuple, list)):
-        return pad
-    raise ValueError(arg_invalid_info(op_name, arg_name, pad))
-
-
-def generator_handler(op_name, arg_name, inputs):
-    """
-    convert constant value in tuple to tensor
-    """
-    new_inputs = []
-    for input_ in inputs:
-        if isinstance(input_, int):
-            new_inputs.append(Tensor(input_, mstype.int64))
-        else:
-            new_inputs.append(input_)
-    return tuple(new_inputs)
-
-dtype_to_type_id = DtypeToEnum()
-
-# string to enum
-# A function for converting str type to enum type are written here,
-# but the backend supports str input, and converting str input to enum input is not necessary.
-str_to_enum = StringToEnum()

mindspore/ops/operations/_opaque_predicate_registry.py

@@ -1,41 +0,0 @@
-# Copyright 2022 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.
-# ============================================================================
-
-"""Register pyfunc for opaque_func_cpu_kernel"""
-
-from mindspore.ops._register_for_op import OpaquePredicateRegistry
-
-
-registered_func_name = OpaquePredicateRegistry()
-
-
-def add_opaque_predicate(fn_name, func):
-    """restore opaque predicate functions"""
-    registered_func_name.register(fn_name, func)
-
-
-def get_opaque_predicate(fn_name):
-    """get opaque predicate function by their name"""
-    return registered_func_name.get(fn_name)
-
-
-def get_func_names():
-    """get function names"""
-    return registered_func_name.func_names
-
-
-def clean_funcs():
-    """clean restored functions"""
-    registered_func_name.func_names = []