mindspore 2.5.0__cp310-cp310-win_amd64.whl → 2.6.0__cp310-cp310-win_amd64.whl

mindspore/profiler/dynamic_profiler.py

@@ -25,12 +25,17 @@ import multiprocessing
 
 from mindspore import log as logger
 from mindspore.train import Callback
-from mindspore.profiler import Profiler, tensor_board_trace_handler, schedule
+from mindspore.profiler import Profiler, tensorboard_trace_handler, schedule
 from mindspore.communication import get_rank
 from mindspore.profiler.parser.ascend_analysis.file_manager import FileManager
 from mindspore.profiler.parser.ascend_analysis.path_manager import PathManager
 from mindspore.profiler.profiler_interface import ProfilerInterface
-from mindspore.profiler.common.constant import ProfilerActivity, ProfilerLevel, AicoreMetrics
+from mindspore.profiler.common.constant import (
+    ProfilerActivity,
+    ProfilerLevel,
+    AicoreMetrics,
+    ExportType,
+)
 from mindspore.profiler.common.util import no_exception_func
 
 
@@ -51,16 +56,19 @@ class DynamicProfilerArgs:
     """
     Data class for dynamic profile config.
     """
-    FMT = "iiiiii????"
+    FMT = "i" * 7 + "?" * 6
     SIZE = struct.calcsize(FMT)
 
     def __init__(self,
                  start_step: int = -1,
                  stop_step: int = -1,
-                 aicore_metrics: int = -1,
+                 aic_metrics: int = -1,
                  profiler_level: int = 0,
                  analyse_mode: int = -1,
                  activities: int = 0,
+                 export_type: int = 0,
+                 profile_memory: bool = False,
+                 mstx: bool = False,
                  parallel_strategy: bool = False,
                  with_stack: bool = False,
                  data_simplification: bool = True,
@@ -68,10 +76,13 @@ class DynamicProfilerArgs:
                  **kwargs):
         self._start_step = start_step
         self._stop_step = stop_step
-        self._aicore_metrics = aicore_metrics
+        self._aic_metrics = aic_metrics
         self._profiler_level = profiler_level
         self._analyse_mode = analyse_mode
         self._activities = activities
+        self._export_type = export_type
+        self._profile_memory = profile_memory
+        self._mstx = mstx
         self._parallel_strategy = parallel_strategy
         self._with_stack = with_stack
         self._data_simplification = data_simplification
@@ -79,42 +90,38 @@ class DynamicProfilerArgs:
         self._check_params_type()
 
     def _check_params_type(self):
-        """ check params type."""
-        if not isinstance(self._start_step, int):
-            logger.warning("start_step should be int type, start_step will be reset to -1.")
-            self._start_step = -1
-
-        if not isinstance(self._stop_step, int):
-            logger.warning("stop_step should be int type, stop_step will be reset to -1.")
-            self._stop_step = -1
-
-        if not isinstance(self._aicore_metrics, int):
-            logger.warning("aicore_metrics should be int type, aicore_metrics will be reset to -1.")
-            self._aicore_metrics = -1
-
-        if not isinstance(self._profiler_level, int):
-            logger.warning("profiler_level should be int type, profiler_level will be reset to 0.")
-            self._profiler_level = 0
-
-        if not isinstance(self._analyse_mode, int):
-            logger.warning("analyse_mode should be int type, analyse_mode will be reset to -1.")
-            self._analyse_mode = -1
-
-        if not isinstance(self._activities, int):
-            logger.warning("activities should be int type, activities will be reset to 0.")
-            self._activities = 0
-
-        if not isinstance(self._with_stack, bool):
-            logger.warning("with_stack should be bool type, with_stack will be reset to False.")
-            self._with_stack = False
-
-        if not isinstance(self._data_simplification, bool):
-            logger.warning("data_simplification should be bool type, data_simplification will be reset to True.")
-            self._data_simplification = True
-
-        if not isinstance(self._is_valid, bool):
-            logger.warning("is_valid should be bool type, is_valid will be reset to False.")
-            self._is_valid = False
+        """Check and enforce parameter types with lower complexity."""
+        # Define a parameter check rule. {Parameter name: (expected type, default value)}
+        param_rules = {
+            '_start_step': (int, -1),
+            '_stop_step': (int, -1),
+            '_aic_metrics': (int, -1),
+            '_profiler_level': (int, 0),
+            '_analyse_mode': (int, -1),
+            '_activities': (int, 0),
+            '_export_type': (int, 0),
+            '_profile_memory': (bool, False),
+            '_mstx': (bool, False),
+            '_parallel_strategy': (bool, False),
+            '_with_stack': (bool, False),
+            '_data_simplification': (bool, True),
+            '_is_valid': (bool, False)
+        }
+
+        def _is_valid_type(value, expected_type):
+            """Helper method for type checking."""
+            if expected_type is int and isinstance(value, bool):
+                return False
+            return isinstance(value, expected_type)
+
+        for param, (expected_type, default) in param_rules.items():
+            value = getattr(self, param)
+            if not _is_valid_type(value, expected_type):
+                logger.warning(
+                    f"{param[1:]} should be {expected_type.__name__} type, "
+                    f"will be reset to {default}."
+                )
+                setattr(self, param, default)
 
     @property
     def start_step(self):
