mindspore 2.2.10__cp38-none-any.whl → 2.2.14__cp38-none-any.whl

mindspore/profiler/parser/framework_parser.py

@@ -768,7 +768,7 @@ class DynamicFrameWorkParser:
         rank_id (int): The rank ID.
     """
 
-    def __init__(self, output_path, rank_id):
+    def __init__(self, output_path, rank_id, pretty=False):
         """Initialization of parsing framework data."""
         self._output_path = output_path
         self._all_op_exe_time = defaultdict(list)
@@ -779,6 +779,12 @@ class DynamicFrameWorkParser:
         self._exe_time_and_shape_detail = defaultdict(dict)
         self._dynamic_shape_info = defaultdict(list)
         self._step = 0
+        self._pretty = pretty
+
+    @property
+    def indent(self):
+        indent = 1 if self._pretty else None
+        return indent
 
     def write_dynamic_shape_data(self, df_op_summary):
         """Analyze dynamic shape data and write to dynamic shape file."""
@@ -804,7 +810,7 @@ class DynamicFrameWorkParser:
         self._dynamic_shape_info['op_type'] = self._op_info.get("op_type")
         dynamic_shape_file_path = os.path.join(self._output_path, output_dynamic_shape_file_name)
         with os.fdopen(os.open(dynamic_shape_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as fp:
-            json.dump(self._dynamic_shape_info, fp)
+            json.dump(self._dynamic_shape_info, fp, indent=self.indent)
         os.chmod(dynamic_shape_file_path, stat.S_IREAD | stat.S_IWRITE)
 
     def _analyse_op_execute_time(self, op_summary):

mindspore/profiler/parser/memory_usage_parser.py

@@ -40,7 +40,7 @@ GIGABYTES = 1024 * 1024 * 1024
 class MemoryUsageParser:
     """MemoryUsageParser to parse memory raw data."""
 
-    def __init__(self, profiling_dir, device_id):
+    def __init__(self, profiling_dir, device_id, pretty=False):
         self._profiling_dir = profiling_dir
         self._device_id = device_id
         self._proto_file_path = 'memory_usage_{}.pb'
@@ -57,6 +57,12 @@ class MemoryUsageParser:
         }
         self._framework = {}
         self._points = {}
+        self._pretty = pretty
+
+    @property
+    def indent(self):
+        indent = 1 if self._pretty else None
+        return indent
 
     @staticmethod
     def _process_framework_info(aicore_detail_data):
@@ -164,7 +170,7 @@ class MemoryUsageParser:
 
         try:
             with os.fdopen(os.open(file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as json_file:
-                json.dump(content, json_file)
+                json.dump(content, json_file, indent=self.indent)
             os.chmod(file_path, stat.S_IREAD | stat.S_IWRITE)
         except (IOError, OSError) as err:
             logger.critical('Fail to write memory file.\n%s', err)

mindspore/profiler/parser/minddata_analyzer.py

@@ -41,7 +41,7 @@ class MinddataProfilingAnalyzer:
         ProfilerFileNotFoundException: If any of the MindData profiling input files do not exist.
     """
 
-    def __init__(self, source_dir, device_id, output_path='./'):
+    def __init__(self, source_dir, device_id, output_path='./', pretty=False):
         # Validate and save input parameters
         self._device_id = device_id
         self._source_dir = self._validate_directory(source_dir, 'Source directory')
@@ -55,6 +55,12 @@ class MinddataProfilingAnalyzer:
 
         # Save output filename
         self._save_path = self._get_save_path(output_path)
+        self._pretty = pretty
+
+    @property
+    def indent(self):
+        indent = 1 if self._pretty else None
+        return indent
 
     @property
     def save_path(self):
