MLIA-411 Report Cortex-A operator compatibility

Check input model for Arm NN TensorFlow Lite Delegate 22.08 support.

Change-Id: I1253c4c0b294c5283e08f0a39561b922ef0f62e6

1 files changed, 53 insertions, 4 deletions

diff --git a/src/mlia/devices/cortexa/data_analysis.py b/src/mlia/devices/cortexa/data_analysis.py
index d2b6f35..9f6d82b 100644
--- a/src/mlia/devices/cortexa/data_analysis.py
+++ b/src/mlia/devices/cortexa/data_analysis.py
@@ -3,13 +3,16 @@
 """Cortex-A data analysis module."""
 from __future__ import annotations
 
+from collections import defaultdict
 from dataclasses import dataclass
+from dataclasses import field
 from functools import singledispatchmethod
 
 from mlia.core.common import DataItem
 from mlia.core.data_analysis import Fact
 from mlia.core.data_analysis import FactExtractor
 from mlia.devices.cortexa.operators import CortexACompatibilityInfo
+from mlia.devices.cortexa.operators import Operator
 from mlia.nn.tensorflow.tflite_compat import TFLiteCompatibilityInfo
 from mlia.nn.tensorflow.tflite_compat import TFLiteConversionErrorCode
 
@@ -27,9 +30,38 @@ class CortexADataAnalyzer(FactExtractor):
     ) -> None:
         """Analyse operator compatibility information."""
         if data_item.cortex_a_compatible:
-            self.add_fact(ModelIsCortexACompatible())
+            self.add_fact(ModelIsCortexACompatible(data_item.backend_info))
         else:
-            self.add_fact(ModelIsNotCortexACompatible())
+            unsupported_ops = set()
+            activation_func_support: defaultdict[
+                str, ModelIsNotCortexACompatible.ActivationFunctionSupport
+            ] = defaultdict(ModelIsNotCortexACompatible.ActivationFunctionSupport)
+            for oper in data_item.operators:
+                if oper.support_type == Operator.SupportType.OP_NOT_SUPPORTED:
+                    unsupported_ops.add(oper.full_name)
+
+                if oper.support_type == Operator.SupportType.ACTIVATION_NOT_SUPPORTED:
+                    # Add used but unsupported actication functions
+                    activation_func_support[oper.full_name].used_unsupported.add(
+                        oper.activation_func.name
+                    )
+                    # Add supported activation functions
+                    activation_func_support[oper.full_name].supported.update(
+                        oper.supported_activation_functions
+                    )
+
+            assert (
+                unsupported_ops or activation_func_support or not data_item.operators
+            ), (
+                "The model is marked as not compatible with Cortex-A but there "
+                "are no unsupported ops activation functions listed."
+            )
+
+            self.add_fact(
+                ModelIsNotCortexACompatible(
+                    data_item.backend_info, unsupported_ops, activation_func_support
+                )
+            )
 
     @analyze_data.register
     def analyze_tflite_compatibility(self, data_item: TFLiteCompatibilityInfo) -> None:
@@ -52,14 +84,31 @@ class CortexADataAnalyzer(FactExtractor):
 
 
 @dataclass
-class ModelIsCortexACompatible(Fact):
+class CortexACompatibility(Fact):
+    """Base class for Cortex-A compatibility providing backend info."""
+
+    backend_info: str
+
+
+@dataclass
+class ModelIsCortexACompatible(CortexACompatibility):
     """Model is completely compatible with Cortex-A."""
 
 
 @dataclass
-class ModelIsNotCortexACompatible(Fact):
+class ModelIsNotCortexACompatible(CortexACompatibility):
     """Model is not compatible with Cortex-A."""
 
+    @dataclass
+    class ActivationFunctionSupport:
+        """Activation function support per operator."""
+
+        used_unsupported: set[str] = field(default_factory=set)
+        supported: set[str] = field(default_factory=set)
+
+    unsupported_ops: set[str]
+    activation_func_support: dict[str, ActivationFunctionSupport]
+
 
 @dataclass
 class ModelIsNotTFLiteCompatible(Fact):