mct-nightly 2.0.0.20240408.430__tar.gz → 2.0.0.20240410.422__tar.gz

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 2.0.0.20240408.430
+Version: 2.0.0.20240410.422
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/mct_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 2.0.0.20240408.430
+Version: 2.0.0.20240410.422
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/mct_nightly.egg-info/SOURCES.txt

@@ -175,6 +175,7 @@ model_compression_toolkit/core/keras/graph_substitutions/substitutions/activatio
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/batchnorm_folding.py
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/batchnorm_reconstruction.py
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/batchnorm_refusing.py
+model_compression_toolkit/core/keras/graph_substitutions/substitutions/concat_threshold_update.py
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/dwconv_to_conv.py
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/input_scaling.py
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/linear_collapsing.py
@@ -237,6 +238,7 @@ model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/__init_
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/batchnorm_folding.py
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/batchnorm_reconstruction.py
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/batchnorm_refusing.py
+model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/concat_threshold_update.py
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/const_holder_conv.py
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/functional_batch_norm.py
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/functional_layer_norm.py

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/model_compression_toolkit/__init__.py

@@ -27,4 +27,4 @@ from model_compression_toolkit import data_generation
 from model_compression_toolkit import pruning
 from model_compression_toolkit.trainable_infrastructure.keras.load_model import keras_load_quantized_model
 
-__version__ = "2.0.0.20240408.000430"
+__version__ = "2.0.0.20240410.000422"

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/model_compression_toolkit/core/analyzer.py

@@ -30,7 +30,8 @@ from model_compression_toolkit.logger import Logger
 
 def analyzer_model_quantization(representative_data_gen: Callable,
                                 tb_w: TensorboardWriter,
-                                tg: Graph,
+                                float_graph: Graph,
+                                quantized_graph: Graph,
                                 fw_impl: FrameworkImplementation,
                                 fw_info: FrameworkInfo):
     """
@@ -41,23 +42,32 @@ def analyzer_model_quantization(representative_data_gen: Callable,
     Args:
         representative_data_gen: Dataset used for calibration.
         tb_w: TensorBoardWriter object to log events.
-        tg: Graph of quantized model.
+        float_graph: Graph of float model.
+        quantized_graph: Graph of quantized model.
         fw_impl: FrameworkImplementation object with a specific framework methods implementation.
         fw_info: Information needed for quantization about the specific framework.
 
     """
     if tb_w is not None:
