mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/_extends/parse/trope.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2020-2022 Huawei Technologies Co., Ltd
+# Copyright 2020-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.
@@ -37,11 +37,6 @@ from functools import (  # noqa
     partial
 )
 
-# support numpy symbol
-from numpy import (  # noqa
-    exp, log, sin, cos, tan
-)
-
 from ...common import mutable
 
 __all__ = ['add', 'sub', 'mul', 'truediv', 'floordiv', 'mod', 'eq', 'ne', 'lt', 'gt', 'le', 'ge', 'pos', 'neg',
@@ -49,7 +44,7 @@ __all__ = ['add', 'sub', 'mul', 'truediv', 'floordiv', 'mod', 'eq', 'ne', 'lt',
            'matmul', 'getitem', 'setitem',
            'bool', 'getattr', 'setattr', 'hasattr', 'len', 'iter', 'next', 'pow', 'range', 'map', 'zip',
            'partial', 'print', 'enumerate', 'isinstance', 'filter', 'abs', 'round', 'mutable',
-           'exp', 'log', 'sin', 'cos', 'tan', 'max', 'min', 'sum', 'list', 'tuple']
+           'max', 'min', 'sum', 'list', 'tuple']
 
 
 def MakeTuple(*elts):  # pragma: no cover
@@ -97,11 +92,6 @@ def not_contains(x):  # pragma: no cover
     raise RuntimeError('This operation is not meant to be called directly.')
 
 
-def while_cond(x):  # pragma: no cover
-    """Not in function."""
-    raise RuntimeError('This operation is not meant to be called directly.')
-
-
 def bool_(x):  # pragma: no cover
     """judge true function."""
     raise RuntimeError('This operation is not meant to be called directly.')

mindspore/_extends/remote/kernel_build_server.py

@@ -15,7 +15,7 @@
 """kernel build server"""
 import os
 from mindspore import log as logger
-from mindspore._extends.parallel_compile.akg_compiler.akg_process import create_akg_parallel_process
+from mindspore._extends.parallel_compile.akg_compiler.akg_process import create_akg_parallel_process, create_akg_v2_parallel_process
 
 
 class Messager:
@@ -124,8 +124,8 @@ class Messager:
         raise NotImplementedError
 
 
-class AkgBuilder():
-    """Akg building wrapper"""
+class AkgBuilderBase():
+    """Base Class for kernel compiler building wrapper"""
 
     def __init__(self, platform):
         self.platform = platform
@@ -133,8 +133,9 @@ class AkgBuilder():
         self.akg_processor = None
 
     def create(self, process_num, waitime):
-        """ Create akg processor"""
-        self.akg_processor = create_akg_parallel_process(process_num, waitime, self.platform)
+        """ Create compiler processor"""
+        del process_num, waitime
+        raise NotImplementedError
 
     def accept_json(self, json):
         """ Accept json"""
@@ -145,7 +146,7 @@ class AkgBuilder():
         return self.akg_processor.compile(self.attrs)
 
     def handle(self, messager, arg):
-        """Handle message about akg"""
+        """Handle message about compiler"""
         if arg == 'AKG/START':
             messager.send_ack()
             process_num_str = messager.get_message()
@@ -172,7 +173,23 @@ class AkgBuilder():
                     messager.send_ack(False)
                     break
         else:
-            raise RuntimeError("Unknown message type: %s" % arg)
+            raise RuntimeError(f"Unknown message type: {arg}")
+
+
+class AkgBuilder(AkgBuilderBase):
+    """Akg building wrapper"""
+
+    def create(self, process_num, waitime):
+        """ Create akg processor"""
+        self.akg_processor = create_akg_parallel_process(process_num, waitime, self.platform)
+
+
+class AkgV2Builder(AkgBuilderBase):
+    """Akg V2 building wrapper"""
+
+    def create(self, process_num, waitime):
+        """ Create akg v2 processor"""
+        self.akg_processor = create_akg_v2_parallel_process(process_num, waitime, self.platform)
 
 
 def get_logger():