@@ -156,7 +163,8 @@ class DynamicProfilerArgs:
         """ get all args in DynamicProfilerArgs."""
         self._profiler_level = self._convert_profiler_level(self._profiler_level)
         self._activities = self._convert_activities(self._activities)
-        self._aicore_metrics = self._convert_aicore_metrics(self._aicore_metrics)
+        self._aic_metrics = self._convert_aic_metrics(self._aic_metrics)
+        self._export_type = self._convert_export_type(self._export_type)
         not_supported_args = ['_start_step', '_stop_step', '_analyse_mode', '_is_valid']
         res = {}
         for key, value in self.__dict__.items():
@@ -187,6 +195,8 @@ class DynamicProfilerArgs:
 
     def _convert_profiler_level(self, profiler_level: int) -> ProfilerLevel:
         """ convert profiler_level to real args in Profiler."""
+        if profiler_level == -1:
+            return ProfilerLevel.LevelNone
         if profiler_level == 0:
             return ProfilerLevel.Level0
         if profiler_level == 1:
@@ -205,26 +215,38 @@ class DynamicProfilerArgs:
             return [ProfilerActivity.NPU]
         return [ProfilerActivity.CPU, ProfilerActivity.NPU]
 
-    def _convert_aicore_metrics(self, aicore_metrics: int) -> AicoreMetrics:
-        """ convert aicore_metrics to real args in Profiler."""
-        if aicore_metrics == -1:
+    def _convert_aic_metrics(self, aic_metrics: int) -> AicoreMetrics:
+        """ convert aic_metrics to real args in Profiler."""
+        if aic_metrics == -1:
             return AicoreMetrics.AiCoreNone
-        if aicore_metrics == 0:
+        if aic_metrics == 0:
             return AicoreMetrics.PipeUtilization
-        if aicore_metrics == 1:
+        if aic_metrics == 1:
             return AicoreMetrics.ArithmeticUtilization
-        if aicore_metrics == 2:
+        if aic_metrics == 2:
             return AicoreMetrics.Memory
-        if aicore_metrics == 3:
+        if aic_metrics == 3:
             return AicoreMetrics.MemoryL0
-        if aicore_metrics == 4:
+        if aic_metrics == 4:
             return AicoreMetrics.MemoryUB
-        if aicore_metrics == 5:
+        if aic_metrics == 5:
             return AicoreMetrics.ResourceConflictRatio
-        if aicore_metrics == 6:
+        if aic_metrics == 6:
             return AicoreMetrics.L2Cache
+        if aic_metrics == 7:
+            return AicoreMetrics.MemoryAccess
         return AicoreMetrics.AiCoreNone
 
