mindstudio-probe 8.3.2__py3-none-any.whl → 26.0.0a1__py3-none-any.whl

msprobe/core/{service.py → dump/service.py}

@@ -1,17 +1,18 @@
-# Copyright (c) 2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 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
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# 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.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import copy
 import functools
@@ -23,14 +24,15 @@ from msprobe.core.common.exceptions import DistributedNotInitializedError
 from msprobe.core.common.file_utils import create_directory
 from msprobe.core.common.runtime import Runtime
 from msprobe.core.common.utils import Const, print_tools_ends_info, DumpPathAggregation
-from msprobe.core.data_dump.api_registry import ApiRegistry
-from msprobe.core.data_dump.data_collector import build_data_collector
-from msprobe.core.kernel_dump.kernel_config import create_kernel_config_json
+from msprobe.core.dump.api_dump.api_registry import ApiRegistry
+from msprobe.core.dump.data_dump.data_collector import build_data_collector
+from msprobe.core.dump.kernel_dump.kernel_config import create_kernel_config_json
 from msprobe.core.common.megatron_utils import MegatronStepInfo
 
 
 class BaseService(ABC):
     def __init__(self, config):
+        self.bench_dump_iter_dir = None
         self.config = copy.deepcopy(config)
         self.config.level = getattr(config, 'level_ori', config.level)  # 兼容MindSpore配置
         self.model = None
@@ -47,7 +49,7 @@ class BaseService(ABC):
         self.hooked_modules = []
         self.ori_customer_func = {}
         self.debug_variable_counter = None
-        self.currrent_step_first_debug_save = True
+        self.current_step_first_debug_save = True
         self.logger = None  # 子类中注入
         self.api_register = None  # 子类中注入
         self.api_template = None  # 子类中注入
@@ -108,7 +110,7 @@ class BaseService(ABC):
         """修改JitDump开关，mindspore子类重写"""
         pass
 
-    def start(self, model=None, token_range=None):
+    def start(self, model=None, token_range=None, rank_id=None):
         """通用start模板"""
         self._process_iteration()
         if self._is_debug_level:
@@ -123,10 +125,13 @@ class BaseService(ABC):
         Runtime.is_running = True
         self.cur_token_id = 0
         if self.first_start:
-            try:
-                self.current_rank = self._get_current_rank()
-            except DistributedNotInitializedError:
-                self.current_rank = None
+            if rank_id is not None:
+                self.current_rank = rank_id
+            else:
+                try:
+                    self.current_rank = self._get_current_rank()
+                except DistributedNotInitializedError:
+                    self.current_rank = None
             Runtime.current_rank = self.current_rank
             if self._is_no_dump_rank:
                 Runtime.is_running = False
@@ -168,7 +173,7 @@ class BaseService(ABC):
             return
         self._process_async_dump()
         self.data_collector.write_json()
-        self.currrent_step_first_debug_save = True
+        self.current_step_first_debug_save = True
         self.loop += 1
         self._reset_status()
         MegatronStepInfo.reset()
@@ -188,7 +193,7 @@ class BaseService(ABC):
         if self._is_no_dump_step:
             return
 
-        if self.currrent_step_first_debug_save:
+        if self.current_step_first_debug_save:
             try:
                 self.current_rank = self._get_current_rank()
             except DistributedNotInitializedError:
@@ -196,7 +201,7 @@ class BaseService(ABC):
 
             self.create_dirs()
             self.debug_variable_counter = defaultdict(int)
-            self.currrent_step_first_debug_save = False
+            self.current_step_first_debug_save = False
 
         count = self.debug_variable_counter[name]
         self.debug_variable_counter[name] += 1
@@ -232,6 +237,11 @@ class BaseService(ABC):
         else:
             self.dump_iter_dir = os.path.join(self.config.dump_path, f"step{self.current_iter}")
 
