"<font size=\"3\">Purpose of this analysis pass is to return the number of similar nodes in a dictionary. So first an onnx model is loaded. In this example a trained brevitas model is used. It was exported from brevitas and saved as .onnx file. With the help of `import onnx` the load function can be accessed. As argument it takes the model path.</font>\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import onnx\n",
"onnx_model = onnx.load('LFC.onnx')"
"onnx_model = onnx.load('LFCW1A1.onnx')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Here a picture or a call for onnx_model in netron**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<font size=\"3\">The onnx model has to be converted to a format that can be processed by FINN. This is done with ModelWrapper. As described in the short introduction, this is the format an analysis pass takes as input.</font>"
]
},
{
"cell_type": "code",
"execution_count": 6,
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
...
...
@@ -44,12 +58,12 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"**Here a picture or a call for onnx_model in netron**"
"<font size=\"3\">The idea is to count all nodes that have the same operation type. The result should contain the operation types and the corresponding number of nodes that occur in the model. At the beginning an empty dictionary is created which is filled by the function and returned as result to the user at the end of the analysis.</font>"
]
},
{
"cell_type": "code",
"execution_count": 3,
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
...
...
@@ -63,9 +77,16 @@
" return count_dict"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<font size=\"3\">The function takes the model as input and iterates over the nodes. Then it is checked whether there is already an entry for the operation type in the dictionary. If this is not the case, an entry is created and set to `1`. If there is already an entry, it is incremented. If all nodes in the model have been iterated, the filled dictionary is returned.</font>"
]
},
{
"cell_type": "code",
"execution_count": 7,
"execution_count": 6,
"metadata": {},
"outputs": [
{
...
...
%% Cell type:markdown id: tags:
# FINN - Analysis passes
--------------------------------------
* traverses the graph structure and produces information about certain properties
* input: ModelWrapper
* return dictionary of named properties that the analysis extracts
*<fontsize="3">traverses the graph structure and produces information about certain properties</font>
*<fontsize="3">input: ModelWrapper</font>
*<fontsize="3">return dictionary of named properties that the analysis extracts</font>
%% Cell type:markdown id: tags:
## Example - Quantity analysis of nodes in onnx graph
<fontsize="3">Purpose of this analysis pass is to return the number of similar nodes in a dictionary. So first an onnx model is loaded. In this example a trained brevitas model is used. It was exported from brevitas and saved as .onnx file. With the help of `import onnx` the load function can be accessed. As argument it takes the model path.</font>
%% Cell type:code id: tags:
``` python
importonnx
onnx_model=onnx.load('LFC.onnx')
onnx_model=onnx.load('LFCW1A1.onnx')
```
%% Cell type:markdown id: tags:
**Here a picture or a call for onnx_model in netron**
%% Cell type:markdown id: tags:
<fontsize="3">The onnx model has to be converted to a format that can be processed by FINN. This is done with ModelWrapper. As described in the short introduction, this is the format an analysis pass takes as input.</font>
%% Cell type:code id: tags:
``` python
fromfinn.core.modelwrapperimportModelWrapper
onnx_model=ModelWrapper(onnx_model)
```
%% Cell type:markdown id: tags:
**Here a picture or a call for onnx_model in netron**
<fontsize="3">The idea is to count all nodes that have the same operation type. The result should contain the operation types and the corresponding number of nodes that occur in the model. At the beginning an empty dictionary is created which is filled by the function and returned as result to the user at the end of the analysis.</font>
%% Cell type:code id: tags:
``` python
defcount_equal_nodes(model):
count_dict={}
fornodeinmodel.graph.node:
ifnode.op_typeincount_dict:
count_dict[node.op_type]+=1
else:
count_dict[node.op_type]=1
returncount_dict
```
%% Cell type:markdown id: tags:
<fontsize="3">The function takes the model as input and iterates over the nodes. Then it is checked whether there is already an entry for the operation type in the dictionary. If this is not the case, an entry is created and set to `1`. If there is already an entry, it is incremented. If all nodes in the model have been iterated, the filled dictionary is returned.</font>