-        visual = NNVisualizer(tg,
+        visual = NNVisualizer(float_graph,
+                              quantized_graph,
                               fw_impl=fw_impl,
                               fw_info=fw_info)
-
-        for i, _data in enumerate(representative_data_gen()):
-            if i >= NUM_SAMPLES_DISTANCE_TENSORBOARD:
-                break
-            figure = visual.plot_distance_graph(_data,
-                                                distance_fn=compute_cs,
-                                                convert_to_range=lambda a: 1 - 2 * a)
-            tb_w.add_figure(figure, f'similarity_distance_sample_{i}')
+        if not visual.has_compare_points():
+            Logger.error(f'No comparing points were found to plot analyze similarity.')
         else:
-            Logger.warning(f'Not enough batches in representative dataset to generate {NUM_SAMPLES_DISTANCE_TENSORBOARD} figures')
+            visualized_samples = 0
+            for _data in representative_data_gen():
+                batch_size = _data[0].shape[0]
+                for sample_index in range(batch_size):
+                    if visualized_samples >= NUM_SAMPLES_DISTANCE_TENSORBOARD:
+                        break
+                    figure = visual.plot_distance_graph(_data,
+                                                        sample_index=sample_index,
+                                                        distance_fn=compute_cs,
+                                                        convert_to_range=lambda a: 1 - 2 * a)
+                    tb_w.add_figure(figure, f'similarity_distance_sample_{visualized_samples}')
+                    visualized_samples += 1
+            if visualized_samples < NUM_SAMPLES_DISTANCE_TENSORBOARD:
+                Logger.error(f'Not enough batches in representative dataset to generate {NUM_SAMPLES_DISTANCE_TENSORBOARD} figures')
         tb_w.close()

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/model_compression_toolkit/core/common/quantization/node_quantization_config.py

@@ -41,24 +41,24 @@ class BaseNodeQuantizationConfig(object):
     Base class for node quantization configuration
     """
 
-    def set_quant_config_attr(self, parameter_name: str, parameter_value: Any,
+    def set_quant_config_attr(self, config_parameter_name: str, config_parameter_value: Any,
                               *args: List[Any], **kwargs: Dict[str, Any]):
         """
         Changes a BaseNodeQuantizationConfig's parameter.
         Note that arg and kwargs are only to allow clean override in the child classes.
 
         Args:
-            parameter_name: parameter name to change.
-            parameter_value: parameter value to change.
+            config_parameter_name: parameter name to change.
+            config_parameter_value: parameter value to change.
             args: A list of additional arguments.
             kwargs: A dictionary with additional key arguments.
 
         """
 
-        if hasattr(self, parameter_name):
-            setattr(self, parameter_name, parameter_value)
+        if hasattr(self, config_parameter_name):
+            setattr(self, config_parameter_name, config_parameter_value)
         else:
-            Logger.warning(f"Parameter {parameter_name} could not be found in the node quantization config and "
+            Logger.warning(f"Parameter {config_parameter_name} could not be found in the node quantization config and "
                            f"was not updated!")
 
     def __repr__(self) -> str:
@@ -106,6 +106,7 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
         self.z_threshold = qc.z_threshold
         self.shift_negative_ratio = qc.shift_negative_ratio
         self.shift_negative_threshold_recalculation = qc.shift_negative_threshold_recalculation
+        self.concat_threshold_update = qc.concat_threshold_update
 
     def quantize_node_output(self,
                              tensors: Any) -> Any:
@@ -219,7 +220,7 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
                self.shift_negative_activation_correction == other.shift_negative_activation_correction and \
                self.z_threshold == other.z_threshold and \
                self.shift_negative_ratio == other.shift_negative_ratio and \
-               self.shift_negative_threshold_recalculation == other.shift_negative_threshold_recalculation
+               self.shift_negative_threshold_recalculation == other.shift_negative_threshold_recalculation 
 
     def __hash__(self):
         return hash((self.activation_quantization_fn,
@@ -521,7 +522,7 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
                            f"{list(attrs_with_name.keys())}.")
         return attrs_with_name
 
-    def set_quant_config_attr(self, parameter_name: str, parameter_value: Any, attr_name: str = None,
+    def set_quant_config_attr(self, config_parameter_name: str, config_parameter_value: Any, attr_name: str = None,
                               *args: List[Any], **kwargs: Dict[str, Any]):
         """
         This method overrides the parent class set_quant_config_attr to enable setting a specific weights
@@ -529,26 +530,27 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
 
         Args:
             attr_name: attribute name to change.
-            parameter_name: parameter name to change.
-            parameter_value: parameter value to change.
+            config_parameter_name: parameter name to change.
+            config_parameter_value: parameter value to change.
             args: A list of additional arguments.
             kwargs: A dictionary with additional key arguments.
 
         """
 
         if attr_name is None:
-            super(NodeWeightsQuantizationConfig, self).set_quant_config_attr(parameter_name, parameter_value,
+            super(NodeWeightsQuantizationConfig, self).set_quant_config_attr(config_parameter_name,
+                                                                             config_parameter_value,
                                                                              *args, **kwargs)
         else:
             if self.has_attribute_config(attr_name):
                 attr_cfg = self.get_attr_config(attr_name)
-                if hasattr(attr_cfg, parameter_name):
-                    setattr(attr_cfg, parameter_name, parameter_value)
+                if hasattr(attr_cfg, config_parameter_name):
+                    setattr(attr_cfg, config_parameter_name, config_parameter_value)
                 else:
-                    Logger.warning(f"Parameter {parameter_name} could not be found in the node quantization config of "
+                    Logger.warning(f"Parameter {config_parameter_name} could not be found in the node quantization config of "
                                    f"weights attribute {attr_name} and was not updated!")
             else:
-                Logger.error(f"Weights attribute {attr_name} could not be found to set parameter {parameter_name}.")
+                Logger.error(f"Weights attribute {attr_name} could not be found to set parameter {config_parameter_name}.")
 
     def __eq__(self, other: Any) -> bool:
         """

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/model_compression_toolkit/core/common/quantization/quantization_config.py

@@ -62,7 +62,8 @@ class QuantizationConfig:
                  residual_collapsing: bool = True,
                  shift_negative_ratio: float = 0.05,
                  shift_negative_threshold_recalculation: bool = False,
-                 shift_negative_params_search: bool = False):
+                 shift_negative_params_search: bool = False,
+                 concat_threshold_update: bool = False):
         """
         Class to wrap all different parameters the library quantize the input model according to.
 
@@ -117,6 +118,7 @@ class QuantizationConfig:
         self.shift_negative_ratio = shift_negative_ratio
         self.shift_negative_threshold_recalculation = shift_negative_threshold_recalculation
         self.shift_negative_params_search = shift_negative_params_search
+        self.concat_threshold_update = concat_threshold_update
 
     def __repr__(self):
         return str(self.__dict__)

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/model_compression_toolkit/core/common/quantization/quantize_graph_weights.py

@@ -23,7 +23,7 @@ from model_compression_toolkit.core.common.quantization.quantize_node import get
 from model_compression_toolkit.logger import Logger
 
 
-def quantize_graph_weights(graph: Graph) -> Graph:
+def quantize_graph_weights(graph_to_quantize: Graph) -> Graph:
     """
     Get a graph representing a model, and quantize its nodes' weights.
     Each node is quantized according to the passed framework info and quantization configuration.
