mct-nightly 2.2.0.20241230.534__py3-none-any.whl → 2.2.0.20250102.111338__py3-none-any.whl

model_compression_toolkit/target_platform_capabilities/schema/v1.py

@@ -14,13 +14,13 @@
 # ==============================================================================
 import pprint
 
-from dataclasses import replace, dataclass, asdict, field
 from enum import Enum
-from typing import Dict, Any, Union, Tuple, List, Optional
+from typing import Dict, Any, Union, Tuple, List, Optional, Literal, Annotated
 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 pydantic import BaseModel, Field, root_validator, validator, PositiveInt, PrivateAttr
+
 
 class OperatorSetNames(Enum):
     OPSET_CONV = "Conv"
@@ -92,8 +92,7 @@ class Signedness(Enum):
     UNSIGNED = 2
 
 
-@dataclass(frozen=True)
-class AttributeQuantizationConfig:
+class AttributeQuantizationConfig(BaseModel):
     """
     Holds the quantization configuration of a weight attribute of a layer.
 
@@ -103,27 +102,22 @@ class AttributeQuantizationConfig:
         weights_per_channel_threshold (bool): Indicates whether to quantize the weights per-channel or per-tensor.
         enable_weights_quantization (bool): Indicates whether to quantize the model weights or not.
         lut_values_bitwidth (Optional[int]): Number of bits to use when quantizing in a look-up table.
-                                               If None, defaults to 8 in hptq; otherwise, it uses the provided value.
+                                            If None, defaults to 8 in hptq; otherwise, it uses the provided value.
     """
     weights_quantization_method: QuantizationMethod = QuantizationMethod.POWER_OF_TWO
-    weights_n_bits: int = FLOAT_BITWIDTH
+    weights_n_bits: PositiveInt = FLOAT_BITWIDTH
     weights_per_channel_threshold: bool = False
     enable_weights_quantization: bool = False
     lut_values_bitwidth: Optional[int] = None
 
-    def __post_init__(self):
-        """
-        Post-initialization processing for input validation.
+    class Config:
+        # Makes the model immutable (frozen)
+        frozen = True
 
-        Raises:
-            Logger critical if attributes are of incorrect type or have invalid values.
-        """
-        if not isinstance(self.weights_n_bits, int) or self.weights_n_bits < 1:
-            Logger.critical("weights_n_bits must be a positive integer.") # pragma: no cover
-        if not isinstance(self.enable_weights_quantization, bool):
-            Logger.critical("enable_weights_quantization must be a boolean.") # pragma: no cover
-        if self.lut_values_bitwidth is not None and not isinstance(self.lut_values_bitwidth, int):
-            Logger.critical("lut_values_bitwidth must be an integer or None.") # pragma: no cover
+    @property
+    def field_names(self) -> list:
+        """Return a list of field names for the model."""
+        return list(self.__fields__.keys())
 
     def clone_and_edit(self, **kwargs) -> 'AttributeQuantizationConfig':
         """
@@ -135,11 +129,10 @@ class AttributeQuantizationConfig:
         Returns:
             AttributeQuantizationConfig: A new instance of AttributeQuantizationConfig with updated attributes.
         """
