mct-nightly 2.2.0.20241221.519__py3-none-any.whl → 2.2.0.20241223.525__py3-none-any.whl

model_compression_toolkit/target_platform_capabilities/schema/v1.py

@@ -21,8 +21,6 @@ from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.constants import FLOAT_BITWIDTH
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.constants import OPS_SET_LIST
-from model_compression_toolkit.target_platform_capabilities.target_platform.current_tp_model import \
-    _current_tp_model
 
 class OperatorSetNames(Enum):
     OPSET_CONV = "Conv"
@@ -61,7 +59,6 @@ class OperatorSetNames(Enum):
     OPSET_DROPOUT = "Dropout"
     OPSET_SPLIT = "Split"
     OPSET_CHUNK = "Chunk"
-    OPSET_UNBIND = "Unbind"
     OPSET_MAXPOOL = "MaxPool"
     OPSET_SIZE = "Size"
     OPSET_SHAPE = "Shape"
@@ -74,6 +71,7 @@ class OperatorSetNames(Enum):
     OPSET_ZERO_PADDING2d = "ZeroPadding2D"
     OPSET_CAST = "Cast"
     OPSET_STRIDED_SLICE = "StridedSlice"
+    OPSET_SSD_POST_PROCESS = "SSDPostProcess"
 
     @classmethod
     def get_values(cls):
@@ -225,10 +223,10 @@ class QuantizationConfigOptions:
     QuantizationConfigOptions wraps a set of quantization configurations to consider during the quantization of an operator.
 
     Attributes:
-        quantization_config_list (List[OpQuantizationConfig]): List of possible OpQuantizationConfig to gather.
+        quantization_configurations (Tuple[OpQuantizationConfig]): Tuple of possible OpQuantizationConfig to gather.
         base_config (Optional[OpQuantizationConfig]): Fallback OpQuantizationConfig to use when optimizing the model in a non-mixed-precision manner.
     """
-    quantization_config_list: List[OpQuantizationConfig]
+    quantization_configurations: Tuple[OpQuantizationConfig]
     base_config: Optional[OpQuantizationConfig] = None
 
     def __post_init__(self):
@@ -236,32 +234,32 @@ class QuantizationConfigOptions:
         Post-initialization processing for input validation.
 
         Raises:
-            Logger critical if quantization_config_list is not a list, contains invalid elements, or if base_config is not set correctly.
+            Logger critical if quantization_configurations is not a tuple, contains invalid elements, or if base_config is not set correctly.
         """
-        # Validate `quantization_config_list`
-        if not isinstance(self.quantization_config_list, list):
+        # Validate `quantization_configurations`
+        if not isinstance(self.quantization_configurations, tuple):
             Logger.critical(
-                f"'quantization_config_list' must be a list, but received: {type(self.quantization_config_list)}.") # pragma: no cover
-        for cfg in self.quantization_config_list:
+                f"'quantization_configurations' must be a tuple, but received: {type(self.quantization_configurations)}.") # pragma: no cover
+        for cfg in self.quantization_configurations:
             if not isinstance(cfg, OpQuantizationConfig):
                 Logger.critical(
                     f"Each option must be an instance of 'OpQuantizationConfig', but found an object of type: {type(cfg)}.") # pragma: no cover
 
         # Handle base_config
-        if len(self.quantization_config_list) > 1:
+        if len(self.quantization_configurations) > 1:
             if self.base_config is None:
                 Logger.critical(f"For multiple configurations, a 'base_config' is required for non-mixed-precision optimization.") # pragma: no cover
-            if not any(self.base_config == cfg for cfg in self.quantization_config_list):
-                Logger.critical(f"'base_config' must be included in the quantization config options list.") # pragma: no cover
-        elif len(self.quantization_config_list) == 1:
+            if not any(self.base_config == cfg for cfg in self.quantization_configurations):
+                Logger.critical(f"'base_config' must be included in the quantization config options.") # pragma: no cover
+        elif len(self.quantization_configurations) == 1:
             if self.base_config is None:
-                object.__setattr__(self, 'base_config', self.quantization_config_list[0])
-            elif self.base_config != self.quantization_config_list[0]:
+                object.__setattr__(self, 'base_config', self.quantization_configurations[0])
+            elif self.base_config != self.quantization_configurations[0]:
                 Logger.critical(
-                    "'base_config' should be the same as the sole item in 'quantization_config_list'.") # pragma: no cover
+                    "'base_config' should be the same as the sole item in 'quantization_configurations'.") # pragma: no cover
 