mindspore/_extends/remote/kernel_build_server_akg_v2.py

@@ -0,0 +1,55 @@
+# 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.
+# ============================================================================
+"""kernel build server for akg v2 kernels"""
+import sys
+import warnings
+from mindspore._extends.remote.kernel_build_server import Messager, get_logger, AkgV2Builder
+
+
+class AkgV2Messager(Messager):
+    '''
+    Default Messager for akg v2 kernels.
+    It works as a server, communicating with c++ client.
+    '''
+
+    def __init__(self, fdin, fdout):
+        super().__init__(fdin, fdout)
+        get_logger().info("[TRACE] AKG V2 Messager init...")
+        self.akg_v2_builder = AkgV2Builder("default")
+
+    def handle(self):
+        """
+        Communicate with remote client.
+        Reference protocol between them at PR#4063
+        """
+        arg = self.get_message()
+        if "AKG" in arg:
+            self.akg_v2_builder.handle(self, arg)
+        else:
+            self.send_ack(False)
+            self.exit()
+
+    def exit(self):
+        get_logger().info("[TRACE] AKG V2 Messager Exit...")
+        exit()
+
+
+if __name__ == '__main__':
+    warnings.simplefilter("ignore")
+    if len(sys.argv) != 3:
+        raise Exception(f"Incorrect argv: {sys.argv}")
+    get_logger().debug(f"[TRACE] argv: {str(sys.argv)}")
+    messager = AkgV2Messager(int(sys.argv[1]), int(sys.argv[2]))
+    messager.run()

mindspore/_install_custom.py

@@ -0,0 +1,43 @@
+# 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/amp.py

@@ -15,11 +15,13 @@
 """ms function for mixed precision."""
 from __future__ import absolute_import
 
+import os
 from abc import ABC, abstractmethod
 from mindspore.common import mutable
 from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore.ops.operations.math_ops import NPUGetFloatStatusV2, NPUClearFloatStatusV2
 from mindspore import _checkparam as validator
+from mindspore._c_expression import MSContext
 from .common import dtype as mstype
 from . import context
 from . import ops
@@ -37,8 +39,13 @@ _partial = ops.Partial()
 
 
 @constexpr
-def _ascend_target():
-    return context.get_context("device_target") == "Ascend"
+def _ascend_910A_target():
+    return MSContext.get_instance().get_ascend_soc_version() == "ascend910"
+
+
+@constexpr
+def _ascend_910B_target():
+    return MSContext.get_instance().get_ascend_soc_version() == "ascend910b"
 
 
 @constexpr
@@ -71,6 +78,26 @@ def _overflow(inputs):
     return 1 - status.all()
 
 
+@jit
+def _all_finite(inputs, check_overflow_mode):
+    """all finite check"""
+    if (_ascend_910A_target()) or \
+       (_ascend_910B_target() and check_overflow_mode != "INFNAN_MODE"):
+        status = Tensor([0] * 8, mstype.int32)
+        status = ops.depend(status, inputs)
+        get_status = _get_cache_prim(NPUGetFloatStatusV2)()(status)
+        status = ops.depend(status, get_status)
+        clear_status = _get_cache_prim(NPUClearFloatStatusV2)()(status)
+        get_status = ops.depend(get_status, clear_status)
+        status_finite = get_status.equal(Tensor(0, mstype.int32)).all()
+        return status_finite
+
+    outputs = _hypermap(_partial(_overflow), inputs)
+    flag_sum = ops.addn(outputs).reshape(())
+    status_finite = ops.less(flag_sum, 1)
+    return status_finite
+
+
 def all_finite(inputs):
     r"""
     Returns a scalar Tensor indicating whether the inputs are finite.
@@ -92,22 +119,18 @@ def all_finite(inputs):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> x = (Tensor(np.array([np.log(-1), 1, np.log(0)])), Tensor(np.array([1.0]))
+        >>> from mindspore import amp, Tensor
+        >>> import numpy as np
+        >>> 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/r2.2/advanced/mixed_precision.html#loss-scaling>`_
     """