-        return replace(self, **kwargs)
+        return self.copy(update=kwargs)
 
 
-@dataclass(frozen=True)
-class OpQuantizationConfig:
+class OpQuantizationConfig(BaseModel):
     """
     OpQuantizationConfig is a class to configure the quantization parameters of an operator.
 
@@ -148,39 +141,45 @@ class OpQuantizationConfig:
         attr_weights_configs_mapping (Dict[str, AttributeQuantizationConfig]): A mapping between an op attribute name and its quantization configuration.
         activation_quantization_method (QuantizationMethod): Which method to use from QuantizationMethod for activation quantization.
         activation_n_bits (int): Number of bits to quantize the activations.
-        supported_input_activation_n_bits (int or Tuple[int]): Number of bits that operator accepts as input.
+        supported_input_activation_n_bits (Union[int, Tuple[int, ...]]): Number of bits that operator accepts as input.
         enable_activation_quantization (bool): Whether to quantize the model activations or not.
         quantization_preserving (bool): Whether quantization parameters should be the same for an operator's input and output.
-        fixed_scale (float): Scale to use for an operator quantization parameters.
-        fixed_zero_point (int): Zero-point to use for an operator quantization parameters.
-        simd_size (int): Per op integer representing the Single Instruction, Multiple Data (SIMD) width of an operator. It indicates the number of data elements that can be fetched and processed simultaneously in a single instruction.
-        signedness (bool): Set activation quantization signedness.
-
+        fixed_scale (Optional[float]): Scale to use for an operator quantization parameters.
+        fixed_zero_point (Optional[int]): Zero-point to use for an operator quantization parameters.
+        simd_size (Optional[int]): Per op integer representing the Single Instruction, Multiple Data (SIMD) width of an operator. It indicates the number of data elements that can be fetched and processed simultaneously in a single instruction.
+        signedness (Signedness): Set activation quantization signedness.
     """
     default_weight_attr_config: AttributeQuantizationConfig
     attr_weights_configs_mapping: Dict[str, AttributeQuantizationConfig]
     activation_quantization_method: QuantizationMethod
     activation_n_bits: int
-    supported_input_activation_n_bits: Union[int, Tuple[int]]
+    supported_input_activation_n_bits: Union[int, Tuple[int, ...]]
     enable_activation_quantization: bool
     quantization_preserving: bool
-    fixed_scale: float
-    fixed_zero_point: int
-    simd_size: int
+    fixed_scale: Optional[float]
+    fixed_zero_point: Optional[int]
+    simd_size: Optional[int]
     signedness: Signedness
 
-    def __post_init__(self):
-        """
-        Post-initialization processing for input validation.
+    class Config:
+        frozen = True
 
-        Raises:
-            Logger critical if supported_input_activation_n_bits is not an int or a tuple of ints.
+    @validator('supported_input_activation_n_bits', pre=True, allow_reuse=True)
+    def validate_supported_input_activation_n_bits(cls, v):
         """
-        if isinstance(self.supported_input_activation_n_bits, int):
-            object.__setattr__(self, 'supported_input_activation_n_bits', (self.supported_input_activation_n_bits,))
-        elif not isinstance(self.supported_input_activation_n_bits, tuple):
-            Logger.critical(
-                f"Supported_input_activation_n_bits only accepts int or tuple of ints, but got {type(self.supported_input_activation_n_bits)}")  # pragma: no cover
+        Validate and process the supported_input_activation_n_bits field.
+        Converts an int to a tuple containing that int.
+        Ensures that if a tuple is provided, all elements are ints.
+        """
+
+        if isinstance(v, int):
+            v = (v,)
+
+        # When loading from JSON, lists are returned. If the value is a list, convert it to a tuple.
+        if isinstance(v, list):
+            v = tuple(v)
+
+        return v
 
     def get_info(self) -> Dict[str, Any]:
         """
@@ -189,9 +188,13 @@ class OpQuantizationConfig:
         Returns:
             dict: Information about the quantization configuration as a dictionary.
         """
-        return asdict(self)  # pragma: no cover
+        return self.dict()  # pragma: no cover
 
-    def clone_and_edit(self, attr_to_edit: Dict[str, Dict[str, Any]] = {}, **kwargs) -> 'OpQuantizationConfig':
+    def clone_and_edit(
+        self,
+        attr_to_edit: Dict[str, Dict[str, Any]] = {},
+        **kwargs: Any
+    ) -> 'OpQuantizationConfig':
         """
         Clone the quantization config and edit some of its attributes.
 