@@ -624,7 +630,7 @@ class MinddataProfilingAnalyzer:
 
         # Save summary output dictionary to JSON output file (format#1)
         with os.fdopen(os.open(self._save_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as save_file:
-            json.dump(summary_dict, save_file)
+            json.dump(summary_dict, save_file, indent=self.indent)
 
         os.chmod(self._save_path, stat.S_IREAD | stat.S_IWRITE)
 

mindspore/profiler/parser/minddata_parser.py

@@ -110,7 +110,7 @@ class MinddataParser:
                         input_path=os.path.join(source_path, "data"), file_name='DATA_PREPROCESS.dev.AICPUMI')
                     if not minddata_aicpu_source_path:
                         return
-        minddata_aicpu_output_path = os.path.join(output_path, "minddata_aicpu_" + device_id + ".txt")
+        minddata_aicpu_output_path = os.path.join(output_path, "minddata_aicpu_" + str(device_id) + ".txt")
         minddata_aicpu_data = MinddataParser.parse_minddata_aicpu_data(minddata_aicpu_source_path)
         if minddata_aicpu_data:
             fwrite_format(minddata_aicpu_output_path, " ".join(col_names), is_start=True)

mindspore/profiler/parser/msadvisor_analyzer.py

@@ -29,10 +29,11 @@ class Msadvisor:
     """
     The interface to call MSAdvisor(CANN) by command line.
     """
-    def __init__(self, job_id, rank_id, output_path):
+    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):
         """
@@ -75,6 +76,7 @@ class Msadvisor:
         """
         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)
+        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

@@ -36,7 +36,7 @@ class MsadvisorParser:
     Data format conversion for MSAdvisor AICPU model.
     """
 
-    def __init__(self, job_id, device_id, rank_id, output_path):
+    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
@@ -45,6 +45,12 @@ class MsadvisorParser:
         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):
@@ -199,7 +205,7 @@ class MsadvisorParser:
                         break
                     if tid > 1:
                         output_file.write(",")
-                    json.dump(op, output_file)
+                    json.dump(op, output_file, indent=self.indent)
 
     def write_aicpu(self):
         """
@@ -221,7 +227,7 @@ class MsadvisorParser:
                     if op.get("ts") > self._time_end:
                         break
                     output_file.write(",")
-                    json.dump(op, output_file)
+                    json.dump(op, output_file, indent=self.indent)
             output_file.write("]")
 
     def parse(self):

mindspore/profiler/profiling.py

@@ -20,6 +20,8 @@ import json
 import glob
 import subprocess
 import csv
+import socket
+import shutil
 from enum import Enum
 import numpy as np
 
@@ -53,7 +55,9 @@ from mindspore.profiler.parser.ascend_fpbp_generator import AscendFPBPGenerator
 from mindspore.profiler.parser.ascend_op_generator import AscendOPGenerator
 from mindspore.profiler.parser.ascend_steptrace_generator import AscendStepTraceGenerator
 from mindspore.profiler.parser.ascend_flops_generator import AscendFlopsGenerator
+from mindspore.profiler.parser.ascend_cluster_generator import AscendClusterGenerator
 from mindspore.profiler.parser.ascend_hccl_generator import AscendHCCLGenerator, AscendHCCLGeneratorOld
+from mindspore.profiler.parser.ascend_communicate_generator import AscendCommunicationGenerator
 
 INIT_OP_NAME = 'Default/InitDataSetQueue'
 
@@ -460,6 +464,7 @@ class Profiler:
         self._dynamic_status = False
         self._profile_framework = "all"
         self._msprof_enable = os.getenv("PROFILER_SAMPLECONFIG")
+        self._pretty_json = False
         if self._msprof_enable:
             return
         self._start_time = int(time.time() * 1000000)
@@ -467,9 +472,7 @@ class Profiler:
         if kwargs.get("env_enable"):
             self._profiler_init(kwargs)
             return
-        if Profiler._has_initialized:
-            msg = "Do not init twice in the profiler."
-            raise RuntimeError(msg)
+
         Profiler._has_initialized = True
         # get device_id and device_target
         self._get_devid_rankid_and_devtarget()
@@ -527,6 +530,9 @@ class Profiler:
             dev_info = info_dict.get("DeviceInfo", [])
             dev_id = dev_info[0].get("id", -1)
 