-    if _ascend_target():
-        status = Tensor([0] * 8, mstype.int32)
-        status = ops.depend(status, inputs)
-        get_status = _get_cache_prim(NPUGetFloatStatusV2)()(status)
-        status = ops.depend(status, get_status)
-        clear_status = _get_cache_prim(NPUClearFloatStatusV2)()(status)
-        get_status = ops.depend(get_status, clear_status)
-        status_finite = get_status.equal(Tensor(0, mstype.int32)).all()
-        return status_finite
-    outputs = _hypermap(_partial(_overflow), inputs)
-    flag_sum = ops.addn(outputs).reshape(())
-    _all_finite = ops.less(flag_sum, 1)
-    return _all_finite
+    inputs = mutable(inputs)
+    _check_overflow_mode = os.environ.get('MS_ASCEND_CHECK_OVERFLOW_MODE')
+    return _all_finite(inputs, _check_overflow_mode)
 
 
 @jit_class
@@ -119,11 +142,36 @@ 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/r2.0/advanced/
+    For more information, refer to the `tutorials  <https://mindspore.cn/tutorials/en/r2.2/advanced/
     mixed_precision.html#loss-scaling>`_.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
+
+    Examples:
+        >>> from mindspore.amp import LossScaler, _grad_scale_map, _grad_unscale_map
+        >>> from mindspore import ops, Parameter, Tensor
+        >>> from mindspore.common import dtype as mstype
+        >>>
+        >>> class MyLossScaler(LossScaler):
+        ...     def __init__(self, scale_value):
+        ...         self.scale_value = Parameter(Tensor(scale_value, dtype=mstype.float32), name="scale_value")
+        ...
+        ...     def scale(self, inputs):
+        ...         inputs = mutable(inputs)
+        ...         return _grad_scale_map(self.scale_value, inputs)
+        ...
+        ...     def unscale(self, inputs):
+        ...         inputs = mutable(inputs)
+        ...         return _grad_unscale_map(self.scale_value, inputs)
+        ...
+        ...     def adjust(self, grads_finite):
+        ...         scale_mul_factor = self.scale_value * self.scale_factor
+        ...         scale_value = ops.select(grads_finite, scale_mul_factor, self.scale_value)
+        ...         ops.assign(self.scale_value, scale_value)
+        ...         return True
+        >>>
+        >>> loss_scaler = MyLossScaler(1024)
     """
     @abstractmethod
     def scale(self, inputs):
@@ -172,6 +220,9 @@ class StaticLossScaler(LossScaler):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import amp, Tensor
+        >>> import numpy as np
         >>> loss_scaler = amp.StaticLossScaler(scale_value=2**10)
         >>> loss_value = Tensor([1.], mindspore.float32)
         >>> scaled_loss_value = loss_scaler.scale(loss_value)
@@ -218,7 +269,8 @@ class StaticLossScaler(LossScaler):
 
     def adjust(self, grads_finite):
         """
-        `scale_value` is fixed.
+        Adjust `scale_value` in `LossScaler`. `scale_value` is fixed in `StaticLossScaler`, so this method
+        return False directly.
 
         Args:
             grads_finite (Tensor): a scalar bool Tensor indicating whether the grads are finite.
@@ -248,6 +300,9 @@ class DynamicLossScaler(LossScaler):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import amp, Tensor
+        >>> import numpy as np
         >>> loss_scaler = amp.DynamicLossScaler(scale_value=2**10, scale_factor=2, scale_window=1)
         >>> grads = (Tensor(np.array([np.log(-1), 1.0]), mindspore.float16),
         ...             Tensor(np.array([0.2]), mindspore.float16))
@@ -276,6 +331,10 @@ class DynamicLossScaler(LossScaler):
 
         Returns:
             Union(Tensor, tuple(Tensor)), the scaled value.