@@ -203,64 +206,87 @@ class OpQuantizationConfig:
         Returns:
             OpQuantizationConfig: Edited quantization configuration.
         """
-
         # Clone and update top-level attributes
-        updated_config = replace(self, **kwargs)
+        updated_config = self.copy(update=kwargs)
 
         # Clone and update nested immutable dataclasses in `attr_weights_configs_mapping`
         updated_attr_mapping = {
             attr_name: (attr_cfg.clone_and_edit(**attr_to_edit[attr_name])
-                        if attr_name in attr_to_edit else attr_cfg)
+                       if attr_name in attr_to_edit else attr_cfg)
             for attr_name, attr_cfg in updated_config.attr_weights_configs_mapping.items()
         }
 
         # Return a new instance with the updated attribute mapping
-        return replace(updated_config, attr_weights_configs_mapping=updated_attr_mapping)
+        return updated_config.copy(update={'attr_weights_configs_mapping': updated_attr_mapping})
 
 
-@dataclass(frozen=True)
-class QuantizationConfigOptions:
+class QuantizationConfigOptions(BaseModel):
     """
     QuantizationConfigOptions wraps a set of quantization configurations to consider during the quantization of an operator.
 
     Attributes:
-        quantization_configurations (Tuple[OpQuantizationConfig]): Tuple 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_configurations: Tuple[OpQuantizationConfig]
+    quantization_configurations: Tuple[OpQuantizationConfig, ...]
     base_config: Optional[OpQuantizationConfig] = None
 