@@ -31,12 +31,13 @@ def quantize_graph_weights(graph: Graph) -> Graph:
     is calculated and subtracted from the original node's bias. The graph is quantized in-place.
 
     Args:
-        graph: Graph to quantize its nodes.
+        graph_to_quantize: Graph to quantize its nodes.
 
     """
+    _quantized_graph = copy.deepcopy(graph_to_quantize)
     # Iterate over nodes in the graph and quantize each node's weights and activations
     # (according to operators groups in framework info).
-    for n in graph.nodes():
+    for n in _quantized_graph.nodes():
         for attr in n.get_node_weights_attributes():
             if n.is_weights_quantization_enabled(attr):
                 quantized_attr, io_channels_axes = \
@@ -51,4 +52,4 @@ def quantize_graph_weights(graph: Graph) -> Graph:
                 # Set the attribute to be the quantized attribute.
                 n.set_weights_by_keys(attr, quantized_attr)
 
-    return graph
+    return _quantized_graph

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/model_compression_toolkit/core/common/similarity_analyzer.py

@@ -146,7 +146,10 @@ def compute_mae(float_tensor: np.ndarray,
     return error
 
 
-def compute_cs(float_tensor: np.ndarray, fxp_tensor: np.ndarray, eps: float = 1e-8, batch: bool = False,
+def compute_cs(float_tensor: np.ndarray,
+               fxp_tensor: np.ndarray,
+               eps: float = 1e-8,
+               batch: bool = False,
                axis: int = None) -> float:
     """
     Compute the similarity between two tensor using cosine similarity.

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/model_compression_toolkit/core/common/visualization/nn_visualizer.py

@@ -12,19 +12,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+
 from typing import Tuple, List, Callable
 
 import numpy as np
 from matplotlib import pyplot as plt
 from matplotlib.figure import Figure
 