+
+        Tutorial Examples:
+            - `Automatic Mix Precision - Loss Scaling
+              <https://mindspore.cn/tutorials/en/r2.2/advanced/mixed_precision.html#loss-scaling>`_
         """
         inputs = mutable(inputs)
         return _grad_scale_map(self.scale_value, inputs)
@@ -289,17 +348,24 @@ class DynamicLossScaler(LossScaler):
 
         Returns:
             Union(Tensor, tuple(Tensor)), the unscaled value.
+
+        Tutorial Examples:
+            - `Automatic Mix Precision - Loss Scaling
+              <https://mindspore.cn/tutorials/en/r2.2/advanced/mixed_precision.html#loss-scaling>`_
         """
         inputs = mutable(inputs)
         return _grad_unscale_map(self.scale_value, inputs)
 
-    @jit
     def adjust(self, grads_finite):
         """
         Adjust the `scale_value` dependent on whether grads are finite.
 
         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/r2.2/advanced/mixed_precision.html#loss-scaling>`_
         """
         one = ops.ones((), self.scale_value.dtype)
         scale_mul_factor = self.scale_value * self.scale_factor

mindspore/boost/base.py

@@ -285,7 +285,7 @@ class ParameterProcess:
 
         Args:
             parameters (list): The network's parameter list.