-    def __post_init__(self):
+    class Config:
+        frozen = True
+
+    @root_validator(pre=True, allow_reuse=True)
+    def validate_and_set_base_config(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Post-initialization processing for input validation.
+        Validate and set the base_config based on quantization_configurations.
+
+        Args:
+            values (Dict[str, Any]): Input data.
 
-        Raises:
-            Logger critical if quantization_configurations is not a tuple, contains invalid elements, or if base_config is not set correctly.
+        Returns:
+            Dict[str, Any]: Modified input data with base_config set appropriately.
         """
-        # Validate `quantization_configurations`
-        if not isinstance(self.quantization_configurations, tuple):
+        quantization_configurations = values.get('quantization_configurations', ())
+        num_configs = len(quantization_configurations)
+        base_config = values.get('base_config')
+
+        if not isinstance(quantization_configurations, (tuple, list)):
             Logger.critical(
-                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_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_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_configurations[0])
-            elif self.base_config != self.quantization_configurations[0]:
+                f"'quantization_configurations' must be a list or tuple, but received: {type(quantization_configurations)}."
+            )  # pragma: no cover
+
+        if num_configs == 0:
+            Logger.critical(
+                "'QuantizationConfigOptions' requires at least one 'OpQuantizationConfig'. The provided configurations are empty."
+            )  # pragma: no cover
+
+        if base_config is None:
+            if num_configs > 1:
                 Logger.critical(
-                    "'base_config' should be the same as the sole item in 'quantization_configurations'.") # pragma: no cover
+                    "For multiple configurations, a 'base_config' is required for non-mixed-precision optimization."
+                )  # pragma: no cover
+            else:
+                # Automatically set base_config to the sole configuration
+                base_config = quantization_configurations[0]
 
-        elif len(self.quantization_configurations) == 0:
-            Logger.critical("'QuantizationConfigOptions' requires at least one 'OpQuantizationConfig'. The provided configurations is empty.") # pragma: no cover
+
+        if base_config not in quantization_configurations:
+            Logger.critical(
+                "'base_config' must be included in the quantization config options."
+            )  # pragma: no cover
+
+        # if num_configs == 1:
+        #     if base_config != quantization_configurations[0]:
+        #         Logger.critical(
+        #             "'base_config' should be the same as the sole item in 'quantization_configurations'."
+        #         )  # pragma: no cover
+
+        values['base_config'] = base_config
+
+        # When loading from JSON, lists are returned. If the value is a list, convert it to a tuple.
+        if isinstance(quantization_configurations, list):
+            values['quantization_configurations'] = tuple(quantization_configurations)
+
+        return values
 
     def clone_and_edit(self, **kwargs) -> 'QuantizationConfigOptions':
         """
@@ -270,46 +296,71 @@ class QuantizationConfigOptions:
             **kwargs: Keyword arguments to edit in each configuration.
 
         Returns:
-            A new instance of QuantizationConfigOptions with updated configurations.
+            QuantizationConfigOptions: A new instance with updated configurations.
         """
-        updated_base_config = replace(self.base_config, **kwargs)
-        updated_configs = [
-            replace(cfg, **kwargs) for cfg in self.quantization_configurations
-        ]
-        return replace(self, base_config=updated_base_config, quantization_configurations=tuple(updated_configs))
+        # Clone and update base_config
+        updated_base_config = self.base_config.clone_and_edit(**kwargs) if self.base_config else None
+
+        # Clone and update all configurations
+        updated_configs = tuple(cfg.clone_and_edit(**kwargs) for cfg in self.quantization_configurations)
 
-    def clone_and_edit_weight_attribute(self, attrs: List[str] = None, **kwargs) -> 'QuantizationConfigOptions':
+        return self.copy(update={
+            'base_config': updated_base_config,
+            'quantization_configurations': updated_configs
+        })
+
+    def clone_and_edit_weight_attribute(
+        self,
+        attrs: Optional[List[str]] = None,
+        **kwargs
+    ) -> 'QuantizationConfigOptions':
         """
         Clones the quantization configurations and edits some of their attributes' parameters.
 
         Args:
-            attrs (List[str]): Attributes names to clone and edit their configurations. If None, updates all attributes.
-            **kwargs: Keyword arguments to edit in the attributes configuration.
+            attrs (Optional[List[str]]): Attribute names to clone and edit their configurations. If None, updates all attributes.
+            **kwargs: Keyword arguments to edit in the attributes' configuration.
 
         Returns:
-            QuantizationConfigOptions: A new instance of QuantizationConfigOptions with edited attributes configurations.
+            QuantizationConfigOptions: A new instance with edited attributes configurations.
         """
         updated_base_config = self.base_config
         updated_configs = []
+
         for qc in self.quantization_configurations:
             if attrs is None:
                 attrs_to_update = list(qc.attr_weights_configs_mapping.keys())
             else:
                 attrs_to_update = attrs
+
             # 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}.") # pragma: no cover
+                    Logger.critical(f"Attribute '{attr}' does not exist in {qc}.")  # pragma: no cover
+
+            # Update the specified attributes
             updated_attr_mapping = {
                 attr: qc.attr_weights_configs_mapping[attr].clone_and_edit(**kwargs)
                 for attr in attrs_to_update
             }
-            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_configurations=tuple(updated_configs))
 
-    def clone_and_map_weights_attr_keys(self, layer_attrs_mapping: Optional[Dict[str, str]]) -> 'QuantizationConfigOptions':
+            # If the current config is the base_config, update it accordingly
+            if qc == self.base_config:
+                updated_base_config = qc.clone_and_edit(attr_weights_configs_mapping=updated_attr_mapping)
+
+            # Update the current config with the new attribute mappings
+            updated_cfg = qc.clone_and_edit(attr_weights_configs_mapping=updated_attr_mapping)
+            updated_configs.append(updated_cfg)
+
+        return self.copy(update={
+            '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]] = None
+    ) -> 'QuantizationConfigOptions':
         """
         Clones the quantization configurations and updates keys in attribute config mappings.
 
@@ -317,22 +368,32 @@ class QuantizationConfigOptions:
             layer_attrs_mapping (Optional[Dict[str, str]]): A mapping between attribute names.
 
         Returns:
-            QuantizationConfigOptions: A new instance of QuantizationConfigOptions with updated attribute keys.
+            QuantizationConfigOptions: A new instance with updated attribute keys.
         """
-        updated_configs = []
         new_base_config = self.base_config
+        updated_configs = []
+
         for qc in self.quantization_configurations:
             if layer_attrs_mapping is None:
-                new_attr_mapping = {}
+                new_attr_mapping = qc.attr_weights_configs_mapping
             else:
                 new_attr_mapping = {
                     layer_attrs_mapping.get(attr, attr): cfg
                     for attr, cfg in qc.attr_weights_configs_mapping.items()
                 }
+
+            # If the current config is the base_config, update it accordingly
             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_configurations=tuple(updated_configs))
+                new_base_config = qc.clone_and_edit(attr_weights_configs_mapping=new_attr_mapping)
+
+            # Update the current config with the new attribute mappings
+            updated_cfg = qc.clone_and_edit(attr_weights_configs_mapping=new_attr_mapping)
+            updated_configs.append(updated_cfg)
+
+        return self.copy(update={
+            'base_config': new_base_config,
+            'quantization_configurations': tuple(updated_configs)
+        })
 
     def get_info(self) -> Dict[str, Any]:
         """
@@ -341,18 +402,16 @@ 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_configurations)}
-
+        return {f'option_{i}': cfg.get_info() for i, cfg in enumerate(self.quantization_configurations)}
 