-from model_compression_toolkit.core.common.quantization.quantize_graph_weights import quantize_graph_weights
 from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
 from model_compression_toolkit.core.common.framework_info import FrameworkInfo
 from model_compression_toolkit.core.common.graph.base_node import BaseNode
 from model_compression_toolkit.core.common.model_builder_mode import ModelBuilderMode
 from model_compression_toolkit.core.common.similarity_analyzer import compute_cs
+from model_compression_toolkit.logger import Logger
 
 
 def _get_compare_points(input_graph: Graph) -> Tuple[List[BaseNode], List[str]]:
@@ -57,17 +58,21 @@ class NNVisualizer:
 
     def __init__(self,
                  graph_float: Graph,
+                 graph_quantized: Graph,
                  fw_impl: FrameworkImplementation,
                  fw_info: FrameworkInfo):
         """
         Initialize a NNVisualizer object.
         Args:
             graph_float: Float version of the graph.
+            graph_quantized: Quantized version of the graph.
+            fw_impl: Framework implementation with framework-specific methods implementation.
+            fw_info: Framework info with framework-specific information.
 
         """
 
         self.graph_float = graph_float
-        self.graph_quantized = quantize_graph_weights(graph_float)
+        self.graph_quantized = graph_quantized
         self.fw_impl = fw_impl
         self.fw_info = fw_info
 
@@ -75,6 +80,16 @@ class NNVisualizer:
         self.compare_points, self.compare_points_name = _get_compare_points(self.graph_quantized)
         self.compare_points_float, self.compare_points_name_float = _get_compare_points(self.graph_float)
 
+        if len(self.compare_points) != len(self.compare_points_float):
+            Logger.critical(f"Number of compare points in float and quantized models must be equal but "
+                            f"num of quantized compare points: {len(self.compare_points)} and "
+                            f"num of float compare points: {len(self.compare_points_float)}")
+        if len(self.compare_points_name) != len(self.compare_points_name_float):
+            Logger.critical(f"Number of compare points in float and quantized models must be equal "
+                            f"but num of quantized compare points: {len(self.compare_points_name)}"
+                            f" and num of float compare points: "
+                            f"{len(self.compare_points_name_float)}")
+
         self.quantized_model, _ = self.fw_impl.model_builder(self.graph_quantized,
                                                              mode=ModelBuilderMode.QUANTIZED,
                                                              append2output=self.compare_points,
@@ -85,8 +100,19 @@ class NNVisualizer:
                                                          append2output=self.compare_points_float,
                                                          fw_info=self.fw_info)
 
