1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
# SPDX-FileCopyrightText: Copyright 2022-2023, Arm Limited and/or its affiliates.
# SPDX-License-Identifier: Apache-2.0
"""Reports module."""
from __future__ import annotations
from pathlib import Path
from typing import Any
from typing import Callable
from mlia.backend.tosa_checker.compat import Operator
from mlia.backend.tosa_checker.compat import TOSACompatibilityInfo
from mlia.core.advice_generation import Advice
from mlia.core.metadata import Metadata
from mlia.core.metadata import MLIAMetadata
from mlia.core.metadata import ModelMetadata
from mlia.core.reporters import report_advice
from mlia.core.reporting import Cell
from mlia.core.reporting import Column
from mlia.core.reporting import CompoundReport
from mlia.core.reporting import Format
from mlia.core.reporting import NestedReport
from mlia.core.reporting import Report
from mlia.core.reporting import ReportItem
from mlia.core.reporting import Table
from mlia.nn.tensorflow.tflite_compat import TFLiteCompatibilityInfo
from mlia.target.common.reporters import report_tflite_compatiblity
from mlia.target.tosa.config import TOSAConfiguration
from mlia.target.tosa.metadata import TOSAMetadata
from mlia.utils.console import style_improvement
from mlia.utils.types import is_list_of
class MetadataDisplay(Metadata): # pylint: disable=too-few-public-methods
"""TOSA metadata display items."""
def __init__(self, model_path: Path) -> None:
"""Init MetadataDisplay."""
self.model_path = model_path
super().__init__("Metadata")
def get_metadata(self) -> dict:
"""Combine all necessary elements for display."""
all_data = {
data_dict.name: data_dict.data_dict
for data_dict in (
TOSAMetadata(),
MLIAMetadata(),
ModelMetadata(self.model_path),
)
}
return all_data
def report_target(target_config: TOSAConfiguration) -> Report:
"""Generate report for the target."""
return NestedReport(
"Target information",
"target",
[
ReportItem("Target", alias="target", value=target_config.target),
],
)
def report_metadata(data: MetadataDisplay) -> Report:
"""Generate report for the metadata."""
items: list[ReportItem] = []
for key, sub_dict in data.data_dict.items():
nested_items = [
ReportItem(key, alias=key, value=val) for key, val in sub_dict.items()
]
items.append(ReportItem(key, alias=key, nested_items=nested_items))
return NestedReport("Metadata", "metadata", items)
def report_tosa_operators(ops: list[Operator]) -> Report:
"""Generate report for the operators."""
return Table(
[
Column("#", only_for=["plain_text"]),
Column(
"Operator location",
alias="operator_location",
fmt=Format(wrap_width=30),
),
Column("Operator name", alias="operator_name", fmt=Format(wrap_width=20)),
Column(
"TOSA compatibility",
alias="is_tosa_compatible",
fmt=Format(wrap_width=25),
),
],
[
(
index + 1,
op.location,
op.name,
Cell(
op.is_tosa_compatible,
Format(
style=style_improvement(op.is_tosa_compatible),
str_fmt=lambda v: "Compatible" if v else "Not compatible",
),
),
)
for index, op in enumerate(ops)
],
name="Operators",
alias="operators",
)
def report_tosa_exception(exc: Exception | None) -> Report:
"""Generate report for exception thrown by tosa."""
return NestedReport(
"TOSA exception",
"exception",
[
ReportItem("TOSA exception", alias="exception", value=repr(exc)),
],
)
def report_tosa_errors(err: list[str] | None) -> Report:
"""Generate report for errors thrown by tosa."""
message = "".join(err) if err else None
return NestedReport(
"TOSA stderr",
"stderr",
[
ReportItem(
"TOSA stderr",
alias="stderr",
value=message,
),
],
)
def report_tosa_compatibility(compat_info: TOSACompatibilityInfo) -> Report:
"""Generate combined report for all compatibility info."""
report_ops = report_tosa_operators(compat_info.operators)
report_exception = report_tosa_exception(compat_info.exception)
report_errors = report_tosa_errors(compat_info.errors)
return CompoundReport([report_ops, report_exception, report_errors])
def tosa_formatters(data: Any) -> Callable[[Any], Report]:
"""Find appropriate formatter for the provided data."""
if is_list_of(data, Advice):
return report_advice
if isinstance(data, TOSAConfiguration):
return report_target
if isinstance(data, MetadataDisplay):
return report_metadata
if is_list_of(data, Operator):
return report_tosa_operators
if isinstance(data, TOSACompatibilityInfo):
return report_tosa_compatibility
if isinstance(data, TFLiteCompatibilityInfo):
return report_tflite_compatiblity
raise Exception(f"Unable to find appropriate formatter for {data}")
|
