mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/parallel/algo_parameter_config.py

@@ -53,7 +53,7 @@ class _AlgoParameterConfig:
     def set_fully_use_devices(self, not_fully):
         """
         Set the flag of whether only generating strategies that fully use all available devices.
-        Default: True
+        Default: ``True``
 
         Args:
             not_fully (bool): The flag.
@@ -141,7 +141,7 @@ class _AlgoParameterConfig:
     def set_dp_algo_enable_approxi(self, enable_flag):
         """
         Set the flag of whether to enable the approximation in the DP algorithms.
-        Default: False.
+        Default: ``False``.
 
         Args:
             enable_flag (bool): The flag.
@@ -229,35 +229,119 @@ def set_algo_parameters(**kwargs):
     """
     Set parameters in the algorithm for parallel strategy searching. See a typical use in
     `test_auto_parallel_resnet.py
-    <https://gitee.com/mindspore/mindspore/blob/r2.0/tests/ut/python/parallel/test_auto_parallel_resnet.py>`_.
+    <https://gitee.com/mindspore/mindspore/blob/r2.2/tests/ut/python/parallel/test_auto_parallel_resnet.py>`_.
 
     Note:
         The attribute name is required. This interface works ONLY in AUTO_PARALLEL mode.
 
     Args:
         fully_use_devices (bool): Whether ONLY searching strategies that fully use all available devices.
-            Default: True. For example with 8 devices available, if set true, strategy (4, 1) will not be included
-            in ReLU's candidate strategies, because strategy (4, 1) only utilizes 4 devices.
+            Default: ``True`` . For example with 8 devices available, if set ``True`` , strategy (4, 1) will not be
+            included in ReLU's candidate strategies, because strategy (4, 1) only utilizes 4 devices.
         elementwise_op_strategy_follow (bool): Whether the elementwise operator has the consistent strategies as its
-            subsequent operators. Default: False. For the example of ReLU followed by Add, where ReLU is elementwise
-            operator, if this flag is set true, then the searched strategy by the algorithm guarantees that strategies
-            of these two operators are consistent, e.g., ReLU's strategy (8, 1) and Add's strategy ((8, 1), (8, 1)).
-        enable_algo_approxi (bool): Whether to enable the approximation in the algorithms. Default: False. Due to large
-            solution space in searching parallel strategy for large DNN model, the algorithm takes fairly long time in
-            this case. To mitigate it, if this flag is set true, an approximation is made to discard some candidate
-            strategies, so that the solution space is shrunken.
-        algo_approxi_epsilon (float): The epsilon value used in the approximation algorithm. Default: 0.1. This value
-            describes the extent of approximation. For example, the number of candidate strategies of an operator is S,
-            if 'enable_algo_approxi' is true, then the remaining strategies is of size: min{S, 1/epsilon}.
-        tensor_slice_align_enable (bool): Whether to check the shape of tensor slice of MatMul. Default: False. Due to
-            properties of some hardware, MatMul kernel only with large shapes can show advantages. If this flag is true,
-            then the slice shape of MatMul is checked to prevent irregular shapes.
+            subsequent operators. Elementwise operators refer to operators that operate on input element by element,
+            such as Add, ReLU, etc. Default: ``False`` . For the example of ReLU followed by Add, if this flag is set
+            ``True`` , then the searched strategy by the algorithm guarantees that strategies of these two operators
+            are consistent, e.g., ReLU's strategy (8, 1) and Add's strategy ((8, 1), (8, 1)).
+        enable_algo_approxi (bool): Whether to enable the approximation in the algorithms. Default: ``False`` . Due to
+            large solution space in searching parallel strategy for large DNN model, the algorithm takes fairly long
+            time in this case. To mitigate it, if this flag is set ``True`` , an approximation is made to discard some
+            candidate strategies, so that the solution space is shrunken.
+        algo_approxi_epsilon (float): The epsilon value used in the approximation algorithm. Default: ``0.1`` . This
+            value describes the extent of approximation. For example, the number of candidate strategies of an operator
+            is S, if 'enable_algo_approxi' is ``True`` , then the remaining strategies is of size: min{S, 1/epsilon}.
+        tensor_slice_align_enable (bool): Whether to check the shape of tensor slice of MatMul. Default: ``False`` .
+            Due to properties of some hardware, MatMul kernel only with large shapes can show advantages. If this flag
+            is ``True`` , then the slice shape of MatMul is checked to prevent irregular shapes.
         tensor_slice_align_size (int): The minimum tensor slice shape of MatMul, the value must be in [1, 1024].
-            Default: 16. If 'tensor_slice_align_enable' is set true, then the slice size of last dimension of MatMul
-            tensors should be multiple of this value.
+            Default: ``16`` . If 'tensor_slice_align_enable' is set ``True`` , then the slice size of last dimension of
+            MatMul tensors should be multiple of this value.
 
     Raises:
         ValueError: If context keyword is not recognized.
+
+    Examples:
+        .. note::
+            Before running the following examples, you need to configure the communication environment variables.
+
+            For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
+            Please see the `rank table startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/rank_table.html>`_
+            for more details.
+
+            For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/mpirun.html>`_ .
+
+            For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
+            Startup <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/dynamic_cluster.html>`_ .
+
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> import mindspore.dataset as ds
+        >>> from mindspore import nn, ops, train
+        >>> from mindspore.communication import init
+        >>> from mindspore.common.initializer import initializer
+        >>>
+        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> ms.set_auto_parallel_context(parallel_mode=ms.ParallelMode.AUTO_PARALLEL,
+        >>>                              search_mode="sharding_propagation")
+        >>> init()
+        >>> ms.set_algo_parameters(fully_use_devices=True)
+        >>> ms.set_algo_parameters(elementwise_op_strategy_follow=True)
+        >>> ms.set_algo_parameters(enable_algo_approxi=True)
+        >>> ms.set_algo_parameters(algo_approxi_epsilon=0.2)
+        >>> ms.set_algo_parameters(tensor_slice_align_enable=True)
+        >>> ms.set_algo_parameters(tensor_slice_align_size=8)
+        >>>
+        >>> # Define the network structure.
+        >>> class Dense(nn.Cell):
+        ...     def __init__(self, in_channels, out_channels):
+        ...         super().__init__()
+        ...         self.weight = ms.Parameter(initializer("normal", [in_channels, out_channels], ms.float32))
+        ...         self.bias = ms.Parameter(initializer("normal", [out_channels], ms.float32))
+        ...         self.matmul = ops.MatMul()
+        ...         self.add = ops.Add()
+        ...
+        ...     def construct(self, x):
+        ...         x = self.matmul(x, self.weight)
+        ...         x = self.add(x, self.bias)
+        ...         return x
+        >>>
+        >>> class FFN(nn.Cell):
+        ...     def __init__(self):
+        ...         super().__init__()
+        ...         self.flatten = ops.Flatten()
+        ...         self.dense1 = Dense(28*28, 64)
+        ...         self.relu = ops.ReLU()
+        ...         self.dense2 = Dense(64, 10)
+        ...
+        ...     def construct(self, x):
+        ...         x = self.flatten(x)
+        ...         x = self.dense1(x)
+        ...         x = self.relu(x)
+        ...         x = self.dense2(x)
+        ...         return x
+        >>> net = FFN()
+        >>> net.dense1.matmul.shard(((2, 1), (1, 2)))
+        >>>
+        >>> # Create dataset.
+        >>> step_per_epoch = 16
+        >>> def get_dataset(*inputs):
+        ...     def generate():
+        ...         for _ in range(step_per_epoch):
+        ...             yield inputs
+        ...     return generate
+        >>>
+        >>> input_data = np.random.rand(1, 28, 28).astype(np.float32)
+        >>> label_data = np.random.rand(1).astype(np.int32)
+        >>> fake_dataset = get_dataset(input_data, label_data)
+        >>> dataset = ds.GeneratorDataset(fake_dataset, ["input", "label"])
+        >>> # Train network.
+        >>> optimizer = nn.Momentum(net.trainable_params(), 1e-3, 0.1)
+        >>> loss_fn = nn.CrossEntropyLoss()
+        >>> loss_cb = train.LossMonitor()
+        >>> model = ms.Model(network=net, loss_fn=loss_fn, optimizer=optimizer)
+        >>> model.train(epoch=2, train_dataset=dataset, callbacks=[loss_cb])
     """
     for key, value in kwargs.items():
         if key not in set_algo_parameters_config_func_map:
@@ -277,12 +361,18 @@ def get_algo_parameters(attr_key):
         attr_key (str): The key of the attribute. The keys include: "fully_use_devices",
             "elementwise_op_strategy_follow", "enable_algo_approxi", "algo_approxi_epsilon",
             "tensor_slice_align_enable","tensor_slice_align_size".
+            See :func:`mindspore.set_algo_parameters` for more details about the meaning of the attributes.
 
     Returns:
         Return attribute value according to the key.
 
     Raises:
         ValueError: If context keyword is not recognized.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.get_algo_parameters("fully_use_devices")
+        True
     """
     if attr_key not in get_algo_parameters_config_func_map:
         raise ValueError("Get context keyword %s is not recognized!" % attr_key)
@@ -304,5 +394,9 @@ def reset_algo_parameters():
     - algo_approxi_epsilon: 0.1.
     - tensor_slice_align_enable: False.
     - tensor_slice_align_size: 16.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.reset_algo_parameters()
     """
     _algo_parameter_config().reset_algo_parameters()

mindspore/parallel/checkpoint_transform.py

@@ -35,8 +35,7 @@ def merge_pipeline_strategys(src_strategy_dirs, dst_strategy_file):
     """
     Merge parallel strategy between all pipeline stages in pipeline parallel mode.
     For more details about converting distributed Checkpoint, please refer to
-    `Distributed Resilience Training and
-    Inference <https://www.mindspore.cn/tutorials/experts/en/r2.0/parallel/resilience_train_and_predict.html>`_.
+    `Model Transformation <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/model_transformation.html>`_.
 
     Note:
         Strategy file of each pipeline stage should be included in src_strategy_dirs.
@@ -50,8 +49,9 @@ def merge_pipeline_strategys(src_strategy_dirs, dst_strategy_file):
         NotADirectoryError: `src_strategy_dirs` is not a directory.
 
     Examples:
+        >>> import mindspore ms
         >>> # src_strategy_dir/stra0.ckpt, src_strategy_dir/stra1.ckpt ... src_strategy_dir/stra127.ckpt
-        >>> merge_pipeline_strategys("./src_strategy_dir", "./dst_strategy.ckpt")
+        >>> ms.merge_pipeline_strategys("./src_strategy_dir", "./dst_strategy.ckpt")
 
     """
     dst_strategy_dir, _ = os.path.split(dst_strategy_file)