+    def has_compare_points(self) -> bool:
+        """
+
+        Returns: Whether or not compare points were found.
+
+        """
+        return len(self.compare_points_float) > 0 and len(self.compare_points) > 0 and len(
+            self.compare_points_name_float) > 0 and len(self.compare_points_name) > 0
+
+
     def plot_distance_graph(self,
                             input_image: np.ndarray,
+                            sample_index: int,
                             distance_fn: Callable = compute_cs,
                             convert_to_range: Callable = lambda a: a) -> Figure:
         """
@@ -95,6 +121,7 @@ class NNVisualizer:
 
         Args:
             input_image: Image to use as input to the networks.
+            sample_index: The index of the sample from input_image to use for comparison.
             distance_fn: Distance function to calculate the distance between two tensors.
             convert_to_range: Optional function to move the distance values into a specific range, e.g., when using
                 cosine similarity for distance, use 'lambda a: 1 - 2 * a' to convert the distance values to the range
@@ -108,7 +135,7 @@ class NNVisualizer:
         # to make the difference more noticeable when exists
         new_inputs = []
         for single_input in input_image:
-            img = single_input[0]
+            img = single_input[sample_index]
             new_inputs.append(np.expand_dims(img, axis=0))
 
         # Get outputs
@@ -123,7 +150,7 @@ class NNVisualizer:
 
         # Display the result: distance at every layer's output.
         fig = plt.figure()
-        plt.plot(distance_array)
+        plt.plot(list(range(len(distance_array))), distance_array)
         eps = 0.5
         y_limits = (min(distance_array) - eps, max(distance_array) + eps)
         plt.ylim(y_limits)

mct-nightly-2.0.0.20240410.422/model_compression_toolkit/core/keras/graph_substitutions/substitutions/concat_threshold_update.py

@@ -0,0 +1,66 @@
+# Copyright 2024 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+
+from tensorflow.keras.layers import Concatenate
+import tensorflow as tf
+
+from model_compression_toolkit.core import common
+from model_compression_toolkit.core.common import Graph, BaseNode
+from model_compression_toolkit.core.common.graph.graph_matchers import NodeOperationMatcher
+from model_compression_toolkit.constants import THRESHOLD
+
+
+
+class ConcatThresholdUpdate(common.BaseSubstitution):
+
+
+    """
+    Find concat layers and match their prior layers thresholds unless prior layer outputs to multiple layers.
+    """
+
+    def __init__(self):
+        """
+        Initialize a threshold_updater object.
+        """
+        concatination_node = NodeOperationMatcher(Concatenate) | \
+            NodeOperationMatcher(tf.concat) 
+        super().__init__(matcher_instance=concatination_node)
+
+    def substitute(self,
+                   graph: Graph,
+                   node: BaseNode) -> Graph:
+        """
+        Update previous layers thresholds to match concatinations quantization thresholds. No change if
+        previous layer outputs to multiple layers. No change in case of uniform quantization. 
+        No change in case of multiple quantization candidates (mixed precision).
+
+
+        Args:
+            graph: Graph we apply the substitution on.
+            node: Node refference to edit previous nodes thresholds.
+
+        Returns:
+            Graph after applying the substitution.
+        """
+
+        if len(node.candidates_quantization_cfg) == 1 and THRESHOLD in node.candidates_quantization_cfg[0].activation_quantization_cfg.activation_quantization_params:
+            concat_threshold = node.candidates_quantization_cfg[0].activation_quantization_cfg.activation_quantization_params[THRESHOLD]
+            prev_nodes = graph.get_prev_nodes(node)
+            for prev_node in prev_nodes:
+                if len(graph.get_next_nodes(prev_node))==1 and prev_node.type != Concatenate and prev_node.type != tf.concat:
+                    prev_node.candidates_quantization_cfg[0].activation_quantization_cfg.activation_quantization_params[THRESHOLD] = concat_threshold
+
+        return graph

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/model_compression_toolkit/core/keras/keras_implementation.py

@@ -80,7 +80,8 @@ from model_compression_toolkit.core.keras.graph_substitutions.substitutions.line
 from model_compression_toolkit.core.keras.graph_substitutions.substitutions.residual_collapsing import \
     keras_residual_collapsing
 from model_compression_toolkit.core.keras.graph_substitutions.substitutions.input_scaling import InputScaling, \
-    InputScalingWithPad
+    InputScalingWithPad 
+from model_compression_toolkit.core.keras.graph_substitutions.substitutions.concat_threshold_update import ConcatThresholdUpdate
 from model_compression_toolkit.core.keras.graph_substitutions.substitutions.relu_bound_to_power_of_2 import \
     ReLUBoundToPowerOfTwo
 from model_compression_toolkit.core.keras.graph_substitutions.substitutions.multi_head_attention_decomposition import \
@@ -300,8 +301,8 @@ class KerasImplementation(FrameworkImplementation):
         """
         return keras_op2d_add_const_collapsing()
 
-    def get_substitutions_post_statistics_collection(self, quant_config: QuantizationConfig) \
-            -> List[common.BaseSubstitution]:
+    def get_substitutions_post_statistics_collection(self, 
+                                                     quant_config: QuantizationConfig) -> List[common.BaseSubstitution]:
         """
         Return a list of the framework substitutions used after we collect statistics.
 
@@ -317,6 +318,8 @@ class KerasImplementation(FrameworkImplementation):
         if quant_config.input_scaling:
             substitutions_list.append(InputScaling())
             substitutions_list.append(InputScalingWithPad())
+        if quant_config.concat_threshold_update:
+            substitutions_list.append(ConcatThresholdUpdate())
         return substitutions_list
 
 

mct-nightly-2.0.0.20240410.422/model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/concat_threshold_update.py

@@ -0,0 +1,69 @@
+# Copyright 2024 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from typing import List
+
+import torch
+
+from model_compression_toolkit.core import common
+from model_compression_toolkit.core.common.graph.base_graph import Graph
+from model_compression_toolkit.core.common.graph.graph_matchers import NodeOperationMatcher
+from model_compression_toolkit.core.common.graph.base_node import BaseNode
+from model_compression_toolkit.constants import THRESHOLD
+
+
+class ConcatThresholdUpdate(common.BaseSubstitution):
+    """
+    Find concat layers and match their prior layers thresholds unless prior layer outputs to multiple layers.
+    """
+
+
+    def __init__(self):
+        """
+        Initialize a threshold_updater object.
+        """
+        concatination_node = NodeOperationMatcher(torch.cat) | \
+            NodeOperationMatcher(torch.concat) 
+        super().__init__(matcher_instance=concatination_node)
+
+    def substitute(self,
+                   graph: Graph,
+                   node: BaseNode) -> Graph:
+        """
+        Update previous layers thresholds to match concatinations quantization thresholds. No change if
+        previous layer outputs to multiple layers. No change in case of uniform quantization. 
+        No change in case of multiple quantization candidates (mixed precision).
+
+
+        Args:
+            graph: Graph we apply the substitution on.
+            node: Node refference to edit previous nodes thresholds.
+
+        Returns:
+            Graph after applying the substitution.
+        """
+    
+        if len(node.candidates_quantization_cfg) == 1 and THRESHOLD in node.candidates_quantization_cfg[0].activation_quantization_cfg.activation_quantization_params:
+            concat_threshold = node.candidates_quantization_cfg[0].activation_quantization_cfg.activation_quantization_params[THRESHOLD]
+            prev_nodes = graph.get_prev_nodes(node)
+            for prev_node in prev_nodes:
+                if len(graph.get_next_nodes(prev_node))==1 and prev_node.type != torch.cat and prev_node.type != torch.concat:
+                    prev_node.candidates_quantization_cfg[0].activation_quantization_cfg.activation_quantization_params[THRESHOLD] = concat_threshold
+
+        return graph
+
+
+
+

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/model_compression_toolkit/core/pytorch/pytorch_implementation.py

@@ -73,6 +73,8 @@ from model_compression_toolkit.core.pytorch.graph_substitutions.substitutions.vi
     VirtualActivationWeightsComposition
 from model_compression_toolkit.core.pytorch.graph_substitutions.substitutions.weights_activation_split import \
     WeightsActivationSplit
+from model_compression_toolkit.core.pytorch.graph_substitutions.substitutions.concat_threshold_update import \
+    ConcatThresholdUpdate
 from model_compression_toolkit.core.pytorch.hessian.activation_trace_hessian_calculator_pytorch import \
     ActivationTraceHessianCalculatorPytorch
 from model_compression_toolkit.core.pytorch.hessian.weights_trace_hessian_calculator_pytorch import \
@@ -302,6 +304,8 @@ class PytorchImplementation(FrameworkImplementation):
             substitutions_list.append(pytorch_softmax_shift())
         if quant_config.input_scaling:
             Logger.critical('Input scaling is currently not supported for Pytorch.')
+        if quant_config.concat_threshold_update:
+            substitutions_list.append(ConcatThresholdUpdate())
         return substitutions_list
 
 

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/model_compression_toolkit/gptq/keras/gptq_training.py

@@ -337,12 +337,16 @@ class KerasGPTQTrainer(GPTQTrainer):
                 node = node[0]
                 kernel_attribute = get_kernel_attribute_name_for_gptq(layer_type=node.type,
                                                                       fw_info=self.fw_info)
+                # TODO: only kernel attributes are currently trained in GPTQ, so only the kernel weights need to be updated.
+                #  To enable GPTQ for other attributes, this code needs to be modified.
                 weights, weight_quant_config, activation_quant_config = \
                     layer.weights_quantizers[kernel_attribute].update_layer_quantization_params(layer)
                 for weight_attr, weight in weights.items():
                     node.set_weights_by_keys(weight_attr, weight.numpy())
-                for config_attr, config_value in weight_quant_config.items():
-                    node.final_weights_quantization_cfg.set_quant_config_attr(config_attr, config_value)
+                for config_parameter_name, config_parameter_value in weight_quant_config.items():
+                    node.final_weights_quantization_cfg.set_quant_config_attr(config_parameter_name,
+                                                                              config_parameter_value,
+                                                                              attr_name=kernel_attribute)
                 for config_attr, config_value in activation_quant_config.items():
                     node.final_activation_quantization_cfg.set_quant_config_attr(config_attr, config_value)
                 if self.gptq_config.train_bias:

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/model_compression_toolkit/gptq/keras/quantization_facade.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+import copy
 
 from typing import Callable, Tuple
 from packaging import version
 
+from model_compression_toolkit.core.common.quantization.quantize_graph_weights import quantize_graph_weights
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 from model_compression_toolkit.gptq.common.gptq_constants import REG_DEFAULT
 from model_compression_toolkit.logger import Logger
@@ -210,6 +212,8 @@ if FOUND_TF:
                                                                   target_resource_utilization=target_resource_utilization,
                                                                   tb_w=tb_w)
 
+        float_graph = copy.deepcopy(tg)
+
         tg_gptq = gptq_runner(tg,
                               core_config,
                               gptq_config,
@@ -223,7 +227,12 @@ if FOUND_TF:
         del hessian_info_service
 
         if core_config.debug_config.analyze_similarity:
-            analyzer_model_quantization(representative_data_gen, tb_w, tg_gptq, fw_impl, fw_info)
+            analyzer_model_quantization(representative_data_gen,
+                                        tb_w,
+                                        float_graph,
+                                        tg_gptq,
+                                        fw_impl,
+                                        DEFAULT_KERAS_INFO)
 
         return get_exportable_keras_model(tg_gptq)
 

{mct-nightly-2.0.0.20240408.430 → mct-nightly-2.0.0.20240410.422}/model_compression_toolkit/gptq/pytorch/gptq_training.py

@@ -284,12 +284,16 @@ class PytorchGPTQTrainer(GPTQTrainer):
                 node = node[0]
                 kernel_attribute = get_kernel_attribute_name_for_gptq(layer_type=node.type,
                                                                       fw_info=self.fw_info)
+                # TODO: only kernel attributes are currently trained in GPTQ, so only the kernel weights need to be updated.
+                #  To enable GPTQ for other attributes, this code needs to be modified.
                 weights, weight_quant_config, activation_quant_config = \
                     layer.weights_quantizers[kernel_attribute].update_layer_quantization_params(layer)
                 for weight_attr, weight in weights.items():
                     node.set_weights_by_keys(weight_attr, self.fw_impl.to_numpy(weight))
-                for config_attr, config_value in weight_quant_config.items():
-                    node.final_weights_quantization_cfg.set_quant_config_attr(config_attr, config_value)
+                for config_parameter_name, config_parameter_value in weight_quant_config.items():
+                    node.final_weights_quantization_cfg.set_quant_config_attr(config_parameter_name,
+                                                                              config_parameter_value,
+                                                                              attr_name=kernel_attribute)
                 for config_attr, config_value in activation_quant_config.items():
                     node.final_activation_quantization_cfg.set_quant_config_attr(config_attr, config_value)
                 if self.gptq_config.train_bias and hasattr(layer.layer, BIAS):