+    def _convert_export_type(self, export_type: int) -> ExportType:
+        """ convert export_type to real args in Profiler."""
+        if export_type == 0:
+            return [ExportType.Text]
+        if export_type == 1:
+            return [ExportType.Db]
+        if export_type == 2:
+            return [ExportType.Text, ExportType.Db]
+        return [ExportType.Text]
+
 class DynamicProfilerMonitorBase(Callback):
     """
     Dynamic profile callback base class implementing the dynamic profile functionality.
@@ -297,7 +319,8 @@ class DynamicProfilerMonitorBase(Callback):
             if self._profiler is None:
                 prof_path = os.path.join(self._output_path, f"rank{self._rank_id}_start{start_step}_stop{stop_step}")
                 PathManager.check_input_directory_path(prof_path)
-                self._profiler = Profiler(output_path=prof_path, start_profile=False, **prof_args.args)
+                self._profiler = Profiler(on_trace_ready=tensorboard_trace_handler(dir_name=prof_path),
+                                          start_profile=False, **prof_args.args)
                 print_msg(f"Rank {self._rank_id} create output path {prof_path}")
 
             self._profiler.start()
@@ -389,27 +412,30 @@ class DynamicProfilerMonitorBase(Callback):
             >>>
             >>> if __name__ == '__main__':
             ...      # set json configuration file
-            ...      cfg_json = {
+            ...      context.set_context(mode=mindspore.PYNATIVE_MODE)
+            ...      mindspore.set_device("Ascend")
+            ...      data_cfg = {
             ...          "start_step": 2,
             ...          "stop_step": 5,
-            ...          "aicore_metrics": -1,
+            ...          "aic_metrics": -1,
             ...          "profiler_level": 0,
             ...          "activities": 0,
-            ...          "analyse_mode": -1,
+            ...          "export_type": 0,
+            ...          "profile_memory": False,
+            ...          "mstx": False,
+            ...          "analyse_mode": 0,
             ...          "parallel_strategy": False,
             ...          "with_stack": False,
             ...          "data_simplification": True,
             ...          }
-            ...      context.set_context(mode=mindspore.PYNATIVE_MODE)
-            ...      mindspore.set_device("Ascend")
-            ...      cfg_path = os.path.join("./cfg_path", "profiler_config.json")
+            ...      output_path = "./cfg_path"
+            ...      cfg_path = os.path.join(output_path, "profiler_config.json")
+            ...      os.makedirs(output_path, exist_ok=True)
             ...      # set cfg file
             ...      with open(cfg_path, 'w') as f:
-            ...           json.dump(cfg_json, f, indent=4)
-            ...      # Assume the user has correctly configured the environment variable (RANK_ID is not a non-numeric type)
-            ...      rank_id = int(os.getenv('RANK_ID')) if os.getenv('RANK_ID') else 0
+            ...           json.dump(data_cfg, f, indent=4)
             ...      # cfg_path contains the json configuration file path, and output_path is the output path
-            ...      dp = DynamicProfilerMonitor(cfg_path=cfg_path, output_path=cfg_path)
+            ...      dp = DynamicProfilerMonitor(cfg_path=output_path, output_path=output_path)
             ...      STEP_NUM = 15
             ...      # Define a network of training models
             ...      net = Net()
@@ -417,11 +443,11 @@ class DynamicProfilerMonitorBase(Callback):
             ...          print(f"step {i}")
             ...          train(net)
             ...          # Modify the configuration file after step 7. For example, change start_step to 8 and stop_step to 10
-            ...          if i == 7:
+            ...          if i == 5:
             ...             # Modify parameters in the JSON file
-            ...             change_cfg_json(os.path.join(cfg_path, "profiler_config.json"))
-            ...             # Call step collection
-            ...             dp.step()
+            ...             change_cfg_json(os.path.join(output_path, "profiler_config.json"))
+            ...          # Call step collection
+            ...          dp.step()
         """
 
         self._step_num += 1
@@ -448,12 +474,11 @@ class DynamicProfilerMonitorBase(Callback):
                 print_msg(f"Rank {self._rank_id} create output path {prof_path}")
                 print_msg(f"Rank {self._rank_id} Dynamic profile start at step {self._start_step}, "
                           f"will stop at step {self._stop_step}")