+            if int(rank_id) < 0:
+                rank_id = 0
+
             return str(rank_id), str(dev_id)
 
     def op_analyse(self, op_name, device_id=None):
@@ -594,7 +600,7 @@ class Profiler:
                 return message
         return op_info
 
-    def analyse(self, offline_path=None):
+    def analyse(self, offline_path=None, pretty=False):
         """
         Collect and analyze training performance data, support calls during and after training. The example shows above.
 
@@ -602,7 +608,9 @@ class Profiler:
             offline_path (Union[str, None], optional): The data path which need to be analysed with offline mode.
                 Offline mode isused in abnormal exit scenario. This parameter should be set to ``None``
                 for online mode. Default: ``None``.
+            pretty (bool, optional): Whether to pretty json files. Default: ``False``.
         """
+        self._pretty_json = pretty
         self._analyse(offline_path=offline_path)
 
     def _analyse(self, offline_path=None, model_iteration_dict=None):
@@ -643,8 +651,6 @@ class Profiler:
         self._dynamic_status = self._profiler_manager.dynamic_status()
         _environment_check()
 
-        self._cpu_profiler.stop()
-
         cpu_op_file = glob.glob(os.path.join(self._output_path, 'cpu_op_type_info_*'))
         if self._device_target and self._device_target != DeviceTarget.CPU.value and cpu_op_file:
             self._is_heterogeneous = True
@@ -673,7 +679,6 @@ class Profiler:
 
         Raises:
             RuntimeError: If the profiler has already started.
-            RuntimeError: If MD profiling has stopped, repeated start action is not supported.
             RuntimeError: If the `start_profile` parameter is not set or is set to ``True``.
 
         Examples:
@@ -707,13 +712,8 @@ class Profiler:
         if not self._has_started:
             if not self._has_started_twice:
                 self._has_started = True
-                self._has_started_twice = True
-            else:
-                raise RuntimeError("MindSpore Profiling has finished, repeated start and stop actions are not "
-                                   "supported.")
         else:
-            raise RuntimeError("The profiler has already started. Use profiler.start() only when start_profile value "
-                               "is set to False.")
+            raise RuntimeError("The profiler has already started. Do not turn on again in the open state.")
 
         # No need to start anything if parse profiling data offline
         if self._is_offline_parser():
@@ -785,7 +785,8 @@ class Profiler:
         # Stop data collection after all operators are executed.
         _pynative_executor.sync()
 
-        if self._data_process:
+        self._cpu_profiler.stop()
+        if self._data_process and self._md_profiler is not None:
             self._md_profiler.stop()
             self._md_profiler.save(self._output_path)
 
@@ -962,9 +963,6 @@ class Profiler:
         if self._profile_communication:
             hccl_option = {"output": self._output_path, "task_trace": "on"}
             os.environ['PROFILING_OPTIONS'] = json.dumps(hccl_option)
-            if not self.start_profile:
-                raise RuntimeError(f"For '{self.__class__.__name__}', the parameter profile_communication can "
-                                   f"not be True while starting profiler in the process of training.")
 
         self._profile_memory = kwargs.pop("profile_memory", False)
         if not isinstance(self._profile_memory, bool):
@@ -1060,7 +1058,8 @@ class Profiler:
         # Analyze minddata information
         logger.info("Profiling: analyzing the minddata information.")
         try:
-            MinddataProfilingAnalyzer(self._output_path, store_id, self._output_path).analyze()
+            MinddataProfilingAnalyzer(self._output_path, store_id,
+                                      self._output_path, pretty=self._pretty_json).analyze()
         except ProfilerException as err:
             logger.warning(err.message)
         finally:
@@ -1080,7 +1079,7 @@ class Profiler:
 
             step_trace_point_info_path = validate_and_normalize_path(step_trace_point_info_path)
 
-            fpbp_analyse = AscendFPBPGenerator(op_summary, steptrace)
+            fpbp_analyse = AscendFPBPGenerator(op_summary, steptrace, pretty=self._pretty_json)
             points, _ = fpbp_analyse.parse()
             fpbp_analyse.write(step_trace_point_info_path)
         except ProfilerException as err:
@@ -1149,7 +1148,7 @@ class Profiler:
             logger.info("Profiling: analyzing the timeline data")
             timeline_analyser = AscendTimelineGenerator(self._output_path, self._dev_id, self._rank_id, self._rank_size,
                                                         context.get_context('mode'))
-            timeline_analyser.init_timeline(op_summary, steptrace)
+            timeline_analyser.init_timeline(op_summary, steptrace, pretty=self._pretty_json)
             timeline_analyser.write_timeline(self._timeline_size_limit_byte)
             timeline_analyser.write_timeline_summary()
         except (ProfilerIOException, ProfilerFileNotFoundException, RuntimeError) as err:
@@ -1166,7 +1165,7 @@ class Profiler:
             logger.warning("The profile_memory parameter cannot be set on the dynamic shape network.")
         logger.warning(
             "[Profiler]Dynamic Shape network does not support collecting step trace performance data currently.")
-        dynamic_parser = DynamicFrameWorkParser(self._output_path, self._rank_id)
+        dynamic_parser = DynamicFrameWorkParser(self._output_path, self._rank_id, pretty=self._pretty_json)
         dynamic_parser.write_dynamic_shape_data(op_summary)
 
     def _ascend_flops_analyse(self, op_summary):
@@ -1184,7 +1183,7 @@ class Profiler:
             flops_path = validate_and_normalize_path(flops_path)
             flops_summary_path = validate_and_normalize_path(flops_summary_path)
 
-            flops_analyser = AscendFlopsGenerator(op_summary)
+            flops_analyser = AscendFlopsGenerator(op_summary, pretty=self._pretty_json)
             flops_analyser.parse()
             flops_analyser.write(flops_path, flops_summary_path)
 
@@ -1208,6 +1207,73 @@ class Profiler:
         finally:
             pass
 