@@ -75,17 +75,16 @@ def rank_list_for_transform(rank_id, src_strategy_file=None, dst_strategy_file=N
     """
     List of original distributed checkpoint rank index for obtaining the target checkpoint of a rank_id
     during the distributed checkpoint conversion. For more details about converting distributed Checkpoint,
-    please refer to `Distributed Resilience Training and
-    Inference <https://www.mindspore.cn/tutorials/experts/en/r2.0/parallel/resilience_train_and_predict.html>`_.
+    please refer to `Model Transformation <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/model_transformation.html>`_.
 
     Args:
         rank_id (int): The rank of which distributed checkpoint needs to be obtained after conversion.
         src_strategy_file (str): Name of source sharding strategy file which saved by
-                                 'mindspore.set_auto_parallel_context(strategy_ckpt_save_file)'.
+                                 `mindspore.set_auto_parallel_context(strategy_ckpt_save_file)`.
                                  when the 'src_strategy_file' is None, it means that the source sharding strategy is
                                  without any sharing for each parameter. Default:None.
         dst_strategy_file (str): Name of destination sharding strategy file which saved by
-                                 'mindspore.set_auto_parallel_context(strategy_ckpt_save_file)'.
+                                 `mindspore.set_auto_parallel_context(strategy_ckpt_save_file)`.
                                  when the 'dst_strategy_file' is None, it means that the destination sharding strategy
                                  is without any sharing for each parameter. Default:None.
 
@@ -98,8 +97,9 @@ def rank_list_for_transform(rank_id, src_strategy_file=None, dst_strategy_file=N
         TypeError: `rank_id` is not a int.
 
     Examples:
+        >>> import mindspore as ms
         >>> rank_id = 0
-        >>> rank_list = rank_list_for_transform(rank_id, "./src_strategy.ckpt", "./dst_strategy.ckpt")
+        >>> rank_list = ms.rank_list_for_transform(rank_id, "./src_strategy.ckpt", "./dst_strategy.ckpt")
         >>> checkpoint_files_map = {}
         >>> for rank in rank_list:
         ...     checkpoint_files_map[rank] = "./pangu{}-100_2.ckpt".format(rank)
@@ -129,9 +129,7 @@ def rank_list_for_transform(rank_id, src_strategy_file=None, dst_strategy_file=N
             src_rank_id_start = src_pipeline_stage_id * src_stage_device_num
             result_set.update([src_rank_id_start + rank for rank in needed_rank_list_in_local_stage])
             handled_pipeline_stage.append(src_pipeline_stage_id)
-    result_list = list(result_set)
-    result_list.sort(reverse=True)
-    return result_list
+    return list(result_set)
 
 
 def transform_checkpoint_by_rank(rank_id, checkpoint_files_map, save_checkpoint_file_name,
@@ -139,8 +137,7 @@ def transform_checkpoint_by_rank(rank_id, checkpoint_files_map, save_checkpoint_
     """
     Transform distributed checkpoint from source sharding strategy to destination sharding strategy by rank
     for a network. For more details about converting distributed Checkpoint, please refer to
-    `Distributed Resilience Training and
-    Inference <https://www.mindspore.cn/tutorials/experts/en/r2.0/parallel/resilience_train_and_predict.html>`_.
+    `Model Transformation <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/model_transformation.html>`_.
 
     Args:
         rank_id (int): The rank of which distributed checkpoint needs to be obtained after conversion.
@@ -166,14 +163,15 @@ def transform_checkpoint_by_rank(rank_id, checkpoint_files_map, save_checkpoint_
         TypeError: `save_checkpoint_file_name` is not a string.
 
     Examples:
+        >>> import mindspore as ms
         >>> dst_device_num = 8
         >>> for rank_id in range(dst_device_num):
-        ...     rank_list = rank_list_for_transform(rank_id, "./src_strategy.ckpt", "./dst_strategy.ckpt")
+        ...     rank_list = ms.rank_list_for_transform(rank_id, "./src_strategy.ckpt", "./dst_strategy.ckpt")
         ...     checkpoint_files_map = {}
         ...     for rank in rank_list:
         ...         checkpoint_files_map[rank] = "./origin_checkpoint_rank{}/pangu{}-100_2.ckpt".format(rank)
         ...     save_checkpoint_file_name = "./new_checkpoint_rank{}/pangu{}-100_2.ckpt".format(rank_id)
-        ...     transform_checkpoint_by_rank(rank_id, checkpoint_files_map, save_checkpoint_file_name,
+        ...     ms.transform_checkpoint_by_rank(rank_id, checkpoint_files_map, save_checkpoint_file_name,
         ...                                  "./src_strategy.ckpt", "./dst_strategy.ckpt")
 
     """
@@ -223,8 +221,7 @@ def transform_checkpoints(src_checkpoints_dir, dst_checkpoints_dir, ckpt_prefix,
     """
     Transform distributed checkpoint from source sharding strategy to destination sharding strategy for a rank.
     For more details about converting distributed Checkpoint, please refer to
-    `Distributed Resilience Training and
-    Inference <https://www.mindspore.cn/tutorials/experts/en/r2.0/parallel/resilience_train_and_predict.html>`_.
+    `Model Transformation <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/model_transformation.html>`_.
 
     Note:
         The `src_checkpoints_dir` directory structure should be organized like "src_checkpoints_dir/rank_0/a.ckpt", the
@@ -251,7 +248,8 @@ def transform_checkpoints(src_checkpoints_dir, dst_checkpoints_dir, ckpt_prefix,
         TypeError: `src_strategy_file` or `dst_strategy_file` is not a string.
 
     Examples:
-        >>> transform_checkpoints(src_checkpoints_dir, dst_checkpoints_dir, "dst_checkpoint",
+        >>> import mindspore as ms
+        >>> ms.transform_checkpoints(src_checkpoints_dir, dst_checkpoints_dir, "dst_checkpoint",
         ...                       "./src_strategy.ckpt", "./dst_strategy.ckpt")
 
     """

mindspore/parallel/shard.py

@@ -24,7 +24,7 @@ class Shard(Shard_):
 
     def __init__(self):
         """Initialize Shard."""
-        Shard_.__init__(self, 'Shard')
+        super().__init__('Shard')
         self.shard_fn = None
         self.fn = None
         self.in_strategy = None
@@ -159,11 +159,9 @@ def shard(fn, in_strategy, out_strategy=None, parameter_plan=None, device="Ascen
 
     Note:
         You need to set the execution mode to PyNative mode,
-        set the parallel mode in `set_auto_parallel_context` to "auto_parallel"
-        and the search mode to "sharding_propagation".
+        set the parallel mode in `set_auto_parallel_context` (parallel_mode) to "auto_parallel"
+        and the search mode (search_mode) to "sharding_propagation".
         If the input contain Parameter, its strategy should be set in `in_strategy`.
-        For more details about shard, please refer to `Functional Operator Sharding
-        <https://www.mindspore.cn/tutorials/experts/en/r2.0/parallel/pynative_shard_function_parallel.html>`_.
 
     Args:
         fn (Union[Cell, Function]): Function to be executed in parallel.
@@ -174,19 +172,19 @@ def shard(fn, in_strategy, out_strategy=None, parameter_plan=None, device="Ascen
                              Tuple defines the layout of the corresponding input
                              and None represents a data parallel strategy.
         out_strategy (Union[tuple, None]): Define the layout of outputs similar with `in_strategy`.
-                                           It is not in use right now. Default: None.
+                                           It is not in use right now. Default: ``None`` .
         parameter_plan (Union[dict, None]): Define the layout for the specified parameters. Each element in dict
                                             defines the layout of the parameter like "param_name: layout".
                                             The key is a parameter name of type 'str'.
                                             The value is a 1-D integer tuple, indicating the corresponding layout.
                                             If the parameter name is incorrect or the corresponding parameter
                                             has been set, the parameter setting will be ignored.
-                                            Default: None.
+                                            Default: ``None`` .
         device (string): Select a certain `device` target. It is not in use right now.
-                         Support ["CPU", "GPU", "Ascend"]. Default: "Ascend".
+                         Support ["CPU", "GPU", "Ascend"]. Default: ``"Ascend"`` .
         level (int): Option for parallel strategy infer algorithm, namely the object function, maximize computation
                      over communication ratio, maximize speed performance, minimize memory usage etc. It is not in
-                     use right now. Support ["0", "1", "2"]. Default: "0".
+                     use right now. Support [0, 1, 2]. Default: ``0`` .
 
     Returns:
         Function, return the function that will be executed under auto parallel process.
@@ -209,19 +207,24 @@ def shard(fn, in_strategy, out_strategy=None, parameter_plan=None, device="Ascen
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor, set_context, set_auto_parallel_context, shard, PYNATIVE_MODE
+        >>> import mindspore as ms
+        >>> from mindspore import Tensor
         >>> from mindspore.communication import init
-        >>> set_context(mode=PYNATIVE_MODE)
+        >>> ms.set_context(mode=ms.PYNATIVE_MODE)
         >>> init()
-        >>> set_auto_parallel_context(parallel_mode="auto_parallel", search_mode="sharding_propagation",
+        >>> ms.set_auto_parallel_context(parallel_mode="auto_parallel", search_mode="sharding_propagation",
         ...                           device_num=2)
         >>> def test_shard(x, y):
         ...     return x + y
         >>> x = Tensor(np.ones(shape=(32, 10)))
         >>> y = Tensor(np.ones(shape=(32, 10)))
-        >>> output = shard(test_shard, in_strategy=((2, 1), (2, 1)))(x, y)
+        >>> output = ms.shard(test_shard, in_strategy=((2, 1), (2, 1)))(x, y)
         >>> print(output.shape)
         (32, 10)
+
+    Tutorial Examples:
+        - `Functional Operator Sharding
+          <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/pynative_shard_function_parallel.html>`_
     """
     if not isinstance(fn, (ms.nn.Cell)):
         logger.warning("'fn' is not a mindspore.nn.Cell, and its definition cannot involve Parameter; "

mindspore/profiler/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
+# Copyright 2020-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.

mindspore/profiler/common/struct_type.py

@@ -72,7 +72,7 @@ class StructType(Enum):
         """
         Parse the binary data to get the unpacked data.
 
-        Args：
+        Args:
             data_struct (dict): Key is the data name, value is StructType.
             binary_data (str): This value should be a binary string.
             special_func (Callable): This is a callable function,
@@ -105,14 +105,14 @@ class StructType(Enum):
         for name, data_type in data_struct.items():
             data_size = StructType.sizeof(data_type)
             if special_process_func:
-                unpack_data, success = special_process_func(binary_data[cursor:cursor+data_size], name,
+                unpack_data, success = special_process_func(binary_data[cursor:cursor + data_size], name,
                                                             data_type, unpacked_data)
                 if success:
                     cursor += data_size
                     unpacked_data[name] = unpack_data
                     continue
 
-            unpack_data = struct.unpack(data_type.value, binary_data[cursor: cursor+data_size])[0]
+            unpack_data = struct.unpack(data_type.value, binary_data[cursor: cursor + data_size])[0]
             cursor += data_size
             unpacked_data[name] = unpack_data
         return unpacked_data

mindspore/profiler/common/util.py

@@ -23,6 +23,7 @@ import os
 import re
 import stat
 
+from mindspore import log as logger
 
 def to_int(param, param_name):
     """
@@ -80,9 +81,9 @@ def fwrite_format(output_data_path, data_source=None, is_print=False, is_start=F
                 if isinstance(raw_data, (list, tuple)):
                     raw_data = map(str, raw_data)
                     raw_data = " ".join(raw_data)
-                print(raw_data)
+                logger.info(raw_data)
         else:
-            print(data_source)
+            logger.info(data_source)
 
 
 def get_log_slice_id(file_name):

mindspore/profiler/envprofiling.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# Copyright 2022-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.
@@ -68,7 +68,7 @@ def construct_profiling_options():
         logger.error(
             "The format of MS_PROFILER_OPTIONS is incorrect. "
             "The MS_PROFILER_OPTIONS parameter configuration may refer to "
-            "'https://www.mindspore.cn/mindinsight/docs/zh-CN/master/performance_profiling_ascend.html'."
+            "'https://www.mindspore.cn/mindinsight/docs/zh-CN/r2.2/performance_profiling_ascend.html'."
         )
         return error_config
     conbine_options = combine_profile_options(profiling_options)
@@ -122,6 +122,11 @@ def parse_pubilc_args(options):
             "The 'output_path' parameter of the environment variable MS_PROFILE_OPTIONS only supports absolute path, "
             f"it will be set to '{absolute_path}'.")
         options["output_path"] = absolute_path
+    if options.get("profile_framework") not in ["memory", "time", "all", None]:
+        logger.warning(
+            "The 'profile_framework' parameter of the environment variable MS_PROFILE_OPTIONS must be one of ['memory',"
+            " 'time', 'all', null], but got %s, it will be set to 'all'.", options.get("profile_framework"))
+        options['profile_framework'] = "all"
     return options
 
 
@@ -191,7 +196,8 @@ def combine_profile_options(profiling_options):
         "data_process": profiling_options.get("data_process", True),
         "timeline_limit": profiling_options.get("timeline_limit", 500),
         "parallel_strategy": profiling_options.get("parallel_strategy", True),
-        'op_time': profiling_options.get("op_time", True)
+        'op_time': profiling_options.get("op_time", True),
+        'profile_framework': profiling_options.get("profile_framework", "all")
     }
     combine_options = parse_profiling_args(config_options)
     if combine_options.get("start"):
@@ -243,7 +249,8 @@ def profiler_check_env():
              l2_cache=config.get("l2_cache", False),
              sync_enable=config.get("sync_enable", False),
              op_time=config.get("op_time", False),
-             timeline_limit=config.get("timeline_limit", 500))
+             timeline_limit=config.get("timeline_limit", 500),
+             profile_framework=config.get("profile_framework", "all"))
 
 
 profiler_check_env()

mindspore/profiler/parser/aicpu_data_parser.py

@@ -72,9 +72,11 @@ class DataPreProcessParser:
     _source_file_target_old = 'DATA_PREPROCESS.dev.AICPU.'
     _source_file_target = 'DATA_PREPROCESS.AICPU.'
     _dst_file_title = 'title:DATA_PREPROCESS AICPU'
-    _dst_file_column_title = ['serial_number', 'node_type_name', 'total_time(ms)',
-                              'dispatch_time(ms)', 'execution_time(ms)', 'run_start',
-                              'run_end']
+    _dst_file_column_title = [
+        'serial_number', 'node_type_name', 'total_time(ms)',
+        'dispatch_time(ms)', 'execution_time(ms)', 'run_start',
+        'run_end'
+    ]
     _ms_unit = 1000
     _us_unit = 100  # Convert 10ns to 1us.
     _task_id_threshold = 65536

mindspore/profiler/parser/ascend_flops_generator.py

@@ -0,0 +1,94 @@
+# Copyright 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.
+# 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.
+# ============================================================================
+"""flops analyse model"""
+import csv
+import json
+import logging
+import os
+import stat
+
+import numpy as np
+from mindspore.profiler.common.exceptions.exceptions import ProfilerIOException
+
+
+class AscendFlopsGenerator:
+    """Generate ascend flops data from DataFrame."""
+
+    def __init__(self, op_summary):
+        self.op_summary = op_summary
+        self.flops_dt = np.dtype(
+            [('op_full_name', object), ('MFLOPs(10^6 cube)', float), ('GFLOPS(10^9 cube)', float),
+             ('MFLOPs(10^6 vector)', float), ('GFLOPS(10^9 vector)', float)])
+        self.flops = None
+        self.flops_summary = None
+
+    def parse(self):
+        """Analyse the op_summary data generate flops data."""
+
+        self.flops = np.empty((len(self.op_summary)), dtype=self.flops_dt)
+
+        nonzero_duration = self.op_summary['Task Duration'] != 0
+        self.flops['op_full_name'] = self.op_summary['Op Name']
+        self.flops['MFLOPs(10^6 cube)'] = self.op_summary['cube_fops'] * 1e-6
+        self.flops['GFLOPS(10^9 cube)'] = np.where(nonzero_duration, self.op_summary['cube_fops'] / self.op_summary[
+            'Task Duration'] * 1e-6, 0)
+        self.flops['MFLOPs(10^6 vector)'] = self.op_summary['vector_fops'] * 1e-6
+        self.flops['GFLOPS(10^9 vector)'] = self.op_summary['vector_fops'] / self.op_summary['Task Duration'] * 1e-6
+        self.flops['GFLOPS(10^9 vector)'] = np.where(nonzero_duration, self.op_summary['vector_fops'] / self.op_summary[
+            'Task Duration'] * 1e-6, 0)
+
+        cube_flops = 0
+        vec_flops = 0
+        if np.sum(self.op_summary['Task Duration']) != 0:
+            cube_flops = round(np.sum(self.flops['GFLOPS(10^9 cube)']) / np.sum(self.op_summary['Task Duration']), 4)
+            vec_flops = round(np.sum(self.flops['GFLOPS(10^9 vector)']) / np.sum(self.op_summary['Task Duration']), 4)
+
+        self.flops_summary = {
+            'cube_FLOPs': round(float(np.sum(self.flops['MFLOPs(10^6 cube)'])), 4),
+            'cube_FLOPS': cube_flops,
+            'vec_FLOPs': round(float(np.sum(self.flops['MFLOPs(10^6 vector)'])), 4),
+            'vec_FLOPS': vec_flops
+        }
+
+    def write(self, flops_path, flops_summary_path):
+        """
+        Write the flops.csv and flops_summary.json
+
+        Args:
+            flops_path(str): flops.csv path.
+            flops_summary_path(str): flops_summary.json path.
+        """
+        try:
+            with os.fdopen(os.open(flops_path,
+                                   os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR), 'w') as fp:
+                writer = csv.writer(fp)
+                writer.writerow(self.flops.dtype.names)
+                writer.writerows(self.flops.tolist())
+        except (IOError, OSError) as err:
+            logging.critical('Errot occurred when write flops file: %s', err)
+            raise ProfilerIOException() from err
+        if os.path.exists(flops_path):
+            os.chmod(flops_path, stat.S_IREAD | stat.S_IWRITE)
+
+        try:
+            with os.fdopen(os.open(flops_summary_path,
+                                   os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR),
+                           'w') as json_file:
+                json.dump(self.flops_summary, json_file)
+        except (IOError, OSError) as err:
+            logging.critical('Errot occurred when write step trace point info file: %s', err)
+            raise ProfilerIOException() from err
+        if os.path.exists(flops_summary_path):
+            os.chmod(flops_summary_path, stat.S_IREAD | stat.S_IWRITE)