-@dataclass(frozen=True)
-class TargetPlatformModelComponent:
+class TargetPlatformModelComponent(BaseModel):
     """
     Component of TargetPlatformModel (Fusing, OperatorsSet, etc.).
     """
-    pass
+    class Config:
+        frozen = True
 
 
-@dataclass(frozen=True)
 class OperatorsSetBase(TargetPlatformModelComponent):
     """
     Base class to represent a set of a target platform model component of operator set types.
@@ -361,91 +420,151 @@ class OperatorsSetBase(TargetPlatformModelComponent):
     pass
 
 
-@dataclass(frozen=True)
 class OperatorsSet(OperatorsSetBase):
     """
     Set of operators that are represented by a unique label.
 
     Attributes:
-        name (str): The set's label (must be unique within a TargetPlatformModel).
-        qc_options (QuantizationConfigOptions): Configuration options to use for this set of operations.
-                                                If None, it represents a fusing set.
-        is_default (bool): Indicates whether this set is the default quantization configuration
-                           for the TargetPlatformModel or a fusing set.
+        name (Union[str, OperatorSetNames]): The set's label (must be unique within a TargetPlatformModel).
+        qc_options (Optional[QuantizationConfigOptions]): Configuration options to use for this set of operations.
+            If None, it represents a fusing set.
+        type (Literal["OperatorsSet"]): Fixed type identifier.
     """
     name: Union[str, OperatorSetNames]
-    qc_options: QuantizationConfigOptions = None
+    qc_options: Optional[QuantizationConfigOptions] = None
+
+    # Define a private attribute _type
+    type: Literal["OperatorsSet"] = "OperatorsSet"
+
+    class Config:
+        frozen = True
 
     def get_info(self) -> Dict[str, Any]:
         """
         Get information about the set as a dictionary.
 
         Returns:
-            Dict[str, Any]: A dictionary containing the set name and
-                            whether it is the default quantization configuration.
+            Dict[str, Any]: A dictionary containing the set name.
         """
         return {"name": self.name}
 
 
-@dataclass(frozen=True)
 class OperatorSetConcat(OperatorsSetBase):
     """
     Concatenate a tuple of operator sets to treat them similarly in different places (like fusing).
 
     Attributes:
-        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.
+        operators_set (Tuple[OperatorsSet, ...]): Tuple of operator sets to group.
+        name (Optional[str]): Concatenated name generated from the names of the operator sets.
     """
-    operators_set: Tuple[OperatorsSet]
-    qc_options: None = field(default=None, init=False)
+    operators_set: Tuple[OperatorsSet, ...]
+    name: Optional[str] = None  # Will be set in the validator if not given
 
-    def __post_init__(self):
+    # Define a private attribute _type
+    type: Literal["OperatorSetConcat"] = "OperatorSetConcat"
+
+    class Config:
+        frozen = True
+
+    @root_validator(pre=True, allow_reuse=True)
+    def validate_and_set_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Post-initialization processing to generate the concatenated name and set it as the `name` attribute.
+        Validate the input and set the concatenated name based on the operators_set.
+
+        Args:
+            values (Dict[str, Any]): Input data.
+
+        Returns:
+            Dict[str, Any]: Modified input data with 'name' set.
+        """
+        operators_set = values['operators_set']
+
+        if len(operators_set) < 1:
+            Logger.critical("'operators_set' must contain at least one OperatorsSet") # pragma: no cover
 
-        Calls the parent class's __post_init__ method and creates a concatenated name
-        by joining the names of all operator sets in `operators_set`.
+        if values.get('name') is None:
+            # Generate the concatenated name from the operator sets
+            concatenated_name = "_".join([
+                op.name.value if isinstance(op.name, OperatorSetNames) else op.name
+                for op in operators_set
+            ])
+            values['name'] = concatenated_name
+
+        return values
+
+    def get_info(self) -> Dict[str, Any]:
         """
-        # Generate the concatenated name from the operator sets
-        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)
+        Get information about the concatenated operator sets as a dictionary.
 
+        Returns:
+            Dict[str, Any]: A dictionary containing the concatenated name and operator sets information.
+        """
+        return {
+            "name": self.name,
+            "operators_set": [op.get_info() for op in self.operators_set]
+        }
 
-@dataclass(frozen=True)
 class Fusing(TargetPlatformModelComponent):
     """
     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 (Tuple[Union[OperatorsSet, OperatorSetConcat]]): A tuple 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.
+        name (Optional[str]): The name for the Fusing instance. If not provided, it is generated from the operator groups' names.
     """
-    operator_groups: Tuple[Union[OperatorsSet, OperatorSetConcat]]
+    operator_groups: Tuple[Annotated[Union[OperatorsSet, OperatorSetConcat], Field(discriminator='type')], ...]
+    name: Optional[str] = None  # Will be set in the validator if not given.
+
+    class Config:
+        frozen = True
 
-    def __post_init__(self):
+    @root_validator(pre=True, allow_reuse=True)
+    def validate_and_set_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Post-initialization processing for input validation and name generation.
+        Validate the operator_groups and set the name by concatenating operator group names.
 
-        Calls the parent class's __post_init__ method, validates the operator_groups,
-        and generates the name if not explicitly provided.
+        Args:
+            values (Dict[str, Any]): Input data.
 
-        Raises:
-            Logger critical if operator_groups is not a tuple or if it contains fewer than two operators.
+        Returns:
+            Dict[str, Any]: Modified input data with 'name' set.
         """
-        # Validate the operator_groups
-        if not isinstance(self.operator_groups, tuple):
-            Logger.critical(
-                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
+        operator_groups = values.get('operator_groups')
 
-        # Generate the name from the operator groups if not provided
-        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)
+        # When loading from JSON, lists are returned. If the value is a list, convert it to a tuple.
+        if isinstance(operator_groups, list):
+            values['operator_groups'] = tuple(operator_groups)
+
+        if values.get('name') is None:
+            # Generate the concatenated name from the operator groups
+            concatenated_name = "_".join([
+                op.name.value if isinstance(op.name, OperatorSetNames) else op.name
+                for op in values['operator_groups']
+            ])
+            values['name'] = concatenated_name
+
+        return values
+
+    @root_validator(allow_reuse=True)
+    def validate_after_initialization(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Perform validation after the model has been instantiated.
+
+        Args:
+            values (Dict[str, Any]): The instantiated fusing.
+
+        Returns:
+            Dict[str, Any]: The validated values.
+        """
+        operator_groups = values.get('operator_groups')
+
+        # Validate that there are at least two operator groups
+        if len(operator_groups) < 2:
+            Logger.critical("Fusing cannot be created for a single operator.")  # pragma: no cover
+
+        return values
 
     def contains(self, other: Any) -> bool:
         """
@@ -483,56 +602,75 @@ 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])}
-        return ' -> '.join([x.name for x in self.operator_groups])
-
+            return {
+                self.name: ' -> '.join([
+                    x.name.value if isinstance(x.name, OperatorSetNames) else x.name
+                    for x in self.operator_groups
+                ])
+            }
+        return ' -> '.join([
+            x.name.value if isinstance(x.name, OperatorSetNames) else x.name
+            for x in self.operator_groups
+        ])
 
-@dataclass(frozen=True)
-class TargetPlatformModel:
+class TargetPlatformModel(BaseModel):
     """
     Represents the hardware configuration used for quantized model inference.
 
     Attributes:
         default_qco (QuantizationConfigOptions): Default quantization configuration options for the model.