+    def _ascend_ms_analyze(self, source_path):
+        """Ascend ms generate"""
+        time_stamp = time.strftime("%Y%m%d%H%M%S", time.localtime(time.time()))
+        if self._rank_id:
+            ascend_ms_path = f"rank-{self._rank_id}_{time_stamp}_ascend_ms"
+        else:
+            ascend_ms_path = f"{socket.gethostname()}--{os.getpid()}_{time_stamp}_ascend_ms"
+        self._ascend_ms_path = os.path.join(self._output_path, ascend_ms_path)
+        if not os.path.exists(self._ascend_ms_path):
+            os.makedirs(self._ascend_ms_path, exist_ok=True)
+            os.chmod(self._ascend_ms_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
+
+        dev_id = self._rank_id if self._device_target == DeviceTarget.ASCEND.value else self._dev_id
+        ascend_profiler_output_path = os.path.join(self._ascend_ms_path, 'ASCEND_PROFILER_OUTPUT')
+        os.makedirs(ascend_profiler_output_path, exist_ok=True)
+
+        source_profiler_info_path = os.path.join(self._output_path, f"profiler_info_{dev_id}.json")
+        target_profiler_info_path = os.path.join(self._ascend_ms_path, f"profiler_info_{dev_id}.json")
+        shutil.copy(source_profiler_info_path, target_profiler_info_path)
+
+        source_timeline_path = os.path.join(self._output_path, f"ascend_timeline_display_{dev_id}.json")
+        target_timeline_path = os.path.join(ascend_profiler_output_path, f"trace_view.json")
+        shutil.copy(source_timeline_path, target_timeline_path)
+
+        self._ascend_graph_cluster_analyse(source_path, ascend_profiler_output_path)
+        self._ascend_graph_communicate_analyse(source_path, ascend_profiler_output_path)
+
+    def _ascend_graph_cluster_analyse(self, source_path, ascend_profiler_output_path):
+        """Analyse step trace time info"""
+
+        try:
+            logger.info("Profiling: analyzing the step trace time profiler info.")
+
+            step_trace_time_path = os.path.join(ascend_profiler_output_path, f'step_trace_time.csv')
+            step_trace_time_path = validate_and_normalize_path(step_trace_time_path)
+
+            cluster_analyse = AscendClusterGenerator(os.path.join(source_path, 'timeline'))
+            cluster_analyse.parse()
+            cluster_analyse.write(step_trace_time_path)
+        except (ProfilerIOException, ProfilerFileNotFoundException, ProfilerRawFileException) as err:
+            logger.warning(err.message)
+        finally:
+            pass
+
+    def _ascend_graph_communicate_analyse(self, source_path, ascend_profiler_output_path):
+        """Analyse communicate info"""
+        if not self._profile_communication:
+            return
+
+        try:
+            logger.info("Profiling: analyzing the communicate and communicate_matrix profiler info.")
+
+            communication_file_path = os.path.join(ascend_profiler_output_path, f'communication.json')
+            communication_file_path = validate_and_normalize_path(communication_file_path)
+
+            communication_matrix_file_path = os.path.join(ascend_profiler_output_path, f"communication_matrix.json")
+            communication_matrix_file_path = validate_and_normalize_path(communication_matrix_file_path)
+
+            analyze_path = os.path.join(os.path.dirname(source_path), 'analyze')
+            communicate_analyser = AscendCommunicationGenerator(analyze_path)
+            communicate_analyser.parse()
+            communicate_analyser.write(communication_file_path, communication_matrix_file_path)
+        except (ProfilerIOException, ProfilerFileNotFoundException, ProfilerRawFileException) as err:
+            logger.warning(err.message)
+        finally:
+            pass
+
     def _ascend_graph_hccl_analyse(self, source_path, steptrace, flag):
         """Analyse hccl profiler info."""
         if not self._profile_communication:
@@ -1237,7 +1303,7 @@ class Profiler:
     def _ascend_graph_msadvisor_analyse(self, job_id):
         """Call MSAdvisor function."""
         logger.info("MSAdvisor starts running.")
-        msadvisor = Msadvisor(job_id, self._rank_id, self._output_path)
+        msadvisor = Msadvisor(job_id, self._rank_id, self._output_path, pretty=self._pretty_json)
         try:
             msadvisor.analyse()
         except FileNotFoundError as err:
@@ -1283,6 +1349,7 @@ class Profiler:
                 self._ascend_dynamic_net_analyse(op_summary)
             self._ascend_flops_analyse(op_summary)
             self._ascend_graph_memory_analyse(points)
+            self._ascend_ms_analyze(source_path)
             self._ascend_graph_hccl_analyse(source_path, steptrace, flag)
             self._ascend_graph_msadvisor_analyse(job_id)
             ProfilerInfo.set_graph_ids(graph_ids)
@@ -1368,11 +1435,15 @@ class Profiler:
 
     def _cpu_analyse(self):
         """Collect and analyse cpu performance data."""
+        if self._has_started:
+            self.stop()
+        else:
+            logger.info("No need to stop profiler because profiler has been stopped or profiler has not been started.")
         if not self._op_time:
             return
         try:
             timeline_generator = CpuTimelineGenerator(self._output_path, self._rank_id, context.get_context("mode"))
-            timeline_generator.init_timeline()
+            timeline_generator.init_timeline(pretty=self._pretty_json)
             timeline_generator.write_timeline(self._timeline_size_limit_byte)
             timeline_generator.write_timeline_summary()
         except (ProfilerIOException, ProfilerFileNotFoundException, RuntimeError) as err:
@@ -1462,7 +1533,7 @@ class Profiler:
         """Analyse memory usage data."""
         integrator = Integrator(self._output_path, self._rank_id)
         aicore_detail_data = integrator.get_aicore_detail_data()
-        memory_parser = MemoryUsageParser(self._output_path, self._rank_id)
+        memory_parser = MemoryUsageParser(self._output_path, self._rank_id, pretty=self._pretty_json)
         memory_parser.init_memory_usage_info(aicore_detail_data, points)
         memory_parser.write_memory_files()
 
@@ -1630,6 +1701,7 @@ class Profiler:
         else:
             output_path = kwargs.pop("output_path")
             self._output_path = validate_and_normalize_path(output_path)
+
         self._output_path = os.path.join(self._output_path, "profiler")
         if not os.path.exists(self._output_path):
             os.makedirs(self._output_path, exist_ok=True)

mindspore/rewrite/api/node.py

@@ -283,7 +283,7 @@ class Node:
             >>> dst_node = stree.get_node("relu_3")
             >>> dst_node.set_arg_by_node(0, src_node, 0)
             >>> print(dst_node.get_args())
-            [fc1]
+            [fc1_var]
         """
         Validator.check_value_type("arg_idx", arg_idx, [int], "Node")
         Validator.check_value_type("src_node", src_node, [Node], "Node")

mindspore/rewrite/api/symbol_tree.py

@@ -168,8 +168,8 @@ class SymbolTree:
             >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
             >>> print([node.get_name() for node in stree.nodes()])
-            ['input_x', 'Expr', 'conv1', 'relu', 'max_pool2d', 'conv2', 'relu_1', 'max_pool2d_1',
-             'flatten', 'fc1', 'relu_2', 'fc2', 'relu_3', 'fc3', 'return']
+            ['input_x', 'Expr', 'conv1', 'relu', 'max_pool2d', 'conv2', 'relu_1', 'max_pool2d_1', 'attribute_assign',
+             'unaryop_not', 'if_node', 'flatten', 'fc1', 'relu_2', 'fc2', 'relu_3', 'fc3', 'return_1']
         """
         Validator.check_value_type("all_nodes", all_nodes, [bool], "nodes")
         nodes = self._symbol_tree.all_nodes() if all_nodes else self._symbol_tree.nodes()

mindspore/rewrite/parsers/for_parser.py

@@ -72,7 +72,7 @@ class ForParser(Parser):
             return
         iter_code = astunparse.unparse(node.iter)
         if not iter_code.startswith(EVAL_WHITE_LIST):
-            logger.warning(
+            logger.info(
                 f"For MindSpore Rewrtie, illegal iteration condition for For node, it must start with{EVAL_WHITE_LIST}")
             return
         if "self" in iter_code:
@@ -82,7 +82,7 @@ class ForParser(Parser):
         except (NameError, TypeError) as e:
             _info = f"For MindSpore Rewrtie, when eval '{iter_code}' by using JIT Fallback feature, " \
                          f"an error occurred: {str(e)}"
-            logger.warning(_info)
+            logger.info(_info)
             stree.try_append_python_node(node, node, node_manager)
             return
 
@@ -115,13 +115,13 @@ class ForParser(Parser):
                 stree.on_change(Event.CodeChangeEvent)
             return
         if isinstance(iter_obj, range):
-            logger.warning("For MindSpore Rewrite, range not support.")
+            logger.info("For MindSpore Rewrite, range not support.")
         elif isinstance(iter_obj, zip):
-            logger.warning("For MindSpore Rewrite, zip not support.")
+            logger.info("For MindSpore Rewrite, zip not support.")
         elif isinstance(iter_obj, enumerate):
-            logger.warning("For MindSpore Rewrite, enumerate not support.")
+            logger.info("For MindSpore Rewrite, enumerate not support.")
         else:
-            logger.warning(f"For MindSpore Rewrite, not supported type: {type(iter_obj).__name__}")
+            logger.info(f"For MindSpore Rewrite, not supported type: {type(iter_obj).__name__}")
         stree.try_append_python_node(node, node, node_manager)
         return
 

mindspore/rewrite/parsers/module_parser.py

@@ -170,15 +170,15 @@ class ModuleParser(Parser):
                 level_count += 1
                 continue
             except Exception as e: # pylint: disable=W0703
-                logger.warning(f"For MindSpore Rewrite, in module parser, process import code: "
-                               f"{import_code} failed: {e}. Ignore this import code.")
+                logger.info(f"For MindSpore Rewrite, in module parser, process import code: "
+                            f"{import_code} failed: {e}. Ignore this import code.")
                 return None, None
             else:
                 # try test code success
                 return import_node_test.module, file_path_tmp
         # try codes with all level failed
-        logger.warning(f"For MindSpore Rewrite, in module parser, test import code: "
-                       f"{astunparse.unparse(import_node).strip()} failed. Ignore this import code.")
+        logger.info(f"For MindSpore Rewrite, in module parser, test import code: "
+                    f"{astunparse.unparse(import_node).strip()} failed. Ignore this import code.")
         return None, None
 
     @staticmethod

mindspore/scipy/ops.py

@@ -1,4 +1,4 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
+# Copyright 2021-2023 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.
@@ -156,14 +156,64 @@ class LU(PrimitiveWithInfer):
 
 
 class LinearSumAssignment(Primitive):
-    """Solve the linear sum assignment problem."""
+    r"""
+    Solve the linear sum assignment problem.
+
+    The assignment problem is represented as follows:
+
+    .. math::
+        min\sum_{i}^{} \sum_{j}^{} C_{i,j} X_{i,j}
+
+    where :math:`C` is cost matrix, :math:`X_{i,j} = 1` means column :math:`j` is assigned to row :math:`i` .
+
+    Inputs:
+        - **cost_matrix** (Tensor) - 2-D cost matrix. Tensor of shape :math:`(M, N)` .
+        - **dimension_limit** (Tensor, optional) - A scalar used to limit the actual size of the 2nd dimension of
+          ``cost_matrix``. Default is ``Tensor(sys.maxsize)``, which means no limitation. The type is 0-D int64
+          Tensor.
+        - **maximize** (bool) - Calculate a maximum weight matching if true, otherwise calculate a minimum weight
+          matching.
+
+    Outputs:
+        A tuple of tensors containing 'row_idx' and 'col_idx'.
+
+        - **row_idx** (Tensor) - Row indices of the problem. If `dimension_limit` is given, -1 would be padded at the
+          end. The shape is  :math:`(N, )` , where :math:`N` is the minimum value of `cost_matrix` dimension.
+        - **col_idx** (Tensor) - Column indices of the problem. If `dimension_limit` is given, -1 would be padded at
+          the end. The shape is  :math:`(N, )` , where :math:`N` is the minimum value of `cost_matrix` dimension.
+
+     Raises:
+        TypeError: If the data type of `cost_matrix` is not the type in [float16, float32, float64,
+                   int8, int16, int32, int64, uint8, uint16, uint32, uint64, bool]
+        TypeError: If the type of `maximize` is not bool.
+        TypeError: If the data type of `dimension_limit` is not int64.
+        ValueError: If the rank of `cost_matrix` is not 2.
+        ValueError: If the number of input args is not 3.
+
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore.scipy.ops import LinearSumAssignment
+        >>> lsap = LinearSumAssignment()
+        >>> cost_matrix = Tensor(np.array([[2, 3, 3], [3, 2, 3], [3, 3, 2]])).astype(ms.float64)
+        >>> dimension_limit = Tensor(2)
+        >>> maximize = False
+        >>> a, b = lsap(cost_matrix, dimension_limit, maximize)
+        >>> print(a)
+        [0 1 -1]
+        >>> print(b)
+        [0 1 -1]
+    """
 
     @prim_attr_register
     def __init__(self):
-        super().__init__("LinearSumAssignment")
+        super().__init__(name="LinearSumAssignment")
         self.init_prim_io_names(inputs=['cost_matrix', 'dimension_limit', 'maximize'], outputs=['row_ind', 'col_ind'])
-        self.add_prim_attr("cust_aicpu", "mindspore_aicpu_kernels")
-
 
 # pylint: disable=C0413,W0611
 from .ops_grad import get_bprpo_eigh, get_bprpo_trsm

mindspore/scipy/optimize/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
+# Copyright 2021-2023 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.
@@ -15,5 +15,6 @@
 """Optimize submodule"""
 from .minimize import minimize
 from .line_search import line_search
+from .linear_sum_assignment import linear_sum_assignment
 
-__all__ = ["minimize", "line_search"]
+__all__ = ["minimize", "line_search", "linear_sum_assignment"]