-        elif len(self.quantization_config_list) == 0:
-            Logger.critical("'QuantizationConfigOptions' requires at least one 'OpQuantizationConfig'. The provided list is empty.") # pragma: no cover
+        elif len(self.quantization_configurations) == 0:
+            Logger.critical("'QuantizationConfigOptions' requires at least one 'OpQuantizationConfig'. The provided configurations is empty.") # pragma: no cover
 
     def clone_and_edit(self, **kwargs) -> 'QuantizationConfigOptions':
         """
@@ -274,10 +272,10 @@ class QuantizationConfigOptions:
             A new instance of QuantizationConfigOptions with updated configurations.
         """
         updated_base_config = replace(self.base_config, **kwargs)
-        updated_configs_list = [
-            replace(cfg, **kwargs) for cfg in self.quantization_config_list
+        updated_configs = [
+            replace(cfg, **kwargs) for cfg in self.quantization_configurations
         ]
-        return replace(self, base_config=updated_base_config, quantization_config_list=updated_configs_list)
+        return replace(self, base_config=updated_base_config, quantization_configurations=tuple(updated_configs))
 
     def clone_and_edit_weight_attribute(self, attrs: List[str] = None, **kwargs) -> 'QuantizationConfigOptions':
         """
@@ -292,7 +290,7 @@ class QuantizationConfigOptions:
         """
         updated_base_config = self.base_config
         updated_configs = []
-        for qc in self.quantization_config_list:
+        for qc in self.quantization_configurations:
             if attrs is None:
                 attrs_to_update = list(qc.attr_weights_configs_mapping.keys())
             else:
@@ -300,7 +298,7 @@ class QuantizationConfigOptions:
             # Ensure all attributes exist in the config
             for attr in attrs_to_update:
                 if attr not in qc.attr_weights_configs_mapping:
-                    Logger.critical(f"{attr} does not exist in {qc}.")
+                    Logger.critical(f"{attr} does not exist in {qc}.") # pragma: no cover
             updated_attr_mapping = {
                 attr: qc.attr_weights_configs_mapping[attr].clone_and_edit(**kwargs)
                 for attr in attrs_to_update
@@ -308,7 +306,7 @@ class QuantizationConfigOptions:
             if qc == updated_base_config:
                 updated_base_config = replace(updated_base_config, attr_weights_configs_mapping=updated_attr_mapping)
             updated_configs.append(replace(qc, attr_weights_configs_mapping=updated_attr_mapping))
-        return replace(self, base_config=updated_base_config, quantization_config_list=updated_configs)
+        return replace(self, base_config=updated_base_config, quantization_configurations=tuple(updated_configs))
 
     def clone_and_map_weights_attr_keys(self, layer_attrs_mapping: Optional[Dict[str, str]]) -> 'QuantizationConfigOptions':
         """
@@ -322,7 +320,7 @@ class QuantizationConfigOptions:
         """
         updated_configs = []
         new_base_config = self.base_config
-        for qc in self.quantization_config_list:
+        for qc in self.quantization_configurations:
             if layer_attrs_mapping is None:
                 new_attr_mapping = {}
             else:
@@ -333,7 +331,7 @@ class QuantizationConfigOptions:
             if qc == self.base_config:
                 new_base_config = replace(qc, attr_weights_configs_mapping=new_attr_mapping)
             updated_configs.append(replace(qc, attr_weights_configs_mapping=new_attr_mapping))
-        return replace(self, base_config=new_base_config, quantization_config_list=updated_configs)
+        return replace(self, base_config=new_base_config, quantization_configurations=tuple(updated_configs))
 
     def get_info(self) -> Dict[str, Any]:
         """
@@ -342,7 +340,7 @@ class QuantizationConfigOptions:
         Returns:
             dict: Information about the quantization configuration options as a dictionary.
         """
-        return {f'option {i}': cfg.get_info() for i, cfg in enumerate(self.quantization_config_list)}
+        return {f'option {i}': cfg.get_info() for i, cfg in enumerate(self.quantization_configurations)}
 
 
 @dataclass(frozen=True)
@@ -350,22 +348,7 @@ class TargetPlatformModelComponent:
     """
     Component of TargetPlatformModel (Fusing, OperatorsSet, etc.).
     """
-
-    def __post_init__(self):
-        """
-        Post-initialization to register the component with the current TargetPlatformModel.
-        """
-        _current_tp_model.get().append_component(self)
-
-    def get_info(self) -> Dict[str, Any]:
-        """
-        Get information about the component to display.
-
-        Returns:
-            Dict[str, Any]: Returns an empty dictionary. The actual component should override
-                            this method to provide relevant information.
-        """
-        return {}
+    pass
 
 
 @dataclass(frozen=True)
@@ -374,12 +357,7 @@ class OperatorsSetBase(TargetPlatformModelComponent):
     Base class to represent a set of a target platform model component of operator set types.
     Inherits from TargetPlatformModelComponent.
     """
-    def __post_init__(self):
-        """
-        Post-initialization to ensure the component is registered with the TargetPlatformModel.
-        Calls the parent class's __post_init__ method to append this component to the current TargetPlatformModel.
-        """
-        super().__post_init__()
+    pass
 
 
 @dataclass(frozen=True)
@@ -394,23 +372,9 @@ class OperatorsSet(OperatorsSetBase):
         is_default (bool): Indicates whether this set is the default quantization configuration
                            for the TargetPlatformModel or a fusing set.
     """
-    name: str
+    name: Union[str, OperatorSetNames]
     qc_options: QuantizationConfigOptions = None
 
-    def __post_init__(self):
-        """
-        Post-initialization processing to mark the operator set as default if applicable.
-
-        Calls the parent class's __post_init__ method and sets `is_default` to True
-        if this set corresponds to the default quantization configuration for the
-        TargetPlatformModel or if it is a fusing set.
-
-        """
-        super().__post_init__()
-        is_fusing_set = self.qc_options is None
-        is_default = _current_tp_model.get().default_qco == self.qc_options or is_fusing_set
-        object.__setattr__(self, 'is_default', is_default)
-
     def get_info(self) -> Dict[str, Any]:
         """
         Get information about the set as a dictionary.
@@ -419,83 +383,67 @@ class OperatorsSet(OperatorsSetBase):
             Dict[str, Any]: A dictionary containing the set name and
                             whether it is the default quantization configuration.
         """
-        return {"name": self.name,
-                "is_default_qc": self.is_default}
+        return {"name": self.name}
 
 
 @dataclass(frozen=True)
 class OperatorSetConcat(OperatorsSetBase):
     """
-    Concatenate a list of operator sets to treat them similarly in different places (like fusing).
+    Concatenate a tuple of operator sets to treat them similarly in different places (like fusing).
 
     Attributes:
-        op_set_list (List[OperatorsSet]): List of operator sets to group.
+        operators_set (Tuple[OperatorsSet]): Tuple of operator sets to group.
         qc_options (None): Configuration options for the set, always None for concatenated sets.
-        name (str): Concatenated name generated from the names of the operator sets in the list.
+        name (str): Concatenated name generated from the names of the operator sets.
     """
-    op_set_list: List[OperatorsSet] = field(default_factory=list)
+    operators_set: Tuple[OperatorsSet]
     qc_options: None = field(default=None, init=False)
-    name: str = None
 
     def __post_init__(self):
         """
         Post-initialization processing to generate the concatenated name and set it as the `name` attribute.
 
         Calls the parent class's __post_init__ method and creates a concatenated name
-        by joining the names of all operator sets in `op_set_list`.
+        by joining the names of all operator sets in `operators_set`.
         """
-        super().__post_init__()
         # Generate the concatenated name from the operator sets
-        concatenated_name = "_".join([op.name for op in self.op_set_list])
+        concatenated_name = "_".join([op.name.value if hasattr(op.name, "value") else op.name for op in self.operators_set])
         # Set the inherited name attribute using `object.__setattr__` since the dataclass is frozen
         object.__setattr__(self, "name", concatenated_name)
 
-    def get_info(self) -> Dict[str, Any]:
-        """
-        Get information about the concatenated set as a dictionary.
-
-        Returns:
-            Dict[str, Any]: A dictionary containing the concatenated name and
-                            the list of names of the operator sets in `op_set_list`.
-        """
-        return {"name": self.name,
-                OPS_SET_LIST: [s.name for s in self.op_set_list]}
-
 
 @dataclass(frozen=True)
 class Fusing(TargetPlatformModelComponent):
     """
-    Fusing defines a list of operators that should be combined and treated as a single operator,
+    Fusing defines a tuple of operators that should be combined and treated as a single operator,
     hence no quantization is applied between them.
 
     Attributes:
-        operator_groups_list (Tuple[Union[OperatorsSet, OperatorSetConcat]]): A list of operator groups,
+        operator_groups (Tuple[Union[OperatorsSet, OperatorSetConcat]]): A tuple of operator groups,
                                                                               each being either an OperatorSetConcat or an OperatorsSet.
         name (str): The name for the Fusing instance. If not provided, it is generated from the operator groups' names.
     """
-    operator_groups_list: Tuple[Union[OperatorsSet, OperatorSetConcat]]
-    name: str = None
+    operator_groups: Tuple[Union[OperatorsSet, OperatorSetConcat]]
 
     def __post_init__(self):
         """
         Post-initialization processing for input validation and name generation.
 
-        Calls the parent class's __post_init__ method, validates the operator_groups_list,
+        Calls the parent class's __post_init__ method, validates the operator_groups,
         and generates the name if not explicitly provided.
 
         Raises:
-            Logger critical if operator_groups_list is not a list or if it contains fewer than two operators.
+            Logger critical if operator_groups is not a tuple or if it contains fewer than two operators.
         """
-        super().__post_init__()
-        # Validate the operator_groups_list
-        if not isinstance(self.operator_groups_list, list):
+        # Validate the operator_groups
+        if not isinstance(self.operator_groups, tuple):
             Logger.critical(
-                f"List of operator groups should be of type list but is {type(self.operator_groups_list)}.") # pragma: no cover
-        if len(self.operator_groups_list) < 2:
+                f"Operator groups should be of type 'tuple' but is {type(self.operator_groups)}.") # pragma: no cover
+        if len(self.operator_groups) < 2:
             Logger.critical("Fusing cannot be created for a single operator.") # pragma: no cover
 
         # Generate the name from the operator groups if not provided
-        generated_name = '_'.join([x.name for x in self.operator_groups_list])
+        generated_name = '_'.join([x.name.value if hasattr(x.name, 'value') else x.name for x in self.operator_groups])
         object.__setattr__(self, 'name', generated_name)
 
     def contains(self, other: Any) -> bool:
@@ -512,11 +460,11 @@ class Fusing(TargetPlatformModelComponent):
             return False
 
         # Check for containment by comparing operator groups
-        for i in range(len(self.operator_groups_list) - len(other.operator_groups_list) + 1):
-            for j in range(len(other.operator_groups_list)):
-                if self.operator_groups_list[i + j] != other.operator_groups_list[j] and not (
-                        isinstance(self.operator_groups_list[i + j], OperatorSetConcat) and (
-                        other.operator_groups_list[j] in self.operator_groups_list[i + j].op_set_list)):
+        for i in range(len(self.operator_groups) - len(other.operator_groups) + 1):
+            for j in range(len(other.operator_groups)):
+                if self.operator_groups[i + j] != other.operator_groups[j] and not (
+                        isinstance(self.operator_groups[i + j], OperatorSetConcat) and (
+                        other.operator_groups[j] in self.operator_groups[i + j].operators_set)):
                     break
             else:
                 # If all checks pass, the other Fusing instance is contained
@@ -534,8 +482,8 @@ class Fusing(TargetPlatformModelComponent):
                                         or just the sequence of operator groups if no name is set.
         """
         if self.name is not None:
-            return {self.name: ' -> '.join([x.name for x in self.operator_groups_list])}
-        return ' -> '.join([x.name for x in self.operator_groups_list])
+            return {self.name: ' -> '.join([x.name for x in self.operator_groups])}
+        return ' -> '.join([x.name for x in self.operator_groups])
 
 
 @dataclass(frozen=True)
@@ -550,8 +498,8 @@ class TargetPlatformModel:
         tpc_platform_type (Optional[str]): Type of the platform for the Target Platform Configuration.
         add_metadata (bool): Flag to determine if metadata should be added.
         name (str): Name of the Target Platform Model.
-        operator_set (List[OperatorsSetBase]): List of operator sets within the model.
-        fusing_patterns (List[Fusing]): List of fusing patterns for the model.
+        operator_set (Tuple[OperatorsSetBase]): Tuple of operator sets within the model.
+        fusing_patterns (Tuple[Fusing]): Tuple of fusing patterns for the model.
         is_simd_padding (bool): Indicates if SIMD padding is applied.
         SCHEMA_VERSION (int): Version of the schema for the Target Platform Model.
     """
@@ -561,8 +509,8 @@ class TargetPlatformModel:
     tpc_platform_type: Optional[str]
     add_metadata: bool = True
     name: str = "default_tp_model"
-    operator_set: List[OperatorsSetBase] = field(default_factory=list)
-    fusing_patterns: List[Fusing] = field(default_factory=list)
+    operator_set: Tuple[OperatorsSetBase] = None
+    fusing_patterns: Tuple[Fusing] = None
     is_simd_padding: bool = False
 
     SCHEMA_VERSION: int = 1
@@ -578,26 +526,12 @@ class TargetPlatformModel:
         # Validate `default_qco`
         if not isinstance(self.default_qco, QuantizationConfigOptions):
             Logger.critical("'default_qco' must be an instance of QuantizationConfigOptions.") # pragma: no cover
-        if len(self.default_qco.quantization_config_list) != 1:
+        if len(self.default_qco.quantization_configurations) != 1:
             Logger.critical("Default QuantizationConfigOptions must contain exactly one option.") # pragma: no cover
 
-    def append_component(self, tp_model_component: TargetPlatformModelComponent):
-        """
-        Attach a TargetPlatformModel component to the model (like Fusing or OperatorsSet).
-
-        Args:
-            tp_model_component (TargetPlatformModelComponent): Component to attach to the model.
-
-        Raises:
-            Logger critical if the component is not an instance of Fusing or OperatorsSetBase.
-        """
-        if isinstance(tp_model_component, Fusing):
-            self.fusing_patterns.append(tp_model_component)
-        elif isinstance(tp_model_component, OperatorsSetBase):
-            self.operator_set.append(tp_model_component)
-        else:
-            Logger.critical(
-                f"Attempted to append an unrecognized TargetPlatformModelComponent of type: {type(tp_model_component)}.") # pragma: no cover
+        opsets_names = [op.name.value if hasattr(op.name, "value") else op.name for op in self.operator_set] if self.operator_set else []
+        if len(set(opsets_names)) != len(opsets_names):
+            Logger.critical("Operator Sets must have unique names.")  # pragma: no cover
 
     def get_info(self) -> Dict[str, Any]:
         """
@@ -608,51 +542,10 @@ class TargetPlatformModel:
         """
         return {
             "Model name": self.name,
-            "Operators sets": [o.get_info() for o in self.operator_set],
-            "Fusing patterns": [f.get_info() for f in self.fusing_patterns],
+            "Operators sets": [o.get_info() for o in self.operator_set] if self.operator_set else [],
+            "Fusing patterns": [f.get_info() for f in self.fusing_patterns] if self.fusing_patterns else [],
         }
 
-    def __validate_model(self):
-        """
-        Validate the model's configuration to ensure its integrity.
-
-        Raises:
-            Logger critical if the model contains multiple operator sets with the same name.
-        """
-        opsets_names = [op.name for op in self.operator_set]
-        if len(set(opsets_names)) != len(opsets_names):
-            Logger.critical("Operator Sets must have unique names.") # pragma: no cover
-
-    def __enter__(self) -> 'TargetPlatformModel':
-        """
-        Start defining the TargetPlatformModel using a 'with' statement.
-
-        Returns:
-            TargetPlatformModel: The initialized TargetPlatformModel object.
-        """
-        _current_tp_model.set(self)
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb) -> 'TargetPlatformModel':
-        """
-        Finalize and validate the TargetPlatformModel at the end of the 'with' clause.
-
-        Args:
-            exc_type: Exception type, if any occurred.
-            exc_value: Exception value, if any occurred.
-            tb: Traceback object, if an exception occurred.
-
-        Raises:
-            The exception raised in the 'with' block, if any.
-
-        Returns:
-            TargetPlatformModel: The validated TargetPlatformModel object.
-        """
-        if exc_value is not None:
-            raise exc_value
-        self.__validate_model()
-        _current_tp_model.reset()
-        return self
 
     def show(self):
         """

model_compression_toolkit/target_platform_capabilities/target_platform/__init__.py

@@ -15,7 +15,6 @@
 
 from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attribute_filter import AttributeFilter
 from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import TargetPlatformCapabilities, OperationsSetToLayers, Smaller, SmallerEq, NotEq, Eq, GreaterEq, Greater, LayerFilterParams, OperationsToLayers, get_current_tpc
-from model_compression_toolkit.target_platform_capabilities.target_platform.target_platform_model import get_default_quantization_config_options
 from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel, OperatorsSet, \
     OperatorSetConcat, Signedness, AttributeQuantizationConfig, OpQuantizationConfig, QuantizationConfigOptions, Fusing
 

model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/operations_to_layers.py

@@ -90,7 +90,7 @@ class OperationsToLayers:
                 return o.layers
         if isinstance(op, OperatorSetConcat):  # If its a concat - return all layers from all OperatorsSets that in the OperatorSetConcat
             layers = []
-            for o in op.op_set_list:
+            for o in op.operators_set:
                 layers.extend(self.get_layers_by_op(o))
             return layers
         Logger.warning(f'{op.name} is not in model.')

model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/target_platform_capabilities.py

@@ -100,8 +100,10 @@ class TargetPlatformCapabilities(ImmutableClass):
 
         """
         res = []
