mindstudio-probe 1.0.4__py3-none-any.whl → 1.1.1__py3-none-any.whl

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,25 +1,37 @@
+# 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
 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
     '''
@@ -40,6 +52,7 @@ 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):
@@ -47,7 +60,7 @@ def hook_graph_mode_optimizer(opt, hook_input):
             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)
+                      grad_value, hook_input.level, hook_input.bounds)
         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 +70,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/ms_config.py

@@ -1,12 +1,26 @@
-import json
+# 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.common_config import CommonConfig, BaseConfig
-from msprobe.core.common.file_utils import FileOpen
 from msprobe.core.common.const import Const
-from msprobe.mindspore.common.const import FreeBenchmarkConst
-from msprobe.mindspore.common.log import logger
+from msprobe.core.common.file_utils import load_json
+from msprobe.core.common.utils import is_int
+from msprobe.core.common_config import BaseConfig, CommonConfig
 from msprobe.core.grad_probe.constant import level_adp
 from msprobe.core.grad_probe.utils import check_numeral_list_ascend
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+from msprobe.mindspore.common.log import logger
 
 
 class TensorConfig(BaseConfig):
@@ -18,9 +32,6 @@ class TensorConfig(BaseConfig):
         self._check_config()
 
     def _check_config(self):
-        if self.data_mode is not None and len(self.data_mode) > 0:
-            if len(self.data_mode) > 1 or self.data_mode[0] not in ["all", "input", "output"]:
-                raise Exception("data_mode must be all, input or output")
         if self.file_format and self.file_format not in ["npy", "bin"]:
             raise Exception("file_format is invalid")
 
@@ -34,9 +45,6 @@ class StatisticsConfig(BaseConfig):
         self._check_config()
 
     def _check_config(self):
-        if self.data_mode is not None and len(self.data_mode) > 0:
-            if len(self.data_mode) > 1 or self.data_mode[0] not in ["all", "input", "output"]:
-                raise Exception("data_mode must be all, input or output")
         if self.summary_mode and self.summary_mode not in ["statistics", "md5"]:
             raise Exception("summary_mode is invalid")
 
@@ -48,7 +56,7 @@ class OverflowCheckConfig(BaseConfig):
         self._check_config()
 
     def _check_config(self):
-        if self.overflow_nums is not None and not isinstance(self.overflow_nums, int):
+        if self.overflow_nums is not None and not is_int(self.overflow_nums):
             raise Exception("overflow_nums is invalid, it should be an integer")
         if self.overflow_nums is not None and self.overflow_nums != -1 and self.overflow_nums <= 0:
             raise Exception("overflow_nums should be -1 or positive integer")
@@ -72,7 +80,7 @@ class FreeBenchmarkConfig(BaseConfig):
         if self.fuzz_level and self.fuzz_level not in FreeBenchmarkConst.DUMP_LEVEL_LIST:
             raise Exception("fuzz_level must be L1 or empty")
         if self.fuzz_stage and self.fuzz_stage not in FreeBenchmarkConst.STAGE_LIST:
-            raise Exception("fuzz_stage must be forward or empty")
+            raise Exception("fuzz_stage must be forward, backward or empty")
         if self.if_preheat or self.preheat_step or self.max_sample:
             logger.warning("'if_preheat', 'preheat_step' and 'max_sample' settings "
                            "are not supported for mindspore free benchmark task.")
@@ -119,8 +127,7 @@ def parse_task_config(task, json_config):
 def parse_json_config(json_file_path):
     if not json_file_path:
         raise Exception("json file path is None")
-    with FileOpen(json_file_path, 'r') as file:
-        json_config = json.load(file)
+    json_config = load_json(json_file_path)
     common_config = parse_common_config(json_config)
     if not common_config.task:
         common_config.task = Const.STATISTICS

msprobe/mindspore/overflow_check/kernel_graph_overflow_check.py

@@ -1,8 +1,23 @@
+# 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 json
-from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+
+from msprobe.core.common.file_utils import create_directory, save_json
 from msprobe.mindspore.common.log import logger
-from msprobe.core.common.file_utils import FileOpen, create_directory
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
 
 
 class KernelGraphOverflowCheck:
@@ -16,7 +31,7 @@ class KernelGraphOverflowCheck:
         self.dump_json["common_dump_settings"]["saved_data"] = "full"
         self.dump_json["common_dump_settings"]["input_output"] = 0
         self.dump_json["common_dump_settings"]["kernels"] = []
-        self.dump_json["common_dump_settings"]["support_device"] = [0,1,2,3,4,5,6,7]
+        self.dump_json["common_dump_settings"]["support_device"] = [0, 1, 2, 3, 4, 5, 6, 7]
         self.dump_json["common_dump_settings"]["op_debug_mode"] = 3
         self.dump_json["common_dump_settings"]["file_format"] = "npy"
 
@@ -36,8 +51,7 @@ class KernelGraphOverflowCheck:
         json_path = self.dump_json["common_dump_settings"]["path"]
         create_directory(json_path)
         json_path = os.path.join(json_path, "kernel_graph_overflow_check.json")
-        with FileOpen(json_path, 'w') as f:
-            json.dump(self.dump_json, f)
+        save_json(json_path, self.dump_json, indent=4)
         logger.info(json_path + " has been created.")
         os.environ["MINDSPORE_DUMP_CONFIG"] = json_path
         if "MS_ACL_DUMP_CFG_PATH" in os.environ:

msprobe/mindspore/overflow_check/overflow_check_tool_factory.py

@@ -1,3 +1,18 @@
+# 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.overflow_check.kernel_graph_overflow_check import KernelGraphOverflowCheck

msprobe/mindspore/runtime.py

@@ -1,3 +1,18 @@
+# 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.
+
 class Runtime:
     step_count: int = 0
     rank_id: int = -1