-            split_point (list): The gradient split point of this network. default: None.
+            split_point (list): The gradient split point of this network. Default: ``None``.
         """
         if not isinstance(parameters, (list, tuple)) or not parameters:
             return parameters
@@ -308,7 +308,7 @@ def _get_local_pca_mat_path(weight_load_dir, pca_mat_path, n_component, device_n
 
     Args:
         weight_load_dir (str): The weight(ckpt) file directory to be load.
-        pca_mat_path (str): the path to load pca mat. Default: None.
+        pca_mat_path (str): the path to load pca mat. Default: ``None``.
         n_component (int): pca component.
         device_number (int): device number.
         network (Cell): The network.

mindspore/boost/boost.py

@@ -56,7 +56,7 @@ class AutoBoost:
     Provide auto accelerating for network.
 
     Args:
-        level (str): Boost config level. Default: "O0".
+        level (str): Boost config level. Default: ``"O0"`` .
         boost_config_dict (dict): User config hyperparameter dict, recommended config format:
 
             .. code-block::
@@ -85,9 +85,6 @@ class AutoBoost:
                         "freeze_p": 0.7,
                         "total_steps": 65536
                     }
-                    "grad_accumulation": {
-                        "grad_accumulation_step": 1
-                    },
                     "dim_reduce": {
                         "rho": 0.55,
                         "gamma": 0.9,
@@ -100,46 +97,44 @@ class AutoBoost:
                     }
                 }
 
+            Default: ``""`` .
+
             - boost:
 
               - mode (str): How to set the boost. Supports ["auto", "manual", "enable_all", "disable_all"].
-                Default: "auto".
+                Default: ``"auto"`` .
 
                 - auto: Depend on the argument "boost_level" in class Model.
                 - manual: Depend on "boost_config_dict".
                 - enable_all: Set all boost functions true.
                 - disable_all: Set all boost functions false.
 
-              - less_bn (bool): Whether to apply less_bn function. Default: False.
-              - grad_freeze: (bool): Whether to apply grad_freeze function. Default: False.
-              - adasum (bool): Whether to apply adasum function. Default: False.
-              - grad_accumulation (bool): Whether to apply grad_accumulation function. Default: False.
-              - dim_reduce (bool): Whether to apply dim_reduce function. Default: False.
-              - loss_scale_group (bool): Whether to apply loss_scale_group function. Default: False.
+              - less_bn (bool): Whether to apply less_bn function. Default: ``False`` .
+              - grad_freeze: (bool): Whether to apply grad_freeze function. Default: ``False`` .
+              - adasum (bool): Whether to apply adasum function. Default: ``False`` .
+              - grad_accumulation (bool): Whether to apply grad_accumulation function. Default: ``False`` .
+              - dim_reduce (bool): Whether to apply dim_reduce function. Default: ``False`` .
+              - loss_scale_group (bool): Whether to apply loss_scale_group function. Default: ``False`` .
 
               If set dim_reduce true, other functions will be false.
               If set grad_freeze true and dim_reduce false, other functions will be false.
 
             - common:
 
-              - gradient_split_groups (list): The gradient split point of this network. Default: [50, 100].
-              - device_number (int): Device number. Default: 8.
+              - gradient_split_groups (list): The gradient split point of this network. Default: ``[50, 100]`` .
+              - device_number (int): Device number. Default: ``8`` .
 
             - less_bn:
 
-              - fn_flag (bool): Whether changing fc to fn. Default: True.
-              - gc_flag (bool): Whether to apply gc. Default: True.
+              - fn_flag (bool): Whether changing fc to fn. Default: ``True`` .
+              - gc_flag (bool): Whether to apply gc. Default: ``True`` .
 
             - grad_freeze:
 
-              - param_groups (int): The number of parameter groups. Default: 10.
-              - freeze_type (int): Gradient freeze grouping strategy, select from [0, 1]. Default: 1.
-              - freeze_p (float): Gradient freezing probability. Default: 0.7.
-              - total_steps (int): Total training steps. Default: 65536.
-
-            - grad_accumulation:
-
-              - grad_accumulation_step (int): Steps to accumulate gradients. Default: 1.
+              - param_groups (int): The number of parameter groups. Default: ``10`` .
+              - freeze_type (int): Gradient freeze grouping strategy, select from [0, 1]. Default: ``1`` .
+              - freeze_p (float): Gradient freezing probability. Default: ``0.7`` .
+              - total_steps (int): Total training steps. Default: ``65536`` .
 
             - dim_reduce:
 
@@ -174,14 +169,14 @@ class AutoBoost:
                   delta\_grad &= alpha \cdot new\_grad\_momentum - pca\_mat.T \cdot sk
                   \end{align}
 
-              - rho (float): Generally, it does not need to be modified. Default: 0.55.
-              - gamma (float): Generally, it does not need to be modified. Default: 0.9.
-              - alpha (float): Generally, it does not need to be modified. Default: 0.001.
-              - sigma (float): Generally, it does not need to be modified. Default: 0.4.
-              - n_components (int): PCA component. Default: 32.
-              - pca_mat_path (str): The path to load pca mat. Default: None.
-              - weight_load_dir (str): The directory to load weight files saved as ckpt. Default: None.
-              - timeout (int): Waiting time to load local pca mat. Default: 1800 (second).
+              - rho (float): Generally, it does not need to be modified. Default: ``0.55`` .
+              - gamma (float): Generally, it does not need to be modified. Default: ``0.9`` .
+              - alpha (float): Generally, it does not need to be modified. Default: ``0.001`` .
+              - sigma (float): Generally, it does not need to be modified. Default: ``0.4`` .
+              - n_components (int): PCA component. Default: ``32`` .
+              - pca_mat_path (str): The path to load pca mat. Default: ``None`` .
+              - weight_load_dir (str): The directory to load weight files saved as ckpt. Default: ``None`` .
+              - timeout (int): Waiting time to load local pca mat. Default: ``1800 (second)`` .
 
             User can load the config through the JSON file or use the dictionary directly.
             The unconfigured parameters will adopt the default values.
@@ -202,7 +197,7 @@ class AutoBoost:
         >>> import json
         >>> boost_json = "/path/boost_config.json"
         >>> with open(boost_json, 'r') as fp:
-        >>>     boost_config_dict = json.load(fp)
+        ...     boost_config_dict = json.load(fp)
         >>> boost = AutoBoost("O1", boost_config_dict)
     """
     _instance_lock = threading.Lock()