**Refactor Target Platform Capabilities - Phase 2**

- Convert all schema classes to immutable dataclasses, replacing existing methods with equivalent dataclass methods (e.g., `replace`).
- Ensure all schema classes are strictly immutable to enhance reliability and maintain consistency.
- Update target platform model versions to align with the new class structure.
- Refactor tests to support and validate the updated class types and functionality.

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

@@ -164,7 +164,8 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,
         name=name,
-        add_metadata=False)
+        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:
@@ -175,8 +176,6 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # be used for operations that will be attached to this set's label.
         # Otherwise, it will be a configure-less set (used in fusing):
 
-        generated_tpc.set_simd_padding(is_simd_padding=True)
-
         # May suit for operations like: Dropout, Reshape, etc.
         default_qco = tp.get_default_quantization_config_options()
         schema.OperatorsSet("NoQuantization",
@@ -206,9 +205,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -201,9 +201,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -197,9 +197,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -166,7 +166,8 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,
         add_metadata=True,
-        name=name)
+        name=name,
+        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:
@@ -177,8 +178,6 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # be used for operations that will be attached to this set's label.
         # Otherwise, it will be a configure-less set (used in fusing):
 
-        generated_tpm.set_simd_padding(is_simd_padding=True)
-
         # May suit for operations like: Dropout, Reshape, etc.
         default_qco = tp.get_default_quantization_config_options()
         schema.OperatorsSet("NoQuantization",
@@ -208,9 +207,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -203,9 +203,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -187,7 +187,8 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,
         add_metadata=True,
-        name=name)
+        name=name,
+        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:
@@ -198,8 +199,6 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # be used for operations that will be attached to this set's label.
         # Otherwise, it will be a configure-less set (used in fusing):
 
-        generated_tpm.set_simd_padding(is_simd_padding=True)
-
         # May suit for operations like: Dropout, Reshape, etc.
         default_qco = tp.get_default_quantization_config_options()
         schema.OperatorsSet("NoQuantization",
@@ -231,9 +230,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -214,9 +214,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -15,7 +15,7 @@
 from typing import List, Tuple
 
 import model_compression_toolkit as mct
-import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
+import model_compression_toolkit.target_platform_capabilities.schema.v1 as schema
 from model_compression_toolkit.constants import FLOAT_BITWIDTH
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, BIAS_ATTR, WEIGHTS_N_BITS, \
     IMX500_TP_MODEL
@@ -235,7 +235,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_minor_version=4,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,
-        add_metadata=True, name=name)
+        add_metadata=True,
+        name=name,
+        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:
@@ -246,8 +248,6 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # be used for operations that will be attached to this set's label.
         # Otherwise, it will be a configure-less set (used in fusing):
 
-        generated_tpm.set_simd_padding(is_simd_padding=True)
-
         # May suit for operations like: Dropout, Reshape, etc.
         default_qco = tp.get_default_quantization_config_options()
         schema.OperatorsSet(OPSET_NO_QUANTIZATION,
@@ -294,11 +294,11 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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, gelu, hardswish, hardsigmoid)
-        activations_after_fc_to_fuse = schema.OperatorSetConcat(any_relu, swish, sigmoid, tanh, gelu,
-                                                                   hardswish, hardsigmoid)
-        any_binary = schema.OperatorSetConcat(add, sub, mul, div)
+        activations_after_conv_to_fuse = schema.OperatorSetConcat([any_relu, swish, prelu, sigmoid,
+                                                                     tanh, gelu, hardswish, hardsigmoid])
+        activations_after_fc_to_fuse = schema.OperatorSetConcat([any_relu, swish, sigmoid, tanh, gelu,
+                                                                   hardswish, hardsigmoid])
+        any_binary = schema.OperatorSetConcat([add, sub, mul, div])
 
         # ------------------- #
         # Fusions

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

@@ -180,11 +180,11 @@ def generate_tp_model(default_config: OpQuantizationConfig,
                                    fixed_zero_point=-128, fixed_scale=1 / 256))
 
         conv2d = schema.OperatorsSet("Conv2d")
-        kernel = schema.OperatorSetConcat(conv2d, fc)
+        kernel = schema.OperatorSetConcat([conv2d, fc])
 
         relu = schema.OperatorsSet("Relu")
         elu = schema.OperatorsSet("Elu")
-        activations_to_fuse = schema.OperatorSetConcat(relu, elu)
+        activations_to_fuse = schema.OperatorSetConcat([relu, elu])
 
         batch_norm = schema.OperatorsSet("BatchNorm")
         bias_add = schema.OperatorsSet("BiasAdd")

tests/common_tests/test_tp_model.py

@@ -55,7 +55,7 @@ def test_immutable_tp(self):
             with model:
                 schema.OperatorsSet("opset")
             model.operator_set = []
-        self.assertEqual('Immutable class. Can\'t edit attributes.', str(e.exception))
+        self.assertEqual("cannot assign to field 'operator_set'", str(e.exception))
 
     def test_default_options_more_than_single_qc(self):
         test_qco = schema.QuantizationConfigOptions([TEST_QC, TEST_QC], base_config=TEST_QC)