+        if self.tp_model.fusing_patterns is None:
+            return res
         for p in self.tp_model.fusing_patterns:
-            ops = [self.get_layers_by_opset(x) for x in p.operator_groups_list]
+            ops = [self.get_layers_by_opset(x) for x in p.operator_groups]
             res.extend(itertools.product(*ops))
         return [list(x) for x in res]
 
@@ -207,9 +209,10 @@ class TargetPlatformCapabilities(ImmutableClass):
         Remove OperatorSets names from the list of the unused sets (so a warning
         will not be displayed).
         """
-        for f in self.tp_model.fusing_patterns:
-            for s in f.operator_groups_list:
-                self.remove_opset_from_not_used_list(s.name)
+        if self.tp_model.fusing_patterns is not None:
+            for f in self.tp_model.fusing_patterns:
+                for s in f.operator_groups:
+                    self.remove_opset_from_not_used_list(s.name)
 
     def remove_opset_from_not_used_list(self,
                                         opset_to_remove: str):

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/tp_model.py

@@ -153,7 +153,54 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     # of possible configurations to consider when quantizing a set of operations (in mixed-precision, for example).
     # If the QuantizationConfigOptions contains only one configuration,
     # this configuration will be used for the operation quantization:
-    default_configuration_options = schema.QuantizationConfigOptions([default_config])
+    default_configuration_options = schema.QuantizationConfigOptions(tuple([default_config]))
+
+    # Create Mixed-Precision quantization configuration options from the given list of OpQuantizationConfig objects
+    mixed_precision_configuration_options = schema.QuantizationConfigOptions(tuple(mixed_precision_cfg_list),
+                                                                             base_config=base_config)
+
+    # Create an OperatorsSet to represent a set of operations.
+    # Each OperatorsSet has a unique label.
+    # If a quantization configuration options is passed, these options will
+    # be used for operations that will be attached to this set's label.
+    # Otherwise, it will be a configure-less set (used in fusing):
+    operator_set = []
+    fusing_patterns = []
+
+    operator_set.append(schema.OperatorsSet("NoQuantization",
+                           default_configuration_options.clone_and_edit(enable_activation_quantization=False)
+                           .clone_and_edit_weight_attribute(enable_weights_quantization=False)))
+
+    # Define operator sets that use mixed_precision_configuration_options:
+    conv = schema.OperatorsSet("Conv", mixed_precision_configuration_options)
+    fc = schema.OperatorsSet("FullyConnected", mixed_precision_configuration_options)
+
+    # Define operations sets without quantization configuration
+    # options (useful for creating fusing patterns, for example):
+    any_relu = schema.OperatorsSet("AnyReLU")
+    add = schema.OperatorsSet("Add")
+    sub = schema.OperatorsSet("Sub")
+    mul = schema.OperatorsSet("Mul")
+    div = schema.OperatorsSet("Div")
+    prelu = schema.OperatorsSet("PReLU")
+    swish = schema.OperatorsSet("Swish")
+    sigmoid = schema.OperatorsSet("Sigmoid")
+    tanh = schema.OperatorsSet("Tanh")
+
+    operator_set.extend([conv, fc, any_relu, add, sub, mul, div, prelu, swish, sigmoid, tanh])
+    # Combine multiple operators into a single operator to avoid quantization between
+    # them. To do this we define fusing patterns using the OperatorsSets that were created.
+    # To group multiple sets with regard to fusing, an OperatorSetConcat can be created
+    activations_after_conv_to_fuse = schema.OperatorSetConcat([any_relu, swish, prelu, sigmoid, tanh])
+    activations_after_fc_to_fuse = schema.OperatorSetConcat([any_relu, swish, sigmoid])
+    any_binary = schema.OperatorSetConcat([add, sub, mul, div])
+
+    # ------------------- #
+    # Fusions
+    # ------------------- #
+    fusing_patterns.append(schema.Fusing((conv, activations_after_conv_to_fuse)))
+    fusing_patterns.append(schema.Fusing((fc, activations_after_fc_to_fuse)))
+    fusing_patterns.append(schema.Fusing((any_binary, any_relu)))
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
@@ -163,57 +210,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_minor_version=1,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,
+        operator_set=tuple(operator_set),
+        fusing_patterns=tuple(fusing_patterns),
         name=name,
         add_metadata=False,
         is_simd_padding=True)
-
-    # To start defining the model's components (such as operator sets, and fusing patterns),
-    # use 'with' the TargetPlatformModel instance, and create them as below:
-    with generated_tpc:
-        # Create an OperatorsSet to represent a set of operations.
-        # Each OperatorsSet has a unique label.
-        # If a quantization configuration options is passed, these options will
-        # be used for operations that will be attached to this set's label.
-        # Otherwise, it will be a configure-less set (used in fusing):
-
-        # May suit for operations like: Dropout, Reshape, etc.
-        default_qco = tp.get_default_quantization_config_options()
-        schema.OperatorsSet("NoQuantization",
-                               default_qco.clone_and_edit(enable_activation_quantization=False)
-                               .clone_and_edit_weight_attribute(enable_weights_quantization=False))
-
-        # Create Mixed-Precision quantization configuration options from the given list of OpQuantizationConfig objects
-        mixed_precision_configuration_options = schema.QuantizationConfigOptions(mixed_precision_cfg_list,
-                                                                                    base_config=base_config)
-
-        # Define operator sets that use mixed_precision_configuration_options:
-        conv = schema.OperatorsSet("Conv", mixed_precision_configuration_options)
-        fc = schema.OperatorsSet("FullyConnected", mixed_precision_configuration_options)
-
-        # Define operations sets without quantization configuration
-        # options (useful for creating fusing patterns, for example):
-        any_relu = schema.OperatorsSet("AnyReLU")
-        add = schema.OperatorsSet("Add")
-        sub = schema.OperatorsSet("Sub")
-        mul = schema.OperatorsSet("Mul")
-        div = schema.OperatorsSet("Div")
-        prelu = schema.OperatorsSet("PReLU")
-        swish = schema.OperatorsSet("Swish")
-        sigmoid = schema.OperatorsSet("Sigmoid")
-        tanh = schema.OperatorsSet("Tanh")
-
-        # Combine multiple operators into a single operator to avoid quantization between
-        # them. To do this we define fusing patterns using the OperatorsSets that were created.
-        # To group multiple sets with regard to fusing, an OperatorSetConcat can be created
-        activations_after_conv_to_fuse = schema.OperatorSetConcat([any_relu, swish, prelu, sigmoid, tanh])
-        activations_after_fc_to_fuse = schema.OperatorSetConcat([any_relu, swish, sigmoid])
-        any_binary = schema.OperatorSetConcat([add, sub, mul, div])
-
-        # ------------------- #
-        # Fusions
-        # ------------------- #
-        schema.Fusing([conv, activations_after_conv_to_fuse])
-        schema.Fusing([fc, activations_after_fc_to_fuse])
-        schema.Fusing([any_binary, any_relu])
-
     return generated_tpc