mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/ops/arg_dtype_cast.py

@@ -1,54 +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."""
-from enum import Enum
-
-
-class TypeCastKind(Enum):
-    INT_TO_TUPLE = 1
-    INT_OR_TUPLE_TO_LIST = 2
-
-
-def type_it(src_data, cast_type):
-    """
-    cast operator argument data type.
-    """
-    if cast_type == TypeCastKind.INT_TO_TUPLE:
-        if isinstance(src_data, tuple):
-            return src_data
-
-        if isinstance(src_data, int):
-            return (src_data,)
-
-        raise TypeError(f'{src_data} is the wrong data type.')
-
-    if cast_type == TypeCastKind.INT_OR_TUPLE_TO_LIST:
-        if isinstance(src_data, list):
-            return src_data
-
-        if isinstance(src_data, int):
-            return [
-                src_data,
-            ]
-
-        if isinstance(src_data, tuple):
-            dst_list = [item for item in src_data]
-            return dst_list
-
-        raise TypeError(f'{src_data} is the wrong data type.')
-
-    raise TypeError("Unsupported type cast")

mindspore/ops/silent_check.py

@@ -1,162 +0,0 @@
-# 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.
-# ============================================================================
-"""Silent Check."""
-import os
-
-from mindspore.common.tensor import Tensor
-from mindspore.common.parameter import Parameter
-import mindspore.common.dtype as mstype
-
-from . import operations
-from .operations._inner_ops import _MirrorSilentCheck
-from .operations import RmsNorm as OriginRmsNorm
-from .operations import LayerNorm as OriginLayerNorm
-from .primitive import Primitive
-
-
-NPU_ASD_ENABLE = 'NPU_ASD_ENABLE'
-
-
-class ASDBase:
-    """
-    ASDBase is the base class of operator with accuracy-sensitive detection feature in python.
-
-    Args:
-        cls (Primitive): Original operator requiring accuracy-sensitive detection feature.
-        args (tuple):  A variable parameter tuple to the original operator.
-        kwargs (dict): A variable parameter dictionary passed the original operator.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> from mindspore.ops.silent_check import ASDBase
-        >>> from mindspore.ops import LayerNorm as OriginLayerNorm
-        >>> class LayerNormASD(ASDBase):
-        ...     def __init__(self, *args, **kwargs):
-        ...         super().__init__(OriginLayerNorm, *args, **kwargs)
-        ...         # init parameters for accuracy-sensitive detection by calling the base class method generate_params()
-        ...         self.pre_val, self.min_val, self.max_val, self.cnt = self.generate_params()
-        ...
-        ...     def __call__(self, input_x, gamma, beta):
-        ...         if self.enable_check:
-        ...             # execute accuracy-sensitive detection by calling the check_op of base class
-        ...             input_x = self.check_op(
-        ...                 input_x, self.pre_val, self.min_val, self.max_val, self.cnt, None)
-        ...             self.cnt += 1
-        ...         # return the result of original operator
-        ...         return self.op(input_x, gamma, beta)
-    """
-    _index = 0
-    __ms_class__ = True
-
-    def __init__(self, cls, *args, **kwargs):
-        self.op = cls(*args, **kwargs)
-        self.check_op = _MirrorSilentCheck()
-        self._suffix = "ASD_" + cls.__name__
-        primitive_attr = dir(Primitive)
-        self._op_attr_dict = {
-            name for name in primitive_attr if not name.startswith("_")}
-        self.enable_check = os.environ.get(NPU_ASD_ENABLE) == "1"
-
-    def __getattr__(self, name):
-        def method_wrapper(*args, **kwargs):
-            out = getattr(self.op, name)(*args, **kwargs)
-            if out is self.op:
-                return self
-            return out
-
-        if name in self._op_attr_dict:
-            if callable(getattr(self.op, name)):
-                return method_wrapper
-        if hasattr(self.op, name):
-            return getattr(self.op, name)
-        return super().__getattr__(self, name)
-
-    def __repr__(self):
-        return self.op.__repr__()
-
-    def generate_params(self):
-        """
-        Generate support params for accuracy-sensitive detection.
-
-        Returns:
-            tuple consisting of four elements.
-            The derived class initializes the parameters required for accuracy-sensitive detection by calling
-            this function.
-
-        Examples:
-            >>> from mindspore.ops.silent_check import ASDBase
-            >>> from mindspore.ops import LayerNorm as OriginLayerNorm
-            >>> class LayerNormASD(ASDBase):
-            ...     def __init__(self, *args, **kwargs):
-            ...         super().__init__(OriginLayerNorm, *args, **kwargs)
-            ...         # init parameters for accuracy-sensitive detection by calling the base class function
-            ...         self.pre_val, self.min_val, self.max_val, self.cnt = self.generate_params()
-        """
-        pre_val = Parameter(Tensor(0, mstype.float32),
-                            name=f"{self._suffix}_pre_val_{self._index}",
-                            requires_grad=False)
-        min_val = Parameter(Tensor(0, mstype.float32),
-                            name=f"{self._suffix}_min_val_{self._index}",
-                            requires_grad=False)
-        max_val = Parameter(Tensor(0, mstype.float32),
-                            name=f"{self._suffix}_max_val_{self._index}",
-                            requires_grad=False)
-        cnt = Parameter(Tensor(0, mstype.int32),
-                        name=f"{self._suffix}_cnt_{self._index}",
-                        requires_grad=False)
-        ASDBase._index += 1
-        return pre_val, min_val, max_val, cnt
-
-
-class RmsNormASD(ASDBase):
-    """
-    RmsNorm with ASD.
-    """
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(OriginRmsNorm, *args, **kwargs)
-        self.pre_val, self.min_val, self.max_val, self.cnt = self.generate_params()
-
-    def __call__(self, input_x, gamma):
-        if self.enable_check:
-            input_x = self.check_op(
-                input_x, self.pre_val, self.min_val, self.max_val, self.cnt, None)
-            self.cnt += 1
-        return self.op(input_x, gamma)
-
-
-class LayerNormASD(ASDBase):
-    """
-    LayerNorm with ASD.
-    """
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(OriginLayerNorm, *args, **kwargs)
-        self.pre_val, self.min_val, self.max_val, self.cnt = self.generate_params()
-
-    def __call__(self, input_x, gamma, beta):
-        if self.enable_check:
-            input_x = self.check_op(
-                input_x, self.pre_val, self.min_val, self.max_val, self.cnt, None)
-            self.cnt += 1
-        return self.op(input_x, gamma, beta)
-
-
-def _silent_check():
-    if os.environ.get(NPU_ASD_ENABLE) == "1":
-        operations.LayerNorm = LayerNormASD
-        operations.RmsNorm = RmsNormASD

mindspore/profiler/parser/msadvisor_analyzer.py

@@ -1,82 +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.
-# ============================================================================
-"""
-The MSAdvisor analyzer.
-"""
-
-import os
-import stat
-import subprocess
-
-from mindspore import log as logger
-from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
-from mindspore.profiler.parser.msadvisor_parser import MsadvisorParser
-
-
-class Msadvisor:
-    """
-    The interface to call MSAdvisor(CANN) by command line.
-    """
-    def __init__(self, job_id, rank_id, output_path, pretty=False):
-        self._job_id, self._device_id = job_id.split("/")
-        self._rank_id = rank_id
-        self._output_path = output_path
-        self._pretty = pretty
-
-    def call_msadvisor(self):
-        """
-        Call MSAdvisor by command line.
-        """
-        output_path = os.path.join(self._output_path, "msadvisor")
-        output_path = os.path.join(output_path, "device_" + self._rank_id)
-        output_path = validate_and_normalize_path(output_path)
-        logger.info("MSAdvisor is running. Log and result files are saved in %s", output_path)
-
-        subprocess.run(["msadvisor", "-d", output_path, "-c", "all"],
-                       capture_output=True, check=True)
-        logger.info("MSAdvisor process finished.")
-
-        # Modified recommendation file permission, only Owner can read and write.
-        recommendation_path = os.path.join(output_path, "recommendation")
-        recommendation_path = validate_and_normalize_path(recommendation_path)
-        os.chmod(recommendation_path, stat.S_IRWXU)
-        file_list = os.listdir(recommendation_path)
-        file_list.sort(key=lambda fn: os.path.getmtime(os.path.join(recommendation_path, fn)))
-        recommendation_path = os.path.join(recommendation_path, file_list[-1])
-        recommendation_path = validate_and_normalize_path(recommendation_path)
-        os.chmod(recommendation_path, stat.S_IRUSR | stat.S_IWUSR)
-
-        # Modified log file permission, only Owner can read and write.
-        log_path = os.path.join(output_path, "log")
-        log_path = validate_and_normalize_path(log_path)
-        os.chmod(log_path, stat.S_IRWXU)
-        file_list = os.listdir(log_path)
-        file_list.sort(key=lambda fn: os.path.getmtime(os.path.join(log_path, fn)))
-        log_path = os.path.join(log_path, file_list[-1])
-        log_path = validate_and_normalize_path(log_path)
-        os.chmod(log_path, stat.S_IRWXU)
-        file_list = os.listdir(log_path)
-        log_path = os.path.join(log_path, file_list[0])
-        log_path = validate_and_normalize_path(log_path)
-        os.chmod(log_path, stat.S_IRUSR | stat.S_IWUSR)
-
-    def analyse(self):
-        """
-        Execute the MSAdvisor parser, generate timeline file and call MSAdvisor by command line.
-        """
-        reformater = MsadvisorParser(self._job_id, self._device_id,
-                                     self._rank_id, self._output_path, pretty=self._pretty)
-        reformater.parse()
-        self.call_msadvisor()

mindspore/profiler/parser/msadvisor_parser.py

@@ -1,240 +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.
-# ============================================================================
-"""
-MSAdvisor AICPU model parser.
-"""
-
-import os
-import stat
-import shutil
-import json
-
-from mindspore import log as logger
-from mindspore.profiler.common.exceptions.exceptions import ProfilerFileNotFoundException
-from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
-
-
-MIN_TO_US = 60000000  # 1 min to us
-MS_TO_US = 1000  # 1 ms to us
-AICPU_STREAM_ID = 9000  # aicpu stream id in profiler
-
-
-class MsadvisorParser:
-    """
-    Data format conversion for MSAdvisor AICPU model.
-    """
-
-    def __init__(self, job_id, device_id, rank_id, output_path, pretty=False):
-        self._job_id = job_id
-        self._device_id = device_id
-        self._rank_id = rank_id
-        self._output_path = output_path
-        self._aicore_path = ""
-        self._aicpu_path = ""
-        self._time_start = 0
-        self._time_end = 0
-        self._pretty = pretty
-
-    @property
-    def indent(self):
-        indent = 1 if self._pretty else None
-        return indent
-
-    @staticmethod
-    def check_clear_make_dir(dir_path):
-        """
-        Check if dir exists, then clear the dir and make a new dir.
-
-        Args:
-            dir_path (str): dir path is needed to clear and make.
-
-        Return:
-            str, new dir path.
-        """
-        dir_path = validate_and_normalize_path(dir_path)
-        if os.path.exists(dir_path):
-            shutil.rmtree(dir_path)
-        os.makedirs(dir_path, stat.S_IRWXU)
-        return dir_path
-
-    @staticmethod
-    def generate_aicore_json(aicore_info, tid):
-        """
-        Generate dict of operation information which be dumped into json file.
-
-        Args:
-            aicore_info (str): str read from aicore timeline file.
-            tid (int): Task Id.
-
-        Return:
-            dict, dict of operation information which can be dumped into json file.
-
-        Raises:
-            ValueError: If the value of aicore attrributes cannot be converted to float.
-        """
-        op = aicore_info.split(",")
-        name = op[0]
-        pid = 0
-        tid = tid - 1
-        task_type = "AI_CORE"
-
-        try:
-            ts, dur, sid = float(op[2]) * MS_TO_US, float(op[3]) * MS_TO_US, float(op[1])
-        except ValueError as err:
-            logger.warning("The aicore timeline file content is abnormal. Failed to format aicore timeline file")
-            raise err
-        finally:
-            pass
-
-        op = {
-            "name": name, "pid": pid, "ts": ts, "dur": dur,
-            "args": {"Task Type": task_type, "Stream Id": sid, "Task Id": tid}, "ph": "X"
-        }
-        return op
-
-    @staticmethod
-    def generate_aicpu_json(aicpu_info, tid):
-        """
-        Generate dict of operation information which be dumped into json file.
-
-        Args:
-            aicpu_info (str): str read from aicpu timeline file.
-            tid (int): Task Id.
-
-        Return:
-            dict, dict of operation information which can be dumped into json file.
-
-        Raises:
-            ValueError: If the value of aicpu attrributes cannot be converted to float.
-        """
-        op = aicpu_info.split(",")
-        name = op[1]
-        pid = 1
-        sid = AICPU_STREAM_ID
-        tid = tid - 1
-        task_type = "AI_CPU"
-
-        try:
-            ts = float(op[5])
-            dur = float(op[4]) * MS_TO_US
-        except ValueError as err:
-            logger.warning("The aicpu timeline file content is abnormal. Failed to format aicpu timeline file")
-            raise err
-        finally:
-            pass
-
-        op = {
-            "name": name, "pid": pid, "ts": ts, "dur": dur,
-            "args": {"Task Type": task_type, "Stream Id": sid, "Task Id": tid}, "ph": "X"
-        }
-        return op
-
-    def get_input_file(self):
-        """
-        Get aicore and aicpu information file from specific path and rank id.
-
-        Raises:
-            ProfilerFileNotFoundException: If aicore timeline file does not exist.
-            ProfilerFileNotFoundException: If aicpu timeline file does not exist.
-        """
-        self._aicore_path = "output_timeline_data_{}.txt".format(self._rank_id)
-        self._aicore_path = os.path.join(self._output_path, self._aicore_path)
-        self._aicore_path = validate_and_normalize_path(self._aicore_path)
-
-        self._aicpu_path = "aicpu_intermediate_{}.csv".format(self._rank_id)
-        self._aicpu_path = os.path.join(self._output_path, self._aicpu_path)
-        self._aicpu_path = validate_and_normalize_path(self._aicpu_path)
-
-        if not os.path.exists(self._aicore_path):
-            logger.warning('The aicore timeline file does not exist!')
-            raise ProfilerFileNotFoundException(msg=self._aicore_path)
-        if not os.path.exists(self._aicpu_path):
-            logger.warning('The aicpu timeline file does not exist!')
-            raise ProfilerFileNotFoundException(msg=self._aicpu_path)
-
-    def get_output_file(self):
-        """
-        Get output path needed by MSAdvisor and created dir.
-        """
-        msprof_file = os.path.join(self._output_path, "msadvisor")
-        msprof_file = os.path.join(msprof_file, "device_" + self._rank_id)
-        msprof_file = os.path.join(msprof_file, "profiling")
-        msprof_file = MsadvisorParser.check_clear_make_dir(msprof_file)
-
-        msprof_file = os.path.join(msprof_file, self._job_id)
-        msprof_file = os.path.join(msprof_file, "device_0", "timeline")
-        msprof_file = validate_and_normalize_path(msprof_file)
-        os.makedirs(msprof_file, stat.S_IRWXU)
-
-        msprof_file = os.path.join(msprof_file, "task_time_0_1_1.json")
-        self._output_path = msprof_file
-
-    def write_aicore(self):
-        """
-        Read aicore information from file created by profiler and generate new file needed by MSAdvisor.
-        """
-        aicore_file = self._aicore_path
-        output_file = self._output_path
-
-        with os.fdopen(os.open(output_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
-                               stat.S_IRUSR | stat.S_IWUSR), "w") as output_file:
-            output_file.write("[")
-            with os.fdopen(os.open(aicore_file, os.O_RDONLY,
-                                   stat.S_IRUSR | stat.S_IWUSR), "r") as aicore_file:
-                for tid, aicore in enumerate(aicore_file):
-                    if tid == 0:
-                        continue
-                    op = MsadvisorParser.generate_aicore_json(aicore, tid)
-                    if tid == 1:
-                        self._time_start = op.get("ts")
-                    total_duration = op.get("ts") - self._time_start
-                    if total_duration > 1 * MIN_TO_US or tid > 10000:
-                        self._time_end = op.get("ts")
-                        break
-                    if tid > 1:
-                        output_file.write(",")
-                    json.dump(op, output_file, indent=self.indent)
-
-    def write_aicpu(self):
-        """
-        Read aicpu information from file created by profiler and write into new file needed by MSAdvisor.
-        """
-        aicpu_file = self._aicpu_path
-        output_file = self._output_path
-
-        with os.fdopen(os.open(output_file, os.O_WRONLY | os.O_APPEND,
-                               stat.S_IRUSR | stat.S_IWUSR), "a") as output_file:
-            with os.fdopen(os.open(aicpu_file, os.O_RDONLY,
-                                   stat.S_IRUSR | stat.S_IWUSR), "r") as aicpu_file:
-                for tid, aicpu in enumerate(aicpu_file):
-                    if tid == 0:
-                        continue
-                    op = MsadvisorParser.generate_aicpu_json(aicpu, tid)
-                    if op is None:
-                        continue
-                    if op.get("ts") > self._time_end:
-                        break
-                    output_file.write(",")
-                    json.dump(op, output_file, indent=self.indent)
-            output_file.write("]")
-
-    def parse(self):
-        """
-        Interface to call all function in the class. Generated data for AICpu model in MSAdvisor.
-        """
-        self.get_input_file()
-        self.get_output_file()
-        self.write_aicore()
-        self.write_aicpu()

mindspore/rewrite/api/tree_node_helper.py

@@ -1,60 +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.
-# ============================================================================
-"""Rewrite module api: TreeNodeHelper."""
-from typing import Optional
-
-from mindspore import log as logger
-from mindspore import _checkparam as Validator
-from .symbol_tree import SymbolTree
-from .node import Node
-from .node_type import NodeType
-from ..symbol_tree import SymbolTree as SymbolTreeImpl
-
-
-class TreeNodeHelper:
-    """
-    `TreeNodeHelper` is used to break circle reference while getting symbol_tree from a `Tree` type `Node`.
-
-    `TreeNodeHelper` provides a staticmethod `get_sub_tree` for getting symbol_tree from a `Tree` type `Node`.
-
-    .. warning::
-        This is a set of experimental APIs that is subject to change or deletion.
-    """
-
-    @staticmethod
-    def get_sub_tree(node: Node) -> Optional[SymbolTree]:
-        """
-        Getting symbol_tree from a `Tree` type `Node`.
-
-        Args:
-            node (Node): A `Node` which may hold a sub-symbol_tree.
-
-        Returns:
-            An instance of SymbolTree represents sub-symbol_tree. Note that `node`'s symbol_tree maybe None, in this
-            case, method will return None.
-
-        Raises:
-            RuntimeError: If `node`'s type is not `NodeType.Tree`.
-            TypeError: If `node` is not a `Node` instance.
-        """
-        Validator.check_value_type("node", node, [Node], "TreeNodeHelper")
-        if node.get_node_type() == NodeType.Tree:
-            node_impl = node.get_handler()
-            subtree: SymbolTreeImpl = node_impl.symbol_tree
-            if subtree is None:
-                return None
-            return SymbolTree(subtree)
-        logger.info(f"Current node is not a Tree node, current node type: {type(node)}")
-        return None