@@ -76,8 +76,6 @@ def test_tp_model_show(self):
         with tpm:
             a = schema.OperatorsSet("opA")
 
-        tpm.show()
-
 
 class OpsetTest(unittest.TestCase):
 
@@ -114,7 +112,7 @@ def test_opset_concat(self):
             b = schema.OperatorsSet('opset_B',
                                     get_default_quantization_config_options().clone_and_edit(activation_n_bits=2))
             schema.OperatorsSet('opset_C')  # Just add it without using it in concat
-            schema.OperatorSetConcat(a, b)
+            schema.OperatorSetConcat([a, b])
         self.assertEqual(len(hm.operator_set), 4)
         self.assertTrue(hm.is_opset_in_model("opset_A_opset_B"))
         self.assertTrue(hm.get_config_options_by_operators_set('opset_A_opset_B') is None)
@@ -136,14 +134,14 @@ def test_non_unique_opset(self):
 class QCOptionsTest(unittest.TestCase):
 
     def test_empty_qc_options(self):
-        with self.assertRaises(AssertionError) as e:
+        with self.assertRaises(Exception) as e:
             schema.QuantizationConfigOptions([])
         self.assertEqual(
             "'QuantizationConfigOptions' requires at least one 'OpQuantizationConfig'. The provided list is empty.",
             str(e.exception))
 
     def test_list_of_no_qc(self):
-        with self.assertRaises(AssertionError) as e:
+        with self.assertRaises(Exception) as e:
             schema.QuantizationConfigOptions([TEST_QC, 3])
         self.assertEqual(
             'Each option must be an instance of \'OpQuantizationConfig\', but found an object of type: <class \'int\'>.',
@@ -186,7 +184,7 @@ def test_fusing_single_opset(self):
             add = schema.OperatorsSet("add")
             with self.assertRaises(Exception) as e:
                 schema.Fusing([add])
-            self.assertEqual('Fusing can not be created for a single operators group', str(e.exception))
+            self.assertEqual('Fusing cannot be created for a single operator.', str(e.exception))
 
     def test_fusing_contains(self):
         hm = schema.TargetPlatformModel(
@@ -220,7 +218,7 @@ def test_fusing_contains_with_opset_concat(self):
             conv = schema.OperatorsSet("conv")
             add = schema.OperatorsSet("add")
             tanh = schema.OperatorsSet("tanh")
-            add_tanh = schema.OperatorSetConcat(add, tanh)
+            add_tanh = schema.OperatorSetConcat([add, tanh])
             schema.Fusing([conv, add])
             schema.Fusing([conv, add_tanh])
             schema.Fusing([conv, add, tanh])

tests/keras_tests/exporter_tests/tflite_int8/imx500_int8_tp_model.py

@@ -95,9 +95,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         swish = schema.OperatorsSet("Swish")
         sigmoid = schema.OperatorsSet("Sigmoid")
         tanh = schema.OperatorsSet("Tanh")
-        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)
+        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])
         schema.Fusing([conv, activations_after_conv_to_fuse])
         schema.Fusing([fc, activations_after_fc_to_fuse])
         schema.Fusing([any_binary, any_relu])

tests/keras_tests/feature_networks_tests/feature_networks/activation_16bit_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+from dataclasses import replace
+
 import numpy as np
 import tensorflow as tf
 
@@ -34,8 +36,8 @@ def get_tpc(self):
         tpc = mct.get_target_platform_capabilities(TENSORFLOW, IMX500_TP_MODEL, 'v4')
         # Force Mul base_config to 16bit only
         mul_op_set = get_op_set('Mul', tpc.tp_model.operator_set)
-        mul_op_set.qc_options.base_config = [l for l in mul_op_set.qc_options.quantization_config_list if l.activation_n_bits == 16][0]
-        tpc.layer2qco[tf.multiply].base_config = mul_op_set.qc_options.base_config
+        base_config = [l for l in mul_op_set.qc_options.quantization_config_list if l.activation_n_bits == 16][0]
+        tpc.layer2qco[tf.multiply] = replace(tpc.layer2qco[tf.multiply], base_config=base_config)
         return tpc
 
     def create_networks(self):
@@ -67,8 +69,8 @@ class Activation16BitMixedPrecisionTest(Activation16BitTest):
     def get_tpc(self):
         tpc = mct.get_target_platform_capabilities(TENSORFLOW, IMX500_TP_MODEL, 'v3')
         mul_op_set = get_op_set('Mul', tpc.tp_model.operator_set)
-        mul_op_set.qc_options.base_config = [l for l in mul_op_set.qc_options.quantization_config_list if l.activation_n_bits == 16][0]
-        tpc.layer2qco[tf.multiply].base_config = mul_op_set.qc_options.base_config
+        base_config = [l for l in mul_op_set.qc_options.quantization_config_list if l.activation_n_bits == 16][0]
+        tpc.layer2qco[tf.multiply] = replace(tpc.layer2qco[tf.multiply], base_config=base_config)
         mul_op_set.qc_options.quantization_config_list.extend(
             [mul_op_set.qc_options.base_config.clone_and_edit(activation_n_bits=4),
              mul_op_set.qc_options.base_config.clone_and_edit(activation_n_bits=2)])