mindstudio-probe 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

msprobe/mindspore/free_benchmark/perturbation/improve_precision.py

@@ -1,34 +1,49 @@
-from typing import Any
-
-import mindspore as ms
-from mindspore import Tensor, ops
-
-from msprobe.mindspore.free_benchmark.perturbation.base_perturbation import BasePerturbation
-from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
-from msprobe.mindspore.common.const import FreeBenchmarkConst
-from msprobe.mindspore.common.log import logger
-
-
-class ImprovePrecisionPerturbation(BasePerturbation):
-
-    def improve_tensor_precision(self, target_tensor):
-        if isinstance(target_tensor, Tensor) and ops.is_floating_point(target_tensor) and \
-           target_tensor.dtype not in [ms.float64, ms.float32]:
-            self.is_fuzzed = True
-            return target_tensor.to(ms.float32)
-        if isinstance(target_tensor, dict):
-            return {k: self.improve_tensor_precision(v) for k, v in target_tensor.items()}
-        if isinstance(target_tensor, (tuple, list)):
-            return type(target_tensor)([self.improve_tensor_precision(v) for v in target_tensor])
-        return target_tensor
-
-    def handle(self, params: HandlerParams) -> Any:
-        args = self.improve_tensor_precision(params.args)
-        kwargs = self.improve_tensor_precision(params.kwargs)
-        fuzzed_value = args
-        if self.api_name in FreeBenchmarkConst.COMMUNICATION_API_LIST:
-            params.fuzzed_value = fuzzed_value
-        if not self.is_fuzzed:
-            logger.warning(f"{self.api_name} can not improve precision.")
-            return False
-        return params.original_func(*args, **kwargs)
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+from typing import Any
+
+import mindspore as ms
+from mindspore import Tensor, ops
+
+from msprobe.mindspore.common.const import Const
+from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
+from msprobe.mindspore.free_benchmark.perturbation.base_perturbation import BasePerturbation
+
+
+class ImprovePrecisionPerturbation(BasePerturbation):
+
+    def improve_tensor_precision(self, target_tensor):
+        if isinstance(target_tensor, Tensor) and ops.is_floating_point(target_tensor) and \
+           target_tensor.dtype not in [ms.float64, ms.float32]:
+            self.is_fuzzed = True
+            return target_tensor.to(ms.float32)
+        if isinstance(target_tensor, dict):
+            return {k: self.improve_tensor_precision(v) for k, v in target_tensor.items()}
+        if isinstance(target_tensor, (tuple, list)):
+            return type(target_tensor)([self.improve_tensor_precision(v) for v in target_tensor])
+        return target_tensor
+
+    def handle(self, params: HandlerParams) -> Any:
+        args = self.improve_tensor_precision(params.args)
+        kwargs = self.improve_tensor_precision(params.kwargs)
+        fuzzed_value = args
+        if self.api_name in Const.COMMUNICATION_API_LIST:
+            params.fuzzed_value = fuzzed_value
+        if not self.is_fuzzed:
+            logger.warning(f"{self.api_name} can not improve precision.")
+            return False
+        return params.original_func(*args, **kwargs)

msprobe/mindspore/free_benchmark/perturbation/no_change.py

@@ -1,12 +1,27 @@
-from typing import Any
-
-from msprobe.mindspore.free_benchmark.perturbation.base_perturbation import BasePerturbation
-from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
-
-
-class NoChangePerturbation(BasePerturbation):
-
-    def handle(self, params: HandlerParams) -> Any:
-        params.fuzzed_value = params.args[params.index]
-        self.is_fuzzed = True
-        return self.get_fuzzed_result(params)
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+from typing import Any
+
+from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
+from msprobe.mindspore.free_benchmark.perturbation.base_perturbation import BasePerturbation
+
+
+class NoChangePerturbation(BasePerturbation):
+
+    def handle(self, params: HandlerParams) -> Any:
+        params.fuzzed_value = params.args[params.index]
+        self.is_fuzzed = True
+        return self.get_fuzzed_result(params)

msprobe/mindspore/free_benchmark/perturbation/perturbation_factory.py

@@ -1,27 +1,44 @@
-from msprobe.mindspore.common.const import FreeBenchmarkConst
-from msprobe.mindspore.free_benchmark.common.config import Config
-from .add_noise import AddNoisePerturbation
-from .bit_noise import BitNoisePerturbation
-from .no_change import NoChangePerturbation
-from .improve_precision import ImprovePrecisionPerturbation
-
-
-class PerturbationFactory:
-    """
-    扰动工厂类
-
-    """
-    perturbations = {
-        FreeBenchmarkConst.IMPROVE_PRECISION: ImprovePrecisionPerturbation,
-        FreeBenchmarkConst.ADD_NOISE: AddNoisePerturbation,
-        FreeBenchmarkConst.BIT_NOISE: BitNoisePerturbation,
-        FreeBenchmarkConst.NO_CHANGE: NoChangePerturbation,
-    }
-
-    @staticmethod
-    def create(api_name: str):
-        perturbation = PerturbationFactory.perturbations.get(Config.pert_type)
-        if perturbation:
-            return perturbation(api_name)
-        else:
-            raise Exception(f'{Config.pert_type} is a invalid perturbation type')
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+from msprobe.mindspore.free_benchmark.common.config import Config
+from msprobe.mindspore.free_benchmark.perturbation.add_noise import AddNoisePerturbation
+from msprobe.mindspore.free_benchmark.perturbation.bit_noise import BitNoisePerturbation
+from msprobe.mindspore.free_benchmark.perturbation.exchange_value import ExchangeValuePerturbation
+from msprobe.mindspore.free_benchmark.perturbation.improve_precision import ImprovePrecisionPerturbation
+from msprobe.mindspore.free_benchmark.perturbation.no_change import NoChangePerturbation
+
+
+class PerturbationFactory:
+    """
+    扰动工厂类
+
+    """
+    perturbations = {
+        FreeBenchmarkConst.IMPROVE_PRECISION: ImprovePrecisionPerturbation,
+        FreeBenchmarkConst.ADD_NOISE: AddNoisePerturbation,
+        FreeBenchmarkConst.BIT_NOISE: BitNoisePerturbation,
+        FreeBenchmarkConst.NO_CHANGE: NoChangePerturbation,
+        FreeBenchmarkConst.EXCHANGE_VALUE: ExchangeValuePerturbation
+    }
+
+    @staticmethod
+    def create(api_name: str):
+        perturbation = PerturbationFactory.perturbations.get(Config.pert_type)
+        if perturbation:
+            return perturbation(api_name)
+        else:
+            raise Exception(f'{Config.pert_type} is a invalid perturbation type')

msprobe/mindspore/free_benchmark/self_check_tool_factory.py

@@ -1,33 +1,48 @@
-from msprobe.mindspore.common.const import Const
-from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
-from msprobe.mindspore.free_benchmark.api_pynative_self_check import ApiPyNativeSelFCheck
-
-
-class SelfCheckToolFactory:
-    tools = {
-        Const.CELL: {
-            Const.GRAPH_KBYK_MODE: None,
-            Const.GRAPH_GE_MODE: None,
-            Const.PYNATIVE_MODE: None
-        },
-        Const.API: {
-            Const.GRAPH_KBYK_MODE: None,
-            Const.GRAPH_GE_MODE: None,
-            Const.PYNATIVE_MODE: ApiPyNativeSelFCheck
-        },
-        Const.KERNEL: {
-            Const.GRAPH_KBYK_MODE: None,
-            Const.GRAPH_GE_MODE: None,
-            Const.PYNATIVE_MODE: None
-        }
-    }
-
-    @staticmethod
-    def create(config: DebuggerConfig):
-        tool = SelfCheckToolFactory.tools.get(config.level)
-        if not tool:
-            raise Exception(f"{config.level} is not supported.")
-        tool = tool.get(config.execution_mode)
-        if not tool:
-            raise Exception(f"Task free_benchmark is not supported in this mode: {config.execution_mode}.")
-        return tool(config)
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+from msprobe.mindspore.common.const import Const
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.free_benchmark.api_pynative_self_check import ApiPyNativeSelFCheck
+
+
+class SelfCheckToolFactory:
+    tools = {
+        Const.CELL: {
+            Const.GRAPH_KBYK_MODE: None,
+            Const.GRAPH_GE_MODE: None,
+            Const.PYNATIVE_MODE: None
+        },
+        Const.API: {
+            Const.GRAPH_KBYK_MODE: None,
+            Const.GRAPH_GE_MODE: None,
+            Const.PYNATIVE_MODE: ApiPyNativeSelFCheck
+        },
+        Const.KERNEL: {
+            Const.GRAPH_KBYK_MODE: None,
+            Const.GRAPH_GE_MODE: None,
+            Const.PYNATIVE_MODE: None
+        }
+    }
+
+    @staticmethod
+    def create(config: DebuggerConfig):
+        tool = SelfCheckToolFactory.tools.get(config.level)
+        if not tool:
+            raise Exception(f"{config.level} is not supported.")
+        tool = tool.get(config.execution_mode)
+        if not tool:
+            raise Exception(f"Task free_benchmark is not supported in this mode: {config.execution_mode}.")
+        return tool(config)

msprobe/mindspore/grad_probe/global_context.py

@@ -1,91 +1,100 @@
-import os
-import threading
-from typing import Dict, Union
-
-from msprobe.core.grad_probe.utils import check_str
-from msprobe.core.grad_probe.constant import GradConst
-from msprobe.core.common.log import logger
-from msprobe.core.common.file_check import create_directory
-from msprobe.core.common.utils import check_path_before_create
-
-
-class GlobalContext:
-
-    _instance = None
-    _instance_lock = threading.Lock()
-    _setting = {
-        GradConst.LEVEL: None,
-        GradConst.PARAM_LIST: None,
-        GradConst.STEP: None,
-        GradConst.RANK: None,
-        GradConst.CURRENT_STEP: 0,
-        GradConst.BOUNDS: [-10, -1, -0.1, -0.01, -0.001, 0, 0.001, 0.01, 0.1, 1, 10],
-        GradConst.OUTPUT_PATH: None
-    }
-
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance_lock.acquire()
-            cls._instance = object.__new__(cls)
-            cls._instance_lock.release()
-        return cls._instance
-
-    def init_context(self, config_dict: Dict):
-        level = config_dict.get(GradConst.LEVEL)
-        check_str(level, variable_name = "level in yaml")
-        if level in GradConst.SUPPORTED_LEVEL:
-            self._setting[GradConst.LEVEL] = config_dict.get(GradConst.LEVEL)
-        else:
-            raise ValueError("Invalid level set in config yaml file, level option: L0, L1, L2")
-
-        self._set_input_list(config_dict, GradConst.PARAM_LIST, str)
-        self._set_input_list(config_dict, GradConst.BOUNDS, float)
-        self._set_input_list(config_dict, GradConst.STEP, int)
-        self._set_input_list(config_dict, GradConst.RANK, int)
-
-        output_path = config_dict.get(GradConst.OUTPUT_PATH)
-        check_str(output_path, variable_name = "output_path in yaml")
-        try:
-            check_path_before_create(output_path)
-        except RuntimeError as err:
-            raise ValueError(f"Invalid output_path: {output_path}. The error message is {err}.") from err
-        self._setting[GradConst.OUTPUT_PATH] = output_path
-        if not os.path.isdir(self._setting.get(GradConst.OUTPUT_PATH)):
-            create_directory(self._setting.get(GradConst.OUTPUT_PATH))
-        else:
-            logger.warning("The output_path exists, the data will be covered.")
-
-    def get_context(self, key: str):
-        if key not in self._setting:
-            logger.warning(f"Unrecognized {key}.")
-        return self._setting.get(key)
-
-    def update_step(self):
-        self._setting[GradConst.CURRENT_STEP] += 1
-
-    def step_need_dump(self, step):
-        dump_step_list = self.get_context(GradConst.STEP)
-        return (not dump_step_list) or (step in dump_step_list)
-
-    def rank_need_dump(self, rank):
-        dump_rank_list = self.get_context(GradConst.RANK)
-        return (not dump_rank_list) or (rank in dump_rank_list)
-
-    def _set_input_list(self, config_dict: Dict, name: str, dtype: Union[int, str, float]):
-        value = config_dict.get(name)
-        if dtype == int:
-            type_str = "integer"
-        elif dtype == float:
-            type_str = "float"
-        else:
-            type_str = "string"
-        if value and isinstance(value, list):
-            for val in value:
-                if not isinstance(val, dtype):
-                    logger.warning(f"Invalid {name} which must be None or list of {type_str}")
-                    return
-            self._setting[name] = value
-        else:
-            logger.warning(f"{name} is None or not a list with valid items, use default value.")
-
-grad_context = GlobalContext()
+import os
+import threading
+from typing import Dict, Union, Tuple
+
+from msprobe.core.grad_probe.utils import check_str, check_bounds_element
+from msprobe.core.grad_probe.constant import GradConst
+from msprobe.mindspore.common.log import logger
+from msprobe.core.common.file_utils import create_directory, check_path_before_create
+
+
+class GlobalContext:
+
+    _instance = None
+    _instance_lock = threading.Lock()
+    _setting = {
+        GradConst.LEVEL: None,
+        GradConst.PARAM_LIST: None,
+        GradConst.STEP: None,
+        GradConst.RANK: None,
+        GradConst.CURRENT_STEP: 0,
+        GradConst.BOUNDS: [-1, 0, 1],
+        GradConst.OUTPUT_PATH: None
+    }
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance_lock.acquire()
+            cls._instance = object.__new__(cls)
+            cls._instance_lock.release()
+        return cls._instance
+
+    def init_context(self, config_dict: Dict):
+        level = config_dict.get(GradConst.LEVEL)
+        check_str(level, variable_name="level in yaml")
+        if level in GradConst.SUPPORTED_LEVEL:
+            self._setting[GradConst.LEVEL] = config_dict.get(GradConst.LEVEL)
+        else:
+            raise ValueError("Invalid level set in config yaml file, level option: L0, L1, L2")
+
+        self._set_input_list(config_dict, GradConst.PARAM_LIST, str)
+        self._set_input_list(config_dict, GradConst.BOUNDS, (float, int), element_check=check_bounds_element)
+        self._set_input_list(config_dict, GradConst.STEP, int)
+        self._set_input_list(config_dict, GradConst.RANK, int)
+
+        output_path = config_dict.get(GradConst.OUTPUT_PATH)
+        check_str(output_path, variable_name="output_path in yaml")
+        try:
+            check_path_before_create(output_path)
+        except RuntimeError as err:
+            raise ValueError(f"Invalid output_path: {output_path}. The error message is {err}.") from err
+        self._setting[GradConst.OUTPUT_PATH] = output_path
+        if not os.path.isdir(self._setting.get(GradConst.OUTPUT_PATH)):
+            create_directory(self._setting.get(GradConst.OUTPUT_PATH))
+        else:
+            logger.warning("The output_path exists, the data will be covered.")
+
+    def get_context(self, key: str):
+        if key not in self._setting:
+            logger.warning(f"Unrecognized {key}.")
+        return self._setting.get(key)
+
+    def update_step(self):
+        self._setting[GradConst.CURRENT_STEP] += 1
+
+    def step_need_dump(self, step):
+        dump_step_list = self.get_context(GradConst.STEP)
+        return (not dump_step_list) or (step in dump_step_list)
+
+    def rank_need_dump(self, rank):
+        dump_rank_list = self.get_context(GradConst.RANK)
+        return (not dump_rank_list) or (rank in dump_rank_list)
+
+    def _get_type_str(self, dtype: Union[int, str, float, Tuple[int, str, float]]):
+        if isinstance(dtype, tuple):
+            return "/".join([self._get_type_str(element) for element in dtype])
+        if dtype == int:
+            type_str = "integer"
+        elif dtype == float:
+            type_str = "float"
+        else:
+            type_str = "string"
+        return type_str
+
+    def _set_input_list(self, config_dict: Dict, name: str,
+                        dtype: Union[int, str, float, Tuple[int, str, float]], element_check=None):
+        value = config_dict.get(name)
+        type_str = self._get_type_str(dtype)
+        if value and isinstance(value, list):
+            for val in value:
+                if not isinstance(val, dtype):
+                    logger.warning(f"Invalid {name} which must be None or list of {type_str}")
+                    return
+                if element_check and not element_check(val):
+                    logger.warning(f"Given {name} violates some rules.")
+                    return
+            self._setting[name] = value
+        else:
+            logger.warning(f"{name} is None or not a list with valid items, use default value.")
+
+grad_context = GlobalContext()