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

msprobe/mindspore/free_benchmark/perturbation/improve_precision.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
 # All rights reserved.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
+# 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
 #
@@ -18,9 +18,11 @@ from typing import Any
 import mindspore as ms
 from mindspore import Tensor, ops
 
-from msprobe.mindspore.common.const import Const
+from msprobe.core.common.const import Const
 from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.free_benchmark.common.config import Config
 from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
+from msprobe.mindspore.free_benchmark.common.utils import Tools
 from msprobe.mindspore.free_benchmark.perturbation.base_perturbation import BasePerturbation
 
 
@@ -40,10 +42,15 @@ class ImprovePrecisionPerturbation(BasePerturbation):
     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.")
+            logger.warning(f"{self.api_name_with_id} can not improve precision.")
             return False
+
+        if Config.stage == Const.BACKWARD:
+            fuzzed_result = Tools.get_grad(params.original_func, *args, **kwargs)
+            if fuzzed_result is not None:
+                return fuzzed_result
+            else:
+                return False
+
         return params.original_func(*args, **kwargs)

msprobe/mindspore/free_benchmark/perturbation/perturbation_factory.py

@@ -36,9 +36,9 @@ class PerturbationFactory:
     }
 
     @staticmethod
-    def create(api_name: str):
+    def create(api_name_with_id: str):
         perturbation = PerturbationFactory.perturbations.get(Config.pert_type)
         if perturbation:
-            return perturbation(api_name)
+            return perturbation(api_name_with_id)
         else:
             raise Exception(f'{Config.pert_type} is a invalid perturbation type')

msprobe/mindspore/free_benchmark/self_check_tool_factory.py

@@ -15,7 +15,7 @@
 
 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
+from msprobe.mindspore.free_benchmark.api_pynative_self_check import ApiPyNativeSelfCheck
 
 
 class SelfCheckToolFactory:
@@ -28,7 +28,7 @@ class SelfCheckToolFactory:
         Const.API: {
             Const.GRAPH_KBYK_MODE: None,
             Const.GRAPH_GE_MODE: None,
-            Const.PYNATIVE_MODE: ApiPyNativeSelFCheck
+            Const.PYNATIVE_MODE: ApiPyNativeSelfCheck
         },
         Const.KERNEL: {
             Const.GRAPH_KBYK_MODE: None,

msprobe/mindspore/grad_probe/global_context.py

@@ -1,15 +1,30 @@
+# 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.
+
 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.common.utils import is_int
+from msprobe.core.common.file_utils import create_directory, check_path_before_create
 from msprobe.core.grad_probe.constant import GradConst
+from msprobe.core.grad_probe.utils import check_str, check_bounds_element, check_param_element
 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 = {
@@ -37,10 +52,10 @@ class GlobalContext:
         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.PARAM_LIST, (str,), element_check=check_param_element)
         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)
+        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")
@@ -88,13 +103,18 @@ class GlobalContext:
         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}")
+                    logger.warning(f"Invalid {name} which must be None or list of {type_str}, use default value.")
+                    return
+                elif isinstance(val, int) and not is_int(val):
+                    logger.warning(f"Invalid {name} which must be None or list of int, use default value.")
                     return
                 if element_check and not element_check(val):
-                    logger.warning(f"Given {name} violates some rules.")
+                    logger.warning(f"Given {name} violates some rules, use default value.")
                     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()

msprobe/mindspore/grad_probe/grad_analyzer.py

@@ -1,23 +1,48 @@
+# 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.
+
+import multiprocessing
 import os
 import time
-from typing import List, Tuple
-import multiprocessing
+from dataclasses import dataclass
 from multiprocessing import Process
+from typing import List
 
-import numpy as np
 import mindspore as ms
-from mindspore.communication import get_rank
-from mindspore.ops import operations as P
+import numpy as np
 from mindspore.common.parameter import Parameter
+from mindspore.communication import get_rank
 
-from msprobe.core.grad_probe.utils import ListCache
-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_file_or_directory_path,
                                             write_csv, remove_path, move_file, load_npy)
+from msprobe.core.grad_probe.constant import GradConst
+from msprobe.core.grad_probe.utils import ListCache
+from msprobe.mindspore.common.log import logger
 from msprobe.mindspore.grad_probe.global_context import grad_context, GlobalContext
 
 
+@dataclass
+class GradDumpConfig:
+    dump_dir: str
+    g_name: str
+    dump_step: Parameter
+    grad: ms.Tensor
+    level: str
+    bounds: List
+
+
 def get_rank_id():
     try:
         rank_id = get_rank()
@@ -27,35 +52,35 @@ def get_rank_id():
 
 
 @ms.jit
-def grad_dump(dump_dir: str, g_name: str, dump_step: Parameter, grad: ms.Tensor, level: str, bounds: List):
-    '''
+def grad_dump(config: GradDumpConfig):
+    """
     Dump gradient statistic data.
         level0: [step, max, min, norm, shape_dim, shape]
         level1: [step, max, min, norm, shape_dim, shape] + grad_bool_data
         level2: [step, max, min, norm, shape_dim, shape, dist_dim, dist] + grad_bool_data
-    '''
-    dump_path = os.path.join(dump_dir, g_name)
+    """
+    dump_path = os.path.join(config.dump_dir, config.g_name)
     dump_dir_path = dump_path + "_dir"
     save_op = ms.ops.TensorDump()
 
-    grad_flat = grad.reshape(-1)
+    grad_flat = config.grad.reshape(-1)
     max_val = grad_flat.max(axis=0).float()
     min_val = grad_flat.min(axis=0).float()
     norm_val = grad_flat.norm(ord=2).float()
-    shape = grad.shape
-    extrem_list = [dump_step[0].float(), max_val, min_val, norm_val]
+    shape = config.grad.shape
+    extrem_list = [config.dump_step[0].float(), max_val, min_val, norm_val]
     extrem_stat = ms.ops.stack(extrem_list)
     shape_list = [len(shape)] + list(shape)
     shape_stat = ms.Tensor(shape_list).float()
     level0_stat = ms.ops.concat((extrem_stat, shape_stat), axis=0)
     level_stat = level0_stat
 
-    if level == GradConst.LEVEL2:
-        zero_grad = (grad == 0).sum()
-        dist_dim = ms.Tensor([len(bounds) + 2]).float()
-        bucket_result = ms.ops.bucketize(grad.float(), bounds)
+    if config.level == GradConst.LEVEL2:
+        zero_grad = (config.grad == 0).sum()
+        dist_dim = ms.Tensor([len(config.bounds) + 2]).float()
+        bucket_result = ms.ops.bucketize(config.grad.float(), config.bounds)
         bucket_result = bucket_result.astype(ms.int8)
-        dist_stat = [(bucket_result == i).sum() for i in range(len(bounds) + 1)]
+        dist_stat = [(bucket_result == i).sum() for i in range(len(config.bounds) + 1)]
         dist_stat.append(zero_grad)
         dist_stat.append(ms.Tensor(1, dtype=ms.int64))  # make sure dist_stat is not empty
         dist_stat = ms.ops.stack(dist_stat, axis=0).float()
@@ -63,8 +88,8 @@ def grad_dump(dump_dir: str, g_name: str, dump_step: Parameter, grad: ms.Tensor,
         level_stat = level2_stat
 
     save_op(dump_path, level_stat)
-    if level == GradConst.LEVEL1 or level == GradConst.LEVEL2:
-        grad_direction = grad > 0
+    if config.level == GradConst.LEVEL1 or config.level == GradConst.LEVEL2:
+        grad_direction = config.grad > 0
         save_op(dump_dir_path, grad_direction)
 
 
@@ -182,7 +207,7 @@ class CSVGenerator(Process):
         shape_dim = int(stat_data[GradConst.SHAPE_DIM_IDX])
         file_name = os.path.basename(file_path)
         prefix_idx = len(file_name.split("_")[0])
-        param_name = file_name[(prefix_idx + 1) : -(len(GradConst.NPY_SUFFIX) + 1)]
+        param_name = file_name[(prefix_idx + 1): -(len(GradConst.NPY_SUFFIX) + 1)]
         if not param_name:
             raise RuntimeError("Invalid gradient statistic file name.")
         csv_line = [param_name]
@@ -224,8 +249,9 @@ class CSVGenerator(Process):
             if i == 0:
                 intervals.append(f"(-inf, {self.bounds[i]}]")
             else:
-                intervals.append(f"({self.bounds[i-1]}, {self.bounds[i]}]")
+                intervals.append(f"({self.bounds[i - 1]}, {self.bounds[i]}]")
         intervals.extend([f"({self.bounds[-1]}, inf)", "=0"])
         return intervals
 
+
 csv_generator = CSVGenerator()

msprobe/mindspore/grad_probe/grad_monitor.py

@@ -1,7 +1,22 @@
+# 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.core.grad_probe.constant import GradConst
 from msprobe.mindspore.grad_probe.global_context import grad_context
 from msprobe.mindspore.grad_probe.grad_analyzer import csv_generator
 from msprobe.mindspore.grad_probe.hook import hook_optimizer
-from msprobe.core.grad_probe.constant import GradConst
 
 
 class GradientMonitor:

msprobe/mindspore/grad_probe/grad_stat_csv.py

@@ -1,8 +1,23 @@
-from abc import ABC, abstractmethod
+# 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.
+
 import hashlib
+from abc import ABC, abstractmethod
 
 import mindspore
-from mindspore import ops, Tensor
+from mindspore import ops
 from msprobe.core.grad_probe.constant import GradConst
 
 
@@ -12,6 +27,7 @@ class CsvInput:
         self.grad = grad
         self.bounds = bounds
 
+
 class GradStatCsv:
     csv = {}
 
@@ -52,9 +68,11 @@ class CsvItem(ABC):
 
 @register_csv_item(GradConst.MD5)
 class CsvMd5(CsvItem):
+    @staticmethod
     def generate_csv_header(csv_input):
         return ["MD5"]
 
+    @staticmethod
     def generate_csv_content(csv_input):
         grad = csv_input.grad
         tensor_bytes = grad.float().numpy().tobytes()
@@ -64,19 +82,21 @@ class CsvMd5(CsvItem):
 
 @register_csv_item(GradConst.DISTRIBUTION)
 class CsvDistribution(CsvItem):
+    @staticmethod
     def generate_csv_header(csv_input):
         bounds = csv_input.bounds
         intervals = []
         if bounds:
             intervals.append(f"(-inf, {bounds[0]}]")
             for i in range(1, len(bounds)):
-                intervals.append(f"({bounds[i-1]}, {bounds[i]}]")
+                intervals.append(f"({bounds[i - 1]}, {bounds[i]}]")
         if intervals:
             intervals.append(f"({bounds[-1]}, inf)")
         intervals.append("=0")
-    
+
         return intervals
 
+    @staticmethod
     def generate_csv_content(csv_input):
         grad = csv_input.grad
         bounds = csv_input.bounds
@@ -94,9 +114,11 @@ class CsvDistribution(CsvItem):
 
 @register_csv_item(GradConst.MAX)
 class CsvMax(CsvItem):
+    @staticmethod
     def generate_csv_header(csv_input):
         return ["max"]
 
+    @staticmethod
     def generate_csv_content(csv_input):
         grad = csv_input.grad
         return [ops.amax(grad).float().numpy().tolist()]
@@ -104,9 +126,11 @@ class CsvMax(CsvItem):
 
 @register_csv_item(GradConst.MIN)
 class CsvMin(CsvItem):
+    @staticmethod
     def generate_csv_header(csv_input):
         return ["min"]
 
+    @staticmethod
     def generate_csv_content(csv_input):
         grad = csv_input.grad
         return [ops.amin(grad).float().numpy().tolist()]
@@ -114,9 +138,11 @@ class CsvMin(CsvItem):
 
 @register_csv_item(GradConst.NORM)
 class CsvNorm(CsvItem):
+    @staticmethod
     def generate_csv_header(csv_input):
         return ["norm"]
 
+    @staticmethod
     def generate_csv_content(csv_input):
         grad = csv_input.grad
         return [ops.norm(grad).float().numpy().tolist()]
@@ -124,9 +150,11 @@ class CsvNorm(CsvItem):
 
 @register_csv_item(GradConst.SHAPE)
 class CsvShape(CsvItem):
+    @staticmethod
     def generate_csv_header(csv_input):
         return ["shape"]
 
+    @staticmethod
     def generate_csv_content(csv_input):
         grad = csv_input.grad
-        return [list(grad.shape)]
+        return [list(grad.shape)]

msprobe/mindspore/grad_probe/hook.py

@@ -1,32 +1,51 @@
+# 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.
 
 import os
 
 import mindspore
 import mindspore as ms
 from mindspore.common.api import jit
-from mindspore.nn.optim.optimizer import Optimizer
-from mindspore.common.parameter import Parameter
 from mindspore.common.initializer import initializer
-
+from mindspore.common.parameter import Parameter
+from mindspore.nn.optim.optimizer import Optimizer
+from msprobe.core.common.file_utils import remove_path, write_csv, create_directory
 from msprobe.core.grad_probe.constant import GradConst
 from msprobe.mindspore.common.log import logger
-
-from msprobe.core.common.file_utils import remove_path, write_csv, create_directory
 from msprobe.mindspore.grad_probe.global_context import grad_context
-from msprobe.mindspore.grad_probe.grad_analyzer import grad_dump, get_rank_id
 from msprobe.mindspore.grad_probe.grad_analyzer import csv_generator
+from msprobe.mindspore.grad_probe.grad_analyzer import grad_dump, get_rank_id, GradDumpConfig
 from msprobe.mindspore.grad_probe.grad_stat_csv import GradStatCsv, CsvInput
 from msprobe.mindspore.grad_probe.utils import save_grad_direction, get_adapted_level
 
-class HookInput:
 
+class HookInput:
     '''
     HookInput is a class wrapping all the variables used for hooking optimizer
     '''
 
     def __init__(self, opt) -> None:
         self.func = opt.construct
-        self.g_names = [param.name for param in opt._parameters]
+        if hasattr(opt, "_parameters"):
+            parameter_list = opt._parameters
+        elif hasattr(opt, "parameters"):
+            parameter_list = opt.parameters
+        else:
+            logger.error_log_with_exp("Given optimizer has no attributes: '_parameters' or 'parameters'. \
+                                      Please check the type of the given optimizer.", ValueError)
+        self.g_names = [param.name for param in parameter_list]
         self.param_list = grad_context.get_context(GradConst.PARAM_LIST)
         self.rank_id = get_rank_id()
         output_path = grad_context.get_context(GradConst.OUTPUT_PATH)
@@ -40,14 +59,17 @@ class HookInput:
         self.bounds = grad_context.get_context(GradConst.BOUNDS)
         self.mode = mindspore.get_context("mode")
 
+
 def hook_graph_mode_optimizer(opt, hook_input):
     @jit
     def new_construct(self, gradients):
         for index, grad_value in enumerate(gradients):
             if hook_input.param_list and hook_input.g_names[index] not in hook_input.param_list:
                 continue
-            grad_dump(hook_input.dump_dir, hook_input.g_names[index], self.dump_step,
-                    grad_value, hook_input.level, hook_input.bounds)
+            conf = GradDumpConfig(dump_dir=hook_input.dump_dir, g_name=hook_input.g_names[index],
+                                  dump_step=self.dump_step, grad=grad_value, level=hook_input.level,
+                                  bounds=hook_input.bounds)
+            grad_dump(conf)
         ms.ops.TensorDump()(hook_input.step_finish_flag, self.dump_step)
         self.assignadd(self.dump_step, self.global_step_increase_tensor)
         out = hook_input.func(gradients)
@@ -57,11 +79,12 @@ def hook_graph_mode_optimizer(opt, hook_input):
     opt.construct = new_construct.__get__(opt, type(opt))
     csv_generator.start()
 
+
 def hook_pynative_optimizer(opt, hook_input):
     level_adapted = get_adapted_level(hook_input.level)
 
-    def hook_fn(cell, input):
-        gradients, = input
+    def hook_fn(cell, input_data):
+        gradients, = input_data
         cur_step = grad_context.get_context(GradConst.CURRENT_STEP)
         if grad_context.step_need_dump(cur_step) and grad_context.rank_need_dump(hook_input.rank_id):
             create_directory(hook_input.save_dir)

msprobe/mindspore/grad_probe/utils.py

@@ -1,12 +1,26 @@
+# 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.
+
 import os
 
 import mindspore
-from msprobe.core.grad_probe.constant import level_adp
-from msprobe.core.grad_probe.utils import check_param
 from msprobe.core.common.file_utils import (create_directory,
-                                            check_path_before_create,
                                             check_file_or_directory_path,
                                             save_npy)
+from msprobe.core.grad_probe.constant import level_adp
+from msprobe.core.grad_probe.utils import check_param
 
 
 def save_grad_direction(param_name, grad, save_path):
@@ -15,7 +29,6 @@ def save_grad_direction(param_name, grad, save_path):
     check_file_or_directory_path(save_path, isdir=True)
     check_param(param_name)
     save_filepath = os.path.join(save_path, f"{param_name}.npy")
-    check_path_before_create(save_filepath)
 
     if grad.dtype == mindspore.bfloat16:
         grad = grad.to(mindspore.float32)
@@ -27,4 +40,4 @@ def save_grad_direction(param_name, grad, save_path):
 
 def get_adapted_level(level: str):
     level_adapted = level_adp.get(level)
-    return level_adapted
+    return level_adapted

msprobe/mindspore/mindtorch/__init__.py

@@ -0,0 +1,18 @@
+# Copyright (c) 2025-2025, 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 .mindtorch_adaptor import (_call_impl,
+                                register_full_backward_pre_hook,
+                                register_full_backward_hook)