-                self._profiler = Profiler(output_path=prof_path,
-                                          schedule=schedule(wait=0, warmup=0,
+                self._profiler = Profiler(schedule=schedule(wait=0, warmup=0,
                                                             active=self._stop_step - self._start_step + 1,
                                                             repeat=1,
                                                             skip_first=1),
-                                          on_trace_ready=tensor_board_trace_handler,
+                                          on_trace_ready=tensorboard_trace_handler(dir_name=prof_path),
                                           **prof_args.args)
             else:
                 self._profiler = None
@@ -625,7 +650,7 @@ if sys.version_info >= (3, 8):
         This class to enable the dynamic profile monitoring of MindSpore neural networks.
 
         Args:
-            cfg_path (str): Dynamic profile json config file directory. The requirement is a shared path
+            cfg_path (str): (Ascend only) Dynamic profile json config file directory. The requirement is a shared path
                 that can be accessed by all nodes. The parameters of the json configuration file are as follows:
 
                 - start_step (int, required) - Sets the step number at which the Profiler starts collecting data.
@@ -635,16 +660,24 @@ if sys.version_info >= (3, 8):
                   a relative value, with the first step of training being 1. The stop_step must be greater than or
                   equal to start_step. The default value is -1, indicating that data collection will not start during
                   the entire training process.
-                - aicore_metrics (int, optional) - The range of values corresponds to the Profiler. The default value -1
+                - aic_metrics (int, optional) - The range of values corresponds to the Profiler. The default value -1
                   indicates that AI Core utilization is not collected, and 0 indicates PipeUtilization, 1 indicates
                   ArithmeticUtilization, 2 stands for Memory, 3 stands for MemoryL0, 4 stands for MemoryUB, 5 indicates
-                  ResourceConflictRatio, 6 indicates L2Cache.
-                - profiler_level (int, optional) - Sets the level of performance data collection, where 0 represents
-                  ProfilerLevel.Level0, 1 represents ProfilerLevel.Level1, and 2 represents ProfilerLevel.Level2. The
-                  default value is 0, indicating the ProfilerLevel.Level0 collection level.
+                  ResourceConflictRatio, 6 indicates L2Cache, 7 indicates MemoryAccess.
+                - profiler_level (int, optional) - Sets the level of performance data collection, where -1 represents
+                  ProfilerLevel.LevelNone, 0 represents ProfilerLevel.Level0, 1 represents ProfilerLevel.Level1, and
+                  2 represents ProfilerLevel.Level2. The default value is 0, indicating the ProfilerLevel.Level0
+                  collection level.
                 - activities (int, optional) - Sets the devices for performance data collection, where 0 represents
                   CPU+NPU, 1 represents CPU, and 2 represents NPU. The default value is 0, indicating the collection
                   of CPU+NPU performance data.
+                - export_type (int, optional) -  Sets the data type to export, where 0 represents text, 1 represents db,
+                  and 2 represents text and db. The default value is 0, indicating only export text type data.
+                - profile_memory (bool, optional) - Set whether to collect memory performance data, true indicates that
+                  memory performance data is collected, false indicates that memory performance data is not collected.
+                  The default value is false, indicating that memory performance data is not collected.
+                - mstx (bool, optional) - Set whether to enable mstx, true indicates that mstx is enabled, false
+                  indicates that mstx is disabled. The default value is false, indicating that mstx is not enabled.
                 - analyse_mode (int, optional) - Sets the mode for online analysis, corresponding to the analyse_mode
                   parameter of the mindspore.Profiler.analyse interface, where 0 represents "sync" and 1 represents
                   "async". The default value is -1, indicating that online analysis is not used.
@@ -658,8 +691,8 @@ if sys.version_info >= (3, 8):
                   to enable and false means not to enable. The default value is true, indicating that data
                   simplification is enabled.
 
-            output_path (str, optional): Output data path. Default: ``"./dyn_profile_data"`` .
-            poll_interval (int, optional): The polling period of the monitoring process, in seconds.
+            output_path (str, optional): (Ascend only) Output data path. Default: ``"./dyn_profile_data"`` .
+            poll_interval (int, optional): (Ascend only) The polling period of the monitoring process, in seconds.
                 Default value: ``2``.
 
         Raises:
@@ -728,7 +761,7 @@ if sys.version_info >= (3, 8):
                 logger.info("Rank %s process stop", self._rank_id)
 
             # clear shared memory
-            if self._shm:
+            if self._shm and self._is_create_process:
                 try:
                     self._shm.close()
                     self._shm.unlink()

mindspore/profiler/envprofiler.py

@@ -21,6 +21,7 @@ from mindspore.profiler.common.constant import (
     ProfilerLevel,
     AicoreMetrics,
     ProfilerActivity,
+    ExportType,
 )
 from mindspore.profiler.common.profiler_parameters import ProfilerParameters
 
@@ -107,7 +108,7 @@ class EnvProfiler:
                     params[param] = cls._convert_activities_to_list(
                         options[param], default_value
                     )
-                elif param == "aicore_metrics":
+                elif param == "aic_metrics":
                     params[param] = cls._convert_option_to_enum_value(
                         AicoreMetrics, options[param], default_value
                     )
@@ -115,6 +116,10 @@ class EnvProfiler:
                     params[param] = cls._convert_option_to_enum_value(
                         ProfilerLevel, options[param], default_value
                     )
+                elif param == "export_type":
+                    params[param] = cls._convert_export_type_to_list(
+                        options[param], default_value
+                    )
                 else:
                     params[param] = options[param]
         return params
@@ -134,5 +139,25 @@ class EnvProfiler:
         # remove duplicate
         return list(set(default_value if default_value in res else res))
 
+    @classmethod
+    def _convert_export_type_to_list(cls, export_types, default_value) -> list:
+        """
+        Check the export type to the list.
+        """
+        res = []
+        for export_type in export_types:
+            if export_type != "text" and export_type != "db":
+                logger.warning(
+                    f"The value '{export_type}' of parameter '{ExportType.__name__}' is invalid, "
+                    f"use default value '{default_value}' instead."
+                )
+                return default_value
+            res.append(
+                cls._convert_option_to_enum_value(
+                    ExportType, export_type, default_value
+                )
+            )
+        # remove duplicate
+        return list(set(res))
 
 EnvProfiler.init_profiler()

mindspore/profiler/experimental_config.py

@@ -0,0 +1,197 @@
+# Copyright 2020-2024 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.
+# ============================================================================
+"""Experimental config file."""
+
+from mindspore.profiler.common.constant import ProfilerLevel, AicoreMetrics
+
+__all__ = ["_ExperimentalConfig"]
+
+
+class _ExperimentalConfig:
+    r"""
+    The purpose of this class is to configure scalable parameters when using profiles for model
+    performance data acquisition.
+
+    Args:
+        profiler_level (ProfilerLevel, optional): (Ascend only) The level of profiling.
+            Default: ``ProfilerLevel.Level0``.
+
+            - ProfilerLevel.LevelNone: This setting takes effect only when mstx is enabled, indicating that no
+              operator data is collected on the device side.
+            - ProfilerLevel.Level0: Leanest level of profiling data collection, collects information about the elapsed
+              time of the computational operators on the NPU and communication large operator information.
+            - ProfilerLevel.Level1: Collect more CANN layer AscendCL data and AICore performance metrics and
+              communication mini operator information based on Level0.
+            - ProfilerLevel.Level2: Collect GE and Runtime information in CANN layer on top of Level1
+        aic_metrics (AicoreMetrics, optional): (Ascend only) Types of AICORE performance data collected,
+            when using this parameter, `activities` must include ``ProfilerActivity.NPU`` , and the value
+            must be a member of AicoreMetrics. When profiler_level is Level0, the default value is
+            ``AicoreMetrics.AiCoreNone``; Profiler_level is a Level1 or Level2 stores, the default value is:
+            ``AicoreMetrics. PipeUtilization``.The data items contained in each metric are as follows:
+
+            - AicoreMetrics.AiCoreNone: Does not collect AICORE data.
+            - AicoreMetrics.ArithmeticUtilization: ArithmeticUtilization contains mac_fp16/int8_ratio,
+              vec_fp32/fp16/int32_ratio, vec_misc_ratio etc.
+            - AicoreMetrics.PipeUtilization: PipeUtilization contains vec_ratio, mac_ratio, scalar_ratio,
+              mte1/mte2/mte3_ratio, icache_miss_rate etc.
+            - AicoreMetrics.Memory: Memory contains ub_read/write_bw, l1_read/write_bw, l2_read/write_bw,
+              main_mem_read/write_bw etc.
+            - AicoreMetrics.MemoryL0: MemoryL0 contains l0a_read/write_bw, l0b_read/write_bw, l0c_read/write_bw etc.
+            - AicoreMetrics.ResourceConflictRatio: ResourceConflictRatio contains vec_bankgroup/bank/resc_cflt_ratio
+              etc.
+            - AicoreMetrics.MemoryUB: MemoryUB contains ub_read/write_bw_mte, ub_read/write_bw_vector,
+              ub\_read/write_bw_scalar etc.
+            - AicoreMetrics.L2Cache: L2Cache contains write_cache_hit, write_cache_miss_allocate, r0_read_cache_hit,
+              r1_read_cache_hit etc. This function only supports Atlas A2 training series products.
+            - AicoreMetrics.MemoryAccess: Statistics on storage access bandwidth and storage capacity of main
+              storage and l2 cache etc.
+        l2_cache (bool, optional): (Ascend only) Whether to collect l2 cache data, collect when True.
+            Default: ``False`` . The l2_cache.csv file is generated in the ASCEND_PROFILER_OUTPUT folder.In O2 mode,
+            only wait and skip_first parameters in schedule configuration can be set to 0.
+        mstx (bool, optional): (Ascend only) Whether to collect light weight profiling data, collect when True.
+            Default: ``False`` .
+        data_simplification (bool, optional): (Ascend only) Whether to remove FRAMEWORK data and other redundant data.
+            If set to True, only the profiler deliverables and raw performance data under the PROF_XXX directory are
+            kept to save space. Default value: ``True`` .
+        export_type (list, optional): (Ascend only) The data type to export.
+            The db and text formats can be exported at the same time. The default value is ``None``,
+            indicating that data of the text type is exported.
+
+            - ExportType.Text: Export text type data.
+            - ExportType.Db: Export db type data.
+
+    Raises:
+        RuntimeError: When the version of CANN does not match the version of MindSpore,
+            MindSpore cannot parse the generated ascend_job_id directory structure.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import nn, context
+        >>> import mindspore.dataset as ds
+        >>> from mindspore.profiler import ProfilerLevel, ProfilerActivity, AicoreMetrics, ExportType
+        >>>
+        >>> class Net(nn.Cell):
+        ...     def __init__(self):
+        ...         super(Net, self).__init__()
+        ...         self.fc = nn.Dense(2,2)
+        ...     def construct(self, x):
+        ...         return self.fc(x)
+        >>>
+        >>> def generator():
+        ...     for i in range(2):
+        ...         yield np.ones([2, 2]).astype(np.float32), np.ones([2]).astype(np.int32)
+        >>>
+        >>> def train(net):
+        ...     optimizer = nn.Momentum(net.trainable_params(), 1, 0.9)
+        ...     loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
+        ...     data = ds.GeneratorDataset(generator, ["data", "label"])
+        ...     model = mindspore.train.Model(net, loss, optimizer)
+        ...     model.train(1, data)
+        >>>
+        >>> if __name__ == '__main__':
+        ...     # If the device_target is GPU, set the device_target to "GPU"
+        ...     context.set_context(mode=mindspore.GRAPH_MODE)
+        ...     mindspore.set_device("Ascend")
+        ...
+        ...     # Init Profiler
+        ...     experimental_config = mindspore.profiler._ExperimentalConfig(
+        ...                                 profiler_level=ProfilerLevel.Level0,
+        ...                                 aic_metrics=AicoreMetrics.AiCoreNone,
+        ...                                 l2_cache=False,
+        ...                                 mstx=False,
+        ...                                 data_simplification=False,
+        ...                                 export_type=[ExportType.Text])
+        ...     steps = 10
+        ...     net = Net()
+        ...     # Note that the Profiler should be initialized before model.train
+        ...     with mindspore.profiler.profile(activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
+        ...                                     schedule=mindspore.profiler.schedule(wait=1, warmup=1, active=2,
+        ...                                           repeat=1, skip_first=2),
+        ...                                     on_trace_ready=mindspore.profiler.tensorboard_trace_handler("./data"),
+        ...                                     profile_memory=False,
+        ...                                     experimental_config=experimental_config) as prof:
+        ...
+        ...         # Train Model
+        ...         for step in range(steps):
+        ...             train(net)
+        ...             prof.step()
+    """
+
+    def __init__(self,
+                 profiler_level: ProfilerLevel = ProfilerLevel.Level0,
+                 aic_metrics: AicoreMetrics = AicoreMetrics.AiCoreNone,
+                 l2_cache: bool = False,
+                 mstx: bool = False,
+                 data_simplification: bool = True,
+                 export_type: list = None):
+        self._profiler_level = profiler_level
+        self._aic_metrics = aic_metrics
+        self._l2_cache = l2_cache
+        self._mstx = mstx
+        self._data_simplification = data_simplification
+        self._export_type = export_type
+
+    @property
+    def profiler_level(self) -> ProfilerLevel:
+        return self._profiler_level
+
+    @property
+    def aic_metrics(self) -> AicoreMetrics:
+        return self._aic_metrics
+
+    @property
+    def l2_cache(self) -> bool:
+        return self._l2_cache
+
+    @property
+    def mstx(self) -> bool:
+        return self._mstx
+
+    @property
+    def data_simplification(self) -> bool:
+        return self._data_simplification
+
+    @property
+    def export_type(self) -> list:
+        return self._export_type
+
+    # Setters
+    @profiler_level.setter
+    def profiler_level(self, value: ProfilerLevel):
+        self._profiler_level = value
+
+    @aic_metrics.setter
+    def aic_metrics(self, value: AicoreMetrics):
+        self._aic_metrics = value
+
+    @l2_cache.setter
+    def l2_cache(self, value: bool):
+        self._l2_cache = value
+
+    @mstx.setter
+    def mstx(self, value: bool):
+        self._mstx = value
+
+    @data_simplification.setter
+    def data_simplification(self, value: bool):
+        self._data_simplification = value
+
+    @export_type.setter
+    def export_type(self, value: list):
+        self._export_type = value