+
+## Overview
+
+When a model compiled using Mindspore run in graph mode `context.set_context(mode=context.GRAPH_MODE)` and `context.set_context(save_graphs=True)` is set in the configuration, some intermediate files will be generated during graph compliation. These intermediate files are called IR files. Currently, there are three IR files:
+
+- .ir file: An IR file that describes the model structure in text format and can be directly viewed using any text editing software. We will also introduce how to view it in the following sections.
+
+- .dat file: An IR file that describes the model structure more strictly than the .ir file. It contains more content and can be directly viewed using any text editing software.
+
+- .dot file: An IR file that describes the topology relationships between different nodes. You can use this file by [graphviz](http://graphviz.org/) as the input to generate images for users to view the model structure. For models with many operators, it is recommended using the visualization component [MindInsight](https://www.mindspore.cn/tutorial/training/zh-CN/master/advanced_use/dashboard.html#id5) to visualize computing graphs.
+
+In this tutorial, we use LeNet in ModelZoo as a demonstration on the Ascend environment. The related scripts can be found in [ModelZoo/LeNet](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/lenet).
+
+## Generate IR Files
+
+Add the following code to `train.py`, When the script run, Mindspore will automatically store the IR files generated during compliation to the specified path.
+
+```python
+if __name__ == "__main__":
+ context.set_context(save_graphs=True, save_graphs_path="path/to/ir/files")
+```
+
+In this tutorial, we run the training script on standalone computing device. When run on multiple computing devices, Mindspore will generate separate processes for each computing device. So, in multiple computing devices scenario, you are advised to read the ID of the current computing device from the training script and set an independent `save_graphs_path` for each decive to save the IR files to a different path. For example:
+
+```python
+device_id = os.getenv("DEVICE_ID")
+context.set_context(save_graphs=True, save_graphs_path="path/to/ir/files"+device_id)
+```
+
+After the training command is executed, the following files are generated in the specified directory: the IR files starting with digits and underscores are generated during the ME diagram compilation. The calculation diagram is saved in each phase of the `pipeline`. Let's see the important phases, For examples, the `parse` phase parses the `construct` function of the entrance. The `symbol_resolve` phase recursively parses other functions and objects directly or indirectly referenced by the entry function. The `abstract_specialize` phase, type derivation and `shape` derivation are performed. The `optimize` phase, hardware-independent optimization is performed, The automatic differential and automatic parallel functions are also performed. The `validate` phase, the compiled compute graph is verified. The `task_emit` phase, the computing graph is transferred to the backend for further processing. The calculation graph is executed in the `execute` phase.
+
+```text
+.
+├── 00_parse_[xxxx].ir
+├── 00_parse.dat
+├── 00_parse.dot
+├── 01_symbol_resolve_[xxxx].ir
+├── 01_symbol_resolve.dat
+├── 01_symbol_resolve.dot
+├── 02_combine_like_graphs_[xxxx].ir
+├── 02_combine_like_graphs.dat
+├── 02_combine_like_graphs.dot
+├── 03_inference_opt_prepare_[xxxx].ir
+├── 03_inference_opt_prepare.dat
+├── 03_inference_opt_prepare.dot
+├── 04_abstract_specialize_[xxxx].ir
+├── 04_abstract_specialize.dat
+├── 04_abstract_specialize.dot
+├── 05_inline_[xxxx].ir
+├── 05_inline.dat
+├── 05_inline.dot
+├── 06_py_pre_ad_[xxxx].ir
+├── 06_py_pre_ad.dat
+├── 06_py_pre_ad.dot
+├── 07_pipeline_split_[xxxx].ir
+├── 07_pipeline_split.dat
+├── 07_pipeline_split.dot
+├── 08_optimize_[xxxx].ir
+├── 08_optimize.dat
+├── 08_optimize.dot
+├── 09_py_opt_[xxxx].ir
+├── 09_py_opt.dat
+├── 09_py_opt.dot
+├── 10_validate_[xxxx].ir
+├── 10_validate.dat
+├── 10_validate.dot
+├── 11_task_emit_[xxxx].ir
+├── 11_task_emit.dat
+├── 11_task_emit.dot
+├── 12_execute_[xxxx].ir
+├── 12_execute.dat
+├── 12_execute.dot
+...
+```
+
+## IR File Contents Introduction
+
+The following is an example to describe the contents of the IR file.
+
+```python
+import mindspore.context as context
+import mindspore.nn as nn
+from mindspore import Tensor
+from mindspore import dtype as mstype
+
+context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
+context.set_context(save_graphs=True, save_graphs_path="./ir_files")
+
+class Net(nn.Cell):
+ def __init__(self):
+ super().__init__()
+
+ def construct(self, x, y):
+ x = x + y
+ x = x * y
+ return x
+
+x = Tensor(3, mstype.float32)
+y = Tensor(2, mstype.float32)
+net = Net()
+out = net(x, y)
+print(out)
+```
+
+Use a text editing software (for example, vi) to open the `12_execute_[xxxx].ir` file. The file contents are as follows:
+
+```text
+1 #IR entry : @6_5_1_construct_wrapper.15
+ 2 #attrs :
+ 3 check_set_strategy_valid_once_only : 1
+ 4 #Total params : 2
+ 5
+ 6 %para1_x : Notice:
+>After several optimizations by the compiler, the node may undergo several changes (such as operator splitting and operator merging). The source code parsing call stack information of the node may not be in a one-to-one correspondence with the script. This is only an auxiliary method.
+ +## Dump Required Data from the IR File + +The following code comes from `lenet.py` in ModelZoo LeNet sample, Assume that you want to dump the first convolutional layer, that is, the `x = self.conv1(x)` data in the following code. + +```python +class LeNet5(nn.Cell): + def __init__(self, num_class=10, num_channel=1, include_top=True): + super(LeNet5, self).__init__() + self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid') + self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid') + self.relu = nn.ReLU() + self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2) + self.include_top = include_top + if self.include_top: + self.flatten = nn.Flatten() + self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02)) + self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02)) + self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02)) + + + def construct(self, x): + x = self.conv1(x) + x = self.relu(x) + x = self.max_pool2d(x) + x = self.conv2(x) + x = self.relu(x) + x = self.max_pool2d(x) + if not self.include_top: + return x + x = self.flatten(x) + x = self.relu(self.fc1(x)) + x = self.relu(self.fc2(x)) + x = self.fc3(x) + return x +``` + +Generally, graph 0, `hwopt_d_end_graph_0_[xxxx].ir`, indicates the data subgraph (if the dataset_sink_mode is enabled), and graph 1 indicates the backbone network. So, search for `x = self.conv1(x)` in the dumped `hwopt_d_end_graph_1_[xxxx].ir`file, 4 results are obtained, 3 of them are `Cast` and `TransData`, skipping these operators generated by the precision conversion and format conversion optimization, we finally locate in lines 213 to 221, that is, `%24(equivoutput) = Conv2D(%23, %19)...`, corresponding to `conv1` in the network. In this way, you can obtain the op name (in the brackets of line 216, `Default/network-TrainOneStepWithLossScaleCell/network-WithLossCell/_backbone-LeNet5/conv1-Conv2d/Conv2D-op89`) in the compiled diagram from the following information. + +```text +... + 213 %24(equivoutput) = Conv2D(%23, %19) {instance name: conv2d} primitive_attrs: {pri_format: NC1HWC0, stride: (1, 1, 1, 1), pad: (0, 0, 0, 0), pad_mode: valid, out_channel: 6, mode: 1 , dilation: (1, 1, 1, 1), output_names: [output], group: 1, format: NCHW, visited: true, offset_a: 0, kernel_size: (5, 5), groups: 1, input_names: [x, w], pad_list: (0, 0, 0, 0), IsF eatureMapOutput: true, IsFeatureMapInputList: (0)} + 214 : (