+        operator_set (Optional[Tuple[OperatorsSet, ...]]): Tuple of operator sets within the model.
+        fusing_patterns (Optional[Tuple[Fusing, ...]]): Tuple of fusing patterns for the model.
         tpc_minor_version (Optional[int]): Minor version of the Target Platform Configuration.
         tpc_patch_version (Optional[int]): Patch version of the Target Platform Configuration.
         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 (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.
     """
     default_qco: QuantizationConfigOptions
+    operator_set: Optional[Tuple[OperatorsSet, ...]]
+    fusing_patterns: Optional[Tuple[Fusing, ...]]
     tpc_minor_version: Optional[int]
     tpc_patch_version: Optional[int]
     tpc_platform_type: Optional[str]
     add_metadata: bool = True
-    name: str = "default_tp_model"
-    operator_set: Tuple[OperatorsSetBase] = None
-    fusing_patterns: Tuple[Fusing] = None
+    name: Optional[str] = "default_tp_model"
     is_simd_padding: bool = False
 
     SCHEMA_VERSION: int = 1
 
-    def __post_init__(self):
+    class Config:
+        frozen = True
+
+    @root_validator(allow_reuse=True)
+    def validate_after_initialization(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Post-initialization processing for input validation.
+        Perform validation after the model has been instantiated.
+
+        Args:
+            values (Dict[str, Any]): The instantiated target platform model.
 
-        Raises:
-            Logger critical if the default_qco is not an instance of QuantizationConfigOptions
-            or if it contains more than one quantization configuration.
+        Returns:
+            Dict[str, Any]: The validated values.
         """
         # 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_configurations) != 1:
-            Logger.critical("Default QuantizationConfigOptions must contain exactly one option.") # 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
+        default_qco = values.get('default_qco')
+        if len(default_qco.quantization_configurations) != 1:
+            Logger.critical("Default QuantizationConfigOptions must contain exactly one option.")  # pragma: no cover
+
+        # Validate `operator_set` uniqueness
+        operator_set = values.get('operator_set')
+        if operator_set is not None:
+            opsets_names = [
+                op.name.value if isinstance(op.name, OperatorSetNames) else op.name
+                for op in operator_set
+            ]
+            if len(set(opsets_names)) != len(opsets_names):
+                Logger.critical("Operator Sets must have unique names.")  # pragma: no cover
+
+        return values
 
     def get_info(self) -> Dict[str, Any]:
         """
@@ -547,11 +685,8 @@ class TargetPlatformModel:
             "Fusing patterns": [f.get_info() for f in self.fusing_patterns] if self.fusing_patterns else [],
         }
 
-
     def show(self):
         """
-
         Display the TargetPlatformModel.
-
         """
         pprint.pprint(self.get_info(), sort_dicts=False)