mindspore 2.3.0__cp310-cp310-win_amd64.whl

mindspore/boost/less_batch_normalization.py

@@ -0,0 +1,174 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""less Batch Normalization"""
+from __future__ import absolute_import
+
+import numpy as np
+from mindspore.nn.cell import Cell
+from mindspore.nn.layer import Dense
+from mindspore.ops import operations as P
+from mindspore.common import Tensor, Parameter
+from mindspore.common import dtype as mstype
+from mindspore.common.initializer import initializer
+
+
+__all__ = ["CommonHeadLastFN", "LessBN"]
+
+
+class CommonHeadLastFN(Cell):
+    r"""
+    The last full Normalization layer.
+
+    This layer implements the operation as:
+
+    .. math::
+        \text{inputs} = \text{norm}(\text{inputs})
+        \text{kernel} = \text{norm}(\text{kernel})
+        \text{outputs} = \text{multiplier} * (\text{inputs} * \text{kernel} + \text{bias}),
+
+    Args:
+        in_channels (int): The number of channels in the input space.
+        out_channels (int): The number of channels in the output space.
+        weight_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable weight_init parameter. The dtype
+            is same as input x. The values of str refer to the function `initializer`. Default: 'normal'.
+        bias_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable bias_init parameter. The dtype is
+            same as input x. The values of str refer to the function `initializer`. Default: 'zeros'.
+        has_bias (bool): Specifies whether the layer uses a bias vector. Default: ``True``.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> input = Tensor(np.array([[180, 234, 154], [244, 48, 247]]), mindspore.float32)
+        >>> net = CommonHeadLastFN(3, 4)
+        >>> output = net(input)
+    """
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 weight_init='normal',
+                 bias_init='zeros',
+                 has_bias=True):
+        super(CommonHeadLastFN, self).__init__()
+        weight_shape = [out_channels, in_channels]
+        self.weight = Parameter(initializer(weight_init, weight_shape), requires_grad=True, name='weight')
+        self.x_norm = P.L2Normalize(axis=1)
+        self.w_norm = P.L2Normalize(axis=1)
+        self.fc = P.MatMul(transpose_a=False, transpose_b=True)
+        self.multiplier = Parameter(Tensor(np.ones([1]), mstype.float32), requires_grad=True, name='multiplier')
+        self.has_bias = has_bias
+        if self.has_bias:
+            bias_shape = [out_channels]
+            self.bias_add = P.BiasAdd()
+            self.bias = Parameter(initializer(bias_init, bias_shape), requires_grad=True, name='bias')
+
+    def construct(self, x):
+        x = self.x_norm(x)
+        w = self.w_norm(self.weight)
+        x = self.fc(x, w)
+        if self.has_bias:
+            x = self.bias_add(x, self.bias)
+        x = self.multiplier * x
+        return x
+
+
+class LessBN(Cell):
+    """
+    Reduce the number of BN automatically to improve the network performance
+    and ensure the network accuracy.
+
+    Args:
+        network (Cell): Network to be modified.
+        fn_flag (bool): Replace FC with FN. Default: ``False`` .
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, Parameter, nn
+        >>> from mindspore import ops
+        >>> from mindspore.nn import WithLossCell
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import boost
+        >>>
+        >>> class Net(nn.Cell):
+        ...    def __init__(self, in_features, out_features):
+        ...        super(Net, self).__init__()
+        ...        self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
+        ...                                name='weight')
+        ...        self.matmul = ops.MatMul()
+        ...
+        ...    def construct(self, x):
+        ...        output = self.matmul(x, self.weight)
+        ...        return output
+        >>> size, in_features, out_features = 16, 16, 10
+        >>> net = Net(in_features, out_features)
+        >>> loss = nn.MSELoss()
+        >>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
+        >>> net_with_loss = WithLossCell(net, loss)
+        >>> inputs = Tensor(np.ones([size, in_features]).astype(np.float32))
+        >>> label = Tensor(np.zeros([size, out_features]).astype(np.float32))
+        >>> train_network = boost.LessBN(net_with_loss)
+        >>> output = train_network(inputs, label)
+    """
+
+    def __init__(self, network, fn_flag=False):
+        super(LessBN, self).__init__()
+        self.network = network
+        if "less_bn" not in self.network.get_flags():
+            self.network.set_boost("less_bn")
+            self.network.update_cell_prefix()
+            if fn_flag:
+                self._convert_to_less_bn_net(self.network)
+            # Please use this interface with caution as it may cause uncontrollable problem.
+            # The purpose here is to prevent the "less_bn" flag from disappearing.
+            self.network.add_flags(defer_inline=True)
+
+    @staticmethod
+    def _convert_dense(subcell):
+        """
+        convert dense cell to FN cell
+        """
+        prefix = subcell.param_prefix
+        new_subcell = CommonHeadLastFN(subcell.in_channels,
+                                       subcell.out_channels,
+                                       subcell.weight,
+                                       subcell.bias,
+                                       False)
+        new_subcell.update_parameters_name(prefix + '.')
+
+        return new_subcell
+
+    def construct(self, *inputs):
+        return self.network(*inputs)
+
+    def _convert_to_less_bn_net(self, net):
+        """
+        convert network to less_bn network
+        """
+        cells = net.name_cells()
+        dense_name = []
+        dense_list = []
+        for name in cells:
+            subcell = cells[name]
+            if subcell == net:
+                continue
+            if isinstance(subcell, (Dense)):
+                dense_name.append(name)
+                dense_list.append(subcell)
+            else:
+                self._convert_to_less_bn_net(subcell)
+
+        if dense_list:
+            new_subcell = LessBN._convert_dense(dense_list[-1])
+            net.insert_child_to_cell(dense_name[-1], new_subcell)

mindspore/common/__init__.py

@@ -0,0 +1,84 @@
+# Copyright 2020-2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Top-level reference to dtype of common module."""
+from __future__ import absolute_import
+from mindspore.common import dtype
+from mindspore.common.api import ms_function, ms_memory_recycle, ms_class, jit, jit_class, _no_grad, flops_collection
+from mindspore.common.dtype import Type, int8, byte, int16, short, int32, intc, int64, intp, \
+    uint8, ubyte, uint16, ushort, uint32, uintc, uint64, uintp, float16, half, \
+    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
+from mindspore.common.dump import set_dump
+from mindspore.common.parameter import Parameter, ParameterTuple
+from mindspore.common.seed import set_seed, get_seed
+from mindspore.common.tensor import Tensor, tensor
+from mindspore.common.sparse_tensor import RowTensor, RowTensorInner, SparseTensor, COOTensor, CSRTensor
+from mindspore.common.mutable import mutable
+from mindspore.common.jit_config import JitConfig
+from mindspore.common.lazy_inline import lazy_inline
+from mindspore.common.no_inline import no_inline
+from mindspore.common.mindir_util import load_mindir, save_mindir
+from mindspore.common.symbol import Symbol
+from mindspore.common.recompute import recompute
+from mindspore.common import generator
+from mindspore.common.generator import (
+    Generator, default_generator, seed, manual_seed, initial_seed, get_rng_state, set_rng_state)
+
+# symbols from dtype
+__all__ = [
+    "int8", "byte",
+    "int16", "short",
+    "int32", "intc",
+    "int64", "intp",
+    "uint8", "ubyte",
+    "uint16", "ushort",
+    "uint32", "uintc",
+    "uint64", "uintp",
+    "float16", "half",
+    "float32", "single",
+    "float64", "double",
+    "bool_", "float_",
+    "list_", "tuple_",
+    "int_", "uint",
+    "number", "tensor_type",
+    "string", "type_none",
+    "_null",
+    "TensorType", "QuantDtype",
+    "Type", "Int", "_NullType",
+    "complex64", "complex128",
+    # __method__ from dtype
+    "dtype_to_nptype", "dtype_to_pytype",
+    "pytype_to_dtype", "get_py_obj_dtype",
+    "bfloat16", "qint4x2"
+]
+
+__all__.extend([
+    "tensor", "Tensor", "RowTensor", "SparseTensor", "COOTensor", "CSRTensor", # tensor
+    "ms_function", "ms_class", 'jit', 'jit_class', '_no_grad',  # api
+    "Parameter", "ParameterTuple",  # parameter
+    "dtype",
+    "set_seed", "get_seed",  # random seed
+    "set_dump",
+    "ms_memory_recycle",
+    "mutable", "JitConfig",
+    "flops_collection",
+    "lazy_inline", "load_mindir", "save_mindir",
+    "no_inline",
+    "Symbol",
+    "recompute"
+])
+__all__.extend(generator.__all__)

mindspore/common/_auto_dynamic.py

@@ -0,0 +1,68 @@
+# This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
+#
+# 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.
+# ============================================================================
+"""convert inputs to dynamic shape automatically at the first round. Method in this file is only used for test."""
+import os
+from mindspore.common.parameter import Parameter
+from mindspore.common.tensor import Tensor
+
+
+def is_auto_dynamic_shape():
+    """this is used only for test"""
+    return os.getenv("MS_DEV_AUTO_DYNAMIC_SHAPE") == "on"
+
+
+def is_auto_dynamic_rank():
+    """this is used only for test"""
+    return os.getenv("MS_DEV_AUTO_DYNAMIC_RANK") == "on"
+
+
+def is_auto_dynamic():
+    """this is used only for test"""
+    return is_auto_dynamic_shape() or is_auto_dynamic_rank()
+
+
+def convert_inputs_to_dynamic(*inputs):
+    """this is used only for test"""
+    dyn_inputs = list(inputs)
+    if not dyn_inputs:
+        return None
+    for idx, net_input in enumerate(inputs):
+        if isinstance(net_input, Tensor) and not isinstance(net_input, Parameter):
+            shp = net_input.shape
+            if not shp:
+                dyn_inputs[idx] = net_input
+                continue
+            if is_auto_dynamic_rank():
+                dyn_tensor = Tensor(shape=None, dtype=net_input.dtype)
+            else:
+                dyn_shape = [None for _ in net_input.shape]
+                dyn_tensor = Tensor(shape=dyn_shape, dtype=net_input.dtype)
+            dyn_inputs[idx] = dyn_tensor
+
+    return tuple(dyn_inputs)
+
+
+def convert_new_shapes(dataset_shapes):
+    """this is used only for test"""
+    new_shapes = []
+    for shape in dataset_shapes:
+        if is_auto_dynamic_rank():
+            new_shape = [-2]
+        else:
+            new_shape = [-1 for _ in shape]
+        new_shapes.append(new_shape)
+    return new_shapes

mindspore/common/_decorator.py

@@ -0,0 +1,50 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Providing decorators."""
+
+from __future__ import absolute_import
+from functools import wraps
+from mindspore import log
+
+
+DEPRECATE_SET = set()
+
+
+def deprecated(version, substitute, use_substitute_name=False):
+    """deprecated warning
+
+    Args:
+        version (str): version that the operator or function is deprecated.
+        substitute (str): the substitute name for deprecated operator or function.
+        use_substitute_name (bool): flag for whether to use substitute name for deprecated operator or function
+    """
+
+    def decorate(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            cls = getattr(args[0], "__class__", None) if args else None
+            name = cls.__name__ if cls else func.__name__
+            if name + version not in DEPRECATE_SET:
+                log.warning(f"'{name}' is deprecated from version {version} and "
+                            f"will be removed in a future version, use '{substitute}' instead.")
+                DEPRECATE_SET.add(name + version)
+            if cls and use_substitute_name:
+                cls.substitute_name = substitute
+            ret = func(*args, **kwargs)
+            return ret
+
+        return wrapper
+
+    return decorate

mindspore/common/_jit_fallback_utils.py

@@ -0,0 +1,110 @@
+# This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
+#
+# 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.
+# ============================================================================
+"""common _jit_fallback_utils."""
+
+_local_value_nodes = {}
+
+
+def generate_list(key_name, list_value):
+    "Generate list object."
+    list_obj = get_local_variable(key_name)
+    # Need to clear current object, in case the same make_list is called multiple times.
+    list_obj.clear()
+    list_obj.extend(list_value)
+    return list_obj
+
+
+def get_local_variable(name):
+    """Get the local variable according name."""
+    return _local_value_nodes.get(name)
+
+
+def set_local_variable(name, value):
+    """Set the local variable with name and value."""
+    _local_value_nodes[name] = value
+
+
+def dict_setitem(dic, key, val):
+    """Set an element to dict."""
+    dic.__setitem__(key, val)
+    return dic
+
+
+def list_inplace_append(list_obj, target_obj):
+    """Inplace append target_obj to list_obj for jit fallback."""
+    # When input list is empty list, it will be converted to tuple.
+    # This will be removed after empty list problem is solved.
+    if isinstance(list_obj, tuple) and not list_obj == 0:
+        list_obj = []
+    list_obj.append(target_obj)
+    return list_obj
+
+
+def list_inplace_extend(list_obj, target_obj):
+    """Inplace extend target_obj to list_obj for jit fallback."""
+    # When input list is empty list, it will be converted to tuple.
+    # This will be removed after empty list problem is solved.
+    if isinstance(list_obj, tuple) and not list_obj == 0:
+        list_obj = []
+    list_obj.extend(target_obj)
+    return list_obj
+
+
+def list_inplace_insert(list_obj, index, target_obj):
+    """Inplace insert target_obj to list_obj at position index for jit fallback."""
+    # When input list is empty list, it will be converted to tuple.
+    # This will be removed after empty list problem is solved.
+    if isinstance(list_obj, tuple) and not list_obj == 0:
+        list_obj = []
+    list_obj.insert(index, target_obj)
+    return list_obj
+
+
+def list_inplace_pop(list_obj, index):
+    """Inplace pop list_obj element at position index for jit fallback."""
+    # When input list is empty list, it will be converted to tuple.
+    # This will be removed after empty list problem is solved.
+    if isinstance(list_obj, tuple) and not list_obj == 0:
+        list_obj = []
+    ret = list_obj.pop(index)
+    return list_obj, ret
+
+
+def list_inplace_reverse(list_obj):
+    """Inplace reverse list_obj for jit fallback."""
+    # When input list is empty list, it will be converted to tuple.
+    # This will be removed after empty list problem is solved.
+    if isinstance(list_obj, tuple) and not list_obj == 0:
+        list_obj = []
+    list_obj.reverse()
+    return list_obj
+
+
+def list_inplace_clear(list_obj):
+    """Inplace clear list_obj for jit fallback."""
+    # When input list is empty list, it will be converted to tuple.
+    # This will be removed after empty list problem is solved.
+    if isinstance(list_obj, tuple) and not list_obj == 0:
+        list_obj = []
+    list_obj.clear()
+    return list_obj
+
+
+def dict_inplace_setitem(dict_obj, key, target):
+    """Inplace dictionary setitem operation for dict_obj."""
+    dict_obj[key] = target
+    return dict_obj

mindspore/common/_monad.py

@@ -0,0 +1,25 @@
+# Copyright 2020-2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Define Monad default value."""
+from __future__ import absolute_import
+from mindspore._c_expression import IOMonad, UMonad
+
+# Universe monad default value.
+U = UMonad()
+
+# IO monad default value.
+IO = IOMonad()
+
+__all__ = ['U', 'IO']

mindspore/common/_register_for_adapter.py

@@ -0,0 +1,74 @@
+# 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/common/_register_for_recompute.py

@@ -0,0 +1,48 @@
+# Copyright 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.
+# ============================================================================
+
+"""Registry the relation."""
+
+from __future__ import absolute_import
+from types import FunctionType
+
+
+class RecomputeRegistry:
+    """Registry class for register recompute generator."""
+
+    def __init__(self):
+        self.recompute_generator = None
+
+    def register(self, fn):
+        """
+        Register recompute generator function
+        :param fn:
+        :return:
+        """
+        if not isinstance(fn, FunctionType):
+            raise TypeError("Fn should be function type, but got", type(fn))
+        self.recompute_generator = fn
+
+    def get(self):
+        """
+        Get recompute generator.
+        :return:
+        """
+        if self.recompute_generator is None:
+            raise TypeError("Recompute generator should be initialised before get()!")
+        return self.recompute_generator
+
+
+recompute_registry = RecomputeRegistry()