+        if getattr(self.config, "bench_path", None):
+            self.bench_dump_iter_dir = os.path.join(self.config.bench_path, f"step{self.current_iter}")
+        else:
+            self.bench_dump_iter_dir = None
+
         cur_rank = self.current_rank if self.current_rank is not None else ''
         if self._is_l2_level:
             self._create_l2_dirs(cur_rank)
@@ -310,16 +320,21 @@ class BaseService(ABC):
 
     def _create_default_dirs(self, cur_rank):
         dump_dir = os.path.join(self.dump_iter_dir, f"rank{cur_rank}")
+        bench_dump_dir = None
+        if self.bench_dump_iter_dir:
+            bench_dump_dir = os.path.join(self.bench_dump_iter_dir, f"rank{cur_rank}")
         create_directory(dump_dir)
-
+        if bench_dump_dir:
+            create_directory(bench_dump_dir)
         dump_data_dir = None
         if self._need_tensor_data:
             dump_data_dir = os.path.join(dump_dir, "dump_tensor_data")
             create_directory(dump_data_dir)
 
-        self._configure_dump_paths(dump_dir, dump_data_dir)
+        self._configure_dump_paths(dump_dir, dump_data_dir, bench_dump_dir)
+
 
-    def _configure_dump_paths(self, dump_dir, dump_data_dir):
+    def _configure_dump_paths(self, dump_dir, dump_data_dir, bench_dump_dir):
         dump_path_aggregation = DumpPathAggregation()
         dump_path_aggregation.dump_file_path = os.path.join(dump_dir, "dump.json")
         dump_path_aggregation.stack_file_path = os.path.join(dump_dir, "stack.json")
@@ -327,7 +342,8 @@ class BaseService(ABC):
         dump_path_aggregation.dump_error_info_path = os.path.join(dump_dir, "dump_error_info.log")
         dump_path_aggregation.dump_tensor_data_dir = dump_data_dir
         dump_path_aggregation.debug_file_path = os.path.join(dump_dir, "debug.json")
-        dump_path_aggregation.free_benchmark_file_path = os.path.join(dump_dir, "free_benchmark.csv")
+        if bench_dump_dir:
+            dump_path_aggregation.bench_dump_file_path = os.path.join(bench_dump_dir, "dump.json")
         self.data_collector.update_dump_paths(dump_path_aggregation)
         self.data_collector.initialize_json_file(self._get_framework_type)
 

msprobe/core/install_deps/install_deps.py

@@ -0,0 +1,51 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+from msprobe.core.common.log import logger
+from msprobe.infer.offline.compare.msquickcmp.main import install_offline_deps_cli
+
+
+def _install_deps_parser(parser):
+    parser.add_argument("-m", "--mode", dest="mode", type=str,
+                        help="Install deps mode: 'offline' for offline_dump om and compare offline_model",
+                        required=True)
+    parser.add_argument("--no_check", dest="no_check", action="store_true",
+                        help="<optional> Whether to skip checking the target website's certificate information "
+                             "when installing dependency packages poses a certain security risk. "
+                             "This poses a certain security risk, "
+                             "and users should use it with caution and bear the consequences themselves.",
+                        required=False)
+
+
+MODE_DISPATCHER = {
+    'offline': install_offline_deps_cli
+}
+
+
+def install_deps_cli(args):
+    """
+    Dispatch install deps based on mode parameter
+    """
+    mode = getattr(args, "mode", None)
+    if not mode:
+        logger.error("No mode specified, please check.")
+    # Get the appropriate function based on mode
+    install_deps_func = MODE_DISPATCHER.get(mode)
+    if install_deps_func is None:
+        logger.error(f"Invalid install deps mode: '{mode}'. Available modes: {list(MODE_DISPATCHER.keys())}")
+        raise RuntimeError
+    # Execute the install_deps function
+    return install_deps_func(args)

msprobe/core/monitor/anomaly_processor.py

@@ -1,17 +1,19 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 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
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# 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.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
 import os
 import sys
 import math

msprobe/core/monitor/csv2db.py

@@ -1,17 +1,18 @@
-# Copyright (c) 2025-2026, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 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
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# 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.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import datetime
 import os
@@ -27,17 +28,10 @@ from msprobe.core.common.file_utils import (create_directory, read_csv,
                                             recursive_chmod, remove_path)
 from msprobe.core.common.log import logger
 from msprobe.core.common.utils import is_int
-from msprobe.core.monitor.db_utils import MonitorDB, update_ordered_dict
+from msprobe.core.monitor.db_utils import MonitorDB, update_ordered_dict, get_ordered_list
 from msprobe.core.monitor.utils import get_target_output_dir
 from tqdm import tqdm
 
-# Constants
-all_data_type_list = [
-    "actv", "actv_grad", "exp_avg", "exp_avg_sq",
-    "grad_unreduced", "grad_reduced", "param_origin", "param_updated", "other"
-]
-
-
 
 @dataclass
 class CSV2DBConfig:
@@ -48,7 +42,6 @@ class CSV2DBConfig:
     process_num: int = 1
     data_type_list: Optional[List[str]] = None
     output_dirpath: Optional[str] = None
-    step_partition: int = 500
 
 
 def validate_process_num(process_num: int) -> None:
@@ -59,26 +52,16 @@ def validate_process_num(process_num: int) -> None:
         raise ValueError(f"Maximum supported process_num is {MonitorConst.MAX_PROCESS_NUM}")
 
 
-def validate_step_partition(step_partition: int) -> None:
-    if not isinstance(step_partition, int):
-        raise TypeError("step_partition must be integer")
-    if not MonitorConst.MIN_PARTITION <= step_partition <= MonitorConst.MAX_PARTITION:
-        raise ValueError(
-            f"step_partition must be between {MonitorConst.MIN_PARTITION} ",
-            f"and {MonitorConst.MAX_PARTITION}, got {step_partition}"
-        )
-
-
 def validate_data_type_list(data_type_list: Optional[List[str]]) -> None:
     """Validate data type list parameter"""
     if data_type_list is None or not data_type_list:
-        logger.info(f"Using default data types: {all_data_type_list}")
+        logger.info(f"Using default data types: {MonitorConst.METRICS_TRENDVIS_SUPPORTED}")
         return
 
     if not isinstance(data_type_list, list):
         raise ValueError("data_type_list must be a list")
 
-    invalid_types = [t for t in data_type_list if t not in all_data_type_list]
+    invalid_types = [t for t in data_type_list if t not in MonitorConst.METRICS_TRENDVIS_SUPPORTED]
     if invalid_types:
         raise ValueError(f"Unsupported data types: {invalid_types}")
 
@@ -100,7 +83,7 @@ def _pre_scan_single_rank(rank: int, files: List[str]) -> Dict:
     min_step = None
     max_step = 0
     metric_stats = defaultdict(set)
-    targets = OrderedDict()
+    targets = defaultdict(OrderedDict)
 
     for file_path in files:
         file_name = os.path.basename(file_path)
@@ -128,16 +111,15 @@ def _pre_scan_single_rank(rank: int, files: List[str]) -> Dict:
                     f"CSV conversion failed | file={file_path}:{row_id+2} | error={str(e)}")
                 continue
             target = (name, vpp_stage, micro_step)
-            if target not in targets:
-                targets[target] = None
+            if target not in targets[metric_name]:
+                targets[metric_name][target] = None
 
     return {
         'max_rank': int(rank),
-        'metrics': metrics,
         'min_step': min_step,
         'max_step': max_step,
         'metric_stats': metric_stats,
-        'targets': list(targets.keys())
+        'targets': {metric_name: list(target_dict.keys()) for metric_name, target_dict in targets.items()}
     }
 
 
@@ -176,47 +158,59 @@ def _pre_scan(monitor_db: MonitorDB, data_dirs: Dict[int, str], data_type_list:
                 pbar.update(1)
 
     # Aggregate results
-    targets = OrderedDict()
-    metrics = set()
-    min_step = None
-    max_step = 0
-    max_rank = 0
-    metric_stats = defaultdict(set)
-
+    targets = defaultdict(OrderedDict)
+    all_stats = set()
+    global_stats = {
+        "min_step": None,
+        "max_step": 0,
+        "max_rank": 0
+    }
     for rank_result in results:
-        max_rank = max(max_rank, rank_result['max_rank'])
-        metrics.update(rank_result['metrics'])
-        min_step = min(
-            min_step if min_step is not None else rank_result['min_step'],
-            rank_result['min_step']
-        )
-        max_step = max(max_step, rank_result['max_step'])
+        global_stats["max_rank"] = max(global_stats["max_rank"], rank_result['max_rank'])
+        if global_stats["min_step"] is None:
+            global_stats["min_step"] = rank_result['min_step']
+        else:
+            global_stats["min_step"] = min(
+                global_stats["min_step"],
+                rank_result['min_step']
+            )
+        global_stats["max_step"] = max(global_stats["max_step"], rank_result['max_step'])
 
         for metric, stats in rank_result['metric_stats'].items():
-            metric_stats[metric].update(stats)
-
-        targets = update_ordered_dict(targets, rank_result['targets'])
-
-    monitor_db.insert_dimensions(
-        targets, metrics, metric_stats, min_step=min_step, max_step=max_step)
-    monitor_db.update_global_stats(
-        max_rank=max_rank, min_step=min_step, max_step=max_step)
-    return rank_files
+            if metric not in global_stats:
+                global_stats[metric] = set()
+            global_stats[metric].update(stats)
+            all_stats.update(stats)
+        for metric_name in rank_result['targets']:
+            targets[metric_name] = update_ordered_dict(
+                targets[metric_name], rank_result['targets'][metric_name])
+
+    monitor_db.insert_dimensions(targets)
+    monitor_db.init_global_stats_data(global_stats)
+    monitor_db.create_trend_data(
+        get_ordered_list(all_stats, MonitorConst.OP_MONVIS_SUPPORTED))
+    metric_id_dict = monitor_db.get_metric_mapping()
+    target_dict = monitor_db.get_target_mapping()
+    monitor_db.extract_tags_from_processed_targets(
+        targets, metric_id_dict, target_dict)
+    return rank_files, metric_id_dict, target_dict
 
 
 def process_single_rank(
     task: Tuple[int, List[str]],
     metric_id_dict: Dict[str, Tuple[int, List[str]]],
     target_dict: Dict[Tuple[str, int, int], int],
-    step_partition_size: int,
     db_path: str
 ) -> int:
     """Process data import for a single rank"""
     rank, files = task
-    db = MonitorDB(db_path, step_partition_size=step_partition_size)
+    db = MonitorDB(db_path)
     total_inserted = 0
-    table_batches = defaultdict(list)
-
+    batch_data = []
+    all_stats = get_ordered_list(
+        set().union(*[stats for _, stats in metric_id_dict.values()]),
+        MonitorConst.OP_MONVIS_SUPPORTED
+    )
     for file in files:
         filename = os.path.basename(file)
         metric_name, _, _ = get_info_from_filename(filename)
@@ -225,8 +219,7 @@ def process_single_rank(
         metric_info = metric_id_dict.get(metric_name)
         if not metric_info:
             continue
-
-        metric_id, stats = metric_info
+        metric_id, _ = metric_info
 
         for row_id, row in read_csv(file).iterrows():
             try:
@@ -239,33 +232,30 @@ def process_single_rank(
                     continue
 
                 step = int(row['step'])
-                table_name, _, _ = db.get_metric_table_name(metric_id, step)
                 # Prepare row data
-                row_data = [rank, step, target_id]
+                row_data = [rank, step, target_id, metric_id]
                 row_data.extend(
                     float(row[stat]) if stat in row else None
-                    for stat in stats
+                    for stat in all_stats
                 )
             except (ValueError, KeyError) as e:
                 logger.error(
                     f"CSV conversion failed | file={file}:{row_id+2} | error={str(e)}")
                 continue
 
-            table_batches[table_name].append(tuple(row_data))
+            batch_data.append(tuple(row_data))
             # Batch insert when threshold reached
-            if len(table_batches[table_name]) >= MonitorConst.BATCH_SIZE:
-                inserted = db.insert_rows(
-                    table_name, table_batches[table_name])
+            if len(batch_data) >= MonitorConst.BATCH_SIZE:
+                inserted = db.insert_rows(batch_data)
                 if inserted is not None:
                     total_inserted += inserted
-                table_batches[table_name] = []
+                batch_data = []
 
     # Insert remaining data
-    for table_name, batch in table_batches.items():
-        if batch:
-            inserted = db.insert_rows(table_name, batch)
-            if inserted is not None:
-                total_inserted += inserted
+    if batch_data:
+        inserted = db.insert_rows(batch_data)
+        if inserted is not None:
+            total_inserted += inserted
 
     logger.info(f"Rank {rank} inserted {total_inserted} rows")
     return total_inserted
@@ -275,20 +265,12 @@ def import_data(monitor_db: MonitorDB, data_dirs: Dict[int, str], data_type_list
     """Main method to import data into database"""
     # 1. Pre-scan to get rank tasks
     monitor_db.init_schema()
-    rank_tasks = _pre_scan(monitor_db, data_dirs, data_type_list, workers)
+    rank_tasks, metric_id_dict, target_dict = _pre_scan(monitor_db, data_dirs, data_type_list, workers)
     if not rank_tasks:
         logger.error("No valid data files found during pre-scan")
         return False
 
-    # 2. Get metric and target mappings
-    try:
-        metric_id_dict = monitor_db.get_metric_mapping()
-        target_dict = monitor_db.get_target_mapping()
-    except Exception as e:
-        logger.error(f"Failed to get database mappings: {str(e)}")
-        return False
-
-    # 3. Process data for each rank in parallel
+    # 2. Process data for each rank in parallel
     total_files = sum(len(files) for files in rank_tasks.values())
     logger.info(f"Starting data import for {len(rank_tasks)} ranks,"
                 f"{total_files} files..."
@@ -301,7 +283,6 @@ def import_data(monitor_db: MonitorDB, data_dirs: Dict[int, str], data_type_list
                 (rank, files),
                 metric_id_dict,
                 target_dict,
-                monitor_db.step_partition_size,
                 monitor_db.db_path): rank
             for rank, files in rank_tasks.items()
         }
@@ -323,7 +304,6 @@ def import_data(monitor_db: MonitorDB, data_dirs: Dict[int, str], data_type_list
 def csv2db(config: CSV2DBConfig) -> None:
     """Main function to convert CSV files to database"""
     validate_process_num(config.process_num)
-    validate_step_partition(config.step_partition)
     validate_data_type_list(config.data_type_list)
 
     target_output_dirs = get_target_output_dir(
@@ -342,12 +322,12 @@ def csv2db(config: CSV2DBConfig) -> None:
         remove_path(db_path)
         logger.warning(f"Existing path {db_path} will be recovered")
 
-    db = MonitorDB(db_path, step_partition_size=config.step_partition)
+    db = MonitorDB(db_path)
 
     result = import_data(
         db,
         target_output_dirs,
-        config.data_type_list if config.data_type_list else all_data_type_list,
+        config.data_type_list if config.data_type_list else MonitorConst.METRICS_TRENDVIS_SUPPORTED,
         workers=config.process_num
     )
     recursive_chmod(config.output_dirpath)