mct-nightly 2.4.0.20250924.535__py3-none-any.whl → 2.4.2.20250926.532__py3-none-any.whl

model_compression_toolkit/xquant/common/constants.py

@@ -32,6 +32,7 @@ CUT_TOTAL_SIZE = 'cut_total_size'
 
 # Report file name:
 REPORT_FILENAME = 'quant_report.json'
+TROUBLESHOOT_REPORT_FILENAME = 'troubleshoot_report.json'
 
 # Tag to use in tensorboard for the graph we plot:
 TENSORBOARD_DEFAULT_TAG = 'xquant'

model_compression_toolkit/xquant/common/model_folding_utils.py

@@ -34,6 +34,7 @@ class ModelFoldingUtils:
     """
 
     def __init__(self,
+                 fw_info: FrameworkInfo,
                  fw_impl: FrameworkImplementation,
                  fw_default_fqc: FrameworkQuantizationCapabilities):
         """
@@ -41,9 +42,11 @@ class ModelFoldingUtils:
         and default FQC.
 
         Args:
+            fw_info: Framework-specific information.
             fw_impl: Implementation functions for the framework.
             fw_default_fqc: Default target platform capabilities for the handled framework.
         """
+        self.fw_info = fw_info
         self.fw_impl = fw_impl
         self.fw_default_fqc = fw_default_fqc
 
@@ -66,7 +69,8 @@ class ModelFoldingUtils:
         float_folded_model, _ = self.fw_impl.model_builder(
             float_graph,
             mode=ModelBuilderMode.FLOAT,
-            append2output=None
+            append2output=None,
+            fw_info=self.fw_info
         )
         return float_folded_model
 
@@ -96,6 +100,7 @@ class ModelFoldingUtils:
         graph = graph_preparation_runner(in_model=model,
                                          representative_data_gen=repr_dataset,
                                          fw_impl=self.fw_impl,
+                                         fw_info=self.fw_info,
                                          quantization_config=DEFAULTCONFIG,
                                          fqc=self.fw_default_fqc)
         return graph

model_compression_toolkit/xquant/common/tensorboard_utils.py

@@ -36,16 +36,19 @@ class TensorboardUtils:
 
     def __init__(self,
                  report_dir: str,
+                 fw_info: FrameworkInfo,
                  fw_impl: FrameworkImplementation):
         """
         Initialize the TensorboardUtils.
 
         Args:
             report_dir (str): Directory where Tensorboard logs will be stored.
+            fw_info (FrameworkInfo): Framework-specific information.
             fw_impl (FrameworkImplementation): Framework-specific implementation.
         """
         self.fw_impl = fw_impl
-        self.tb_writer = TensorboardWriter(report_dir)
+        self.fw_info = fw_info
+        self.tb_writer = TensorboardWriter(report_dir, fw_info)
         Logger.info(f"Please run: tensorboard --logdir {self.tb_writer.dir_path}")
 
     def get_graph_for_tensorboard_display(self,

model_compression_toolkit/xquant/common/xquant_config.py

@@ -14,6 +14,7 @@
 #  ==============================================================================
 
 from typing import Dict, Callable
+from model_compression_toolkit.logger import Logger
 
 
 class XQuantConfig:
@@ -25,13 +26,38 @@ class XQuantConfig:
 
     def __init__(self,
                  report_dir: str,
-                 custom_similarity_metrics: Dict[str, Callable] = None):
+                 custom_similarity_metrics: Dict[str, Callable] = None,
+                 quantize_reported_dir: str = None,
+                 threshold_quantize_error: Dict[str, float] = {"mse": 0.1, "cs": 0.1, "sqnr": 0.1},
+                 is_detect_under_threshold_quantize_error: Dict[str, bool] = {"mse": False, "cs": True, "sqnr": True},
+                 threshold_degrade_layer_ratio: float = 0.5,
+                 threshold_zscore_outlier_removal: float = 5.0,
+                 threshold_ratio_unbalanced_concatenation: float = 16.0,
+                 threshold_bitwidth_mixed_precision_with_model_output_loss_objective: int = 2
+                 ):
         """
         Initializes the configuration for explainable quantization.
 
         Args:
             report_dir (str): Directory where the reports will be saved.
             custom_similarity_metrics (Dict[str, Callable]): Custom similarity metrics to be computed between tensors of the two models. The dictionary keys are similarity metric names and the values are callables that implement the similarity metric computation.
+            quantize_reported_dir (str): Directory where the the quantization log will be saved. 
+            threshold_quantize_error (Dict[str, float]): Threshold values for detecting degradation in accuracy.
+            is_detect_under_threshold_quantize_error (Dict[str, bool]): For each threshold specified in threshold_quantize_error, True: detect the layer as degraded when the error is below the threshold.; False: detect the layer as degraded when the error is above the threshold.
+            threshold_degrade_layer_ratio (float): If the number of layers detected as degraded is large, skips the judge degradation causes Specify the ratio here.
+            threshold_zscore_outlier_removal (float): Used in judge degradation causes (Outlier Removal). Threshold for z_score to detect outliers.
+            threshold_ratio_unbalanced_concatenation (float): Used in judge degradation causes (unbalanced “concatnation”). Threshold for the multiplier of range width between concatenated layers.
+            threshold_bitwidth_mixed_precision_with_model_output_loss_objective (int): Used in judge degradation causes (Mixed precision with model output loss objective). Bitwidth of the final layer to judge insufficient bitwidth.
         """
+
         self.report_dir = report_dir
         self.custom_similarity_metrics = custom_similarity_metrics
+        self.quantize_reported_dir = quantize_reported_dir
+        if(self.quantize_reported_dir is None):
+            self.quantize_reported_dir = Logger.LOG_PATH
+        self.threshold_quantize_error = threshold_quantize_error
+        self.is_detect_under_threshold_quantize_error = is_detect_under_threshold_quantize_error
+        self.threshold_degrade_layer_ratio = threshold_degrade_layer_ratio
+        self.threshold_zscore_outlier_removal = threshold_zscore_outlier_removal
+        self.threshold_ratio_unbalanced_concatenation = threshold_ratio_unbalanced_concatenation
+        self.threshold_bitwidth_mixed_precision_with_model_output_loss_objective = threshold_bitwidth_mixed_precision_with_model_output_loss_objective

model_compression_toolkit/xquant/{common → keras}/core_report_generator.py

@@ -19,7 +19,7 @@ from model_compression_toolkit.core.common.model_collector import ModelCollector
 from model_compression_toolkit.xquant import XQuantConfig
 from model_compression_toolkit.xquant.common.constants import OUTPUT_SIMILARITY_METRICS_REPR, OUTPUT_SIMILARITY_METRICS_VAL, INTERMEDIATE_SIMILARITY_METRICS_REPR, \
     INTERMEDIATE_SIMILARITY_METRICS_VAL
-from model_compression_toolkit.xquant.common.framework_report_utils import FrameworkReportUtils
+from model_compression_toolkit.xquant.keras.framework_report_utils import FrameworkReportUtils
 
 
 def core_report_generator(float_model: Any,
@@ -50,7 +50,7 @@ def core_report_generator(float_model: Any,
 
     # Collect histograms on the float model.
     float_graph = fw_report_utils.model_folding_utils.create_float_folded_graph(float_model, repr_dataset)
-    mi = ModelCollector(float_graph, fw_report_utils.fw_impl)
+    mi = ModelCollector(float_graph, fw_report_utils.fw_impl, fw_report_utils.fw_info)
     for _data in tqdm(repr_dataset(), desc="Collecting Histograms"):
         mi.infer(_data)
 

model_compression_toolkit/xquant/keras/facade_xquant_report.py

@@ -16,13 +16,13 @@
 from typing import Callable, Dict, Any
 
 from model_compression_toolkit.verify_packages import FOUND_TF
-from model_compression_toolkit.xquant.common.core_report_generator import core_report_generator
 from model_compression_toolkit.xquant import XQuantConfig
 from model_compression_toolkit.logger import Logger
 
 if FOUND_TF:
     import keras
     from model_compression_toolkit.xquant.keras.keras_report_utils import KerasReportUtils
+    from model_compression_toolkit.xquant.keras.core_report_generator import core_report_generator
 
     def xquant_report_keras_experimental(float_model: keras.Model,
                                          quantized_model: keras.Model,

model_compression_toolkit/xquant/{common → keras}/framework_report_utils.py

@@ -20,10 +20,10 @@ from model_compression_toolkit.core.common.framework_implementation import Frame
 from model_compression_toolkit.core.common.framework_info import FrameworkInfo
 from typing import Any, Dict, Callable
 
-from model_compression_toolkit.xquant.common.constants import REPORT_FILENAME
+from model_compression_toolkit.xquant.common.constants import REPORT_FILENAME, TROUBLESHOOT_REPORT_FILENAME
 from model_compression_toolkit.xquant.common.dataset_utils import DatasetUtils
 from model_compression_toolkit.xquant.common.model_folding_utils import ModelFoldingUtils
-from model_compression_toolkit.xquant.common.similarity_calculator import SimilarityCalculator
+from model_compression_toolkit.xquant.keras.similarity_calculator import SimilarityCalculator
 from model_compression_toolkit.xquant.common.tensorboard_utils import TensorboardUtils
 from model_compression_toolkit.logger import Logger
 
@@ -34,6 +34,7 @@ class FrameworkReportUtils:
     """
 
     def __init__(self,
+                 fw_info: FrameworkInfo,
                  fw_impl: FrameworkImplementation,
                  similarity_calculator: SimilarityCalculator,
                  dataset_utils: DatasetUtils,
@@ -44,6 +45,7 @@ class FrameworkReportUtils:
         Initializes the FrameworkReportUtils class with various utility components required for generating the report.
 
         Args:
+            fw_info (FrameworkInfo): Information about the framework being used.
             fw_impl (FrameworkImplementation): The implemented functions of the framework.
             similarity_calculator (SimilarityCalculator): A utility for calculating similarity metrics.
             dataset_utils (DatasetUtils): Utilities for handling datasets.
@@ -51,6 +53,7 @@ class FrameworkReportUtils:
             tb_utils (TensorboardUtils): Utilities for TensorBoard operations.
             get_metadata_fn (Callable): Function to retrieve the metadata from the quantized model.
         """
+        self.fw_info = fw_info
         self.fw_impl = fw_impl
         self.similarity_calculator = similarity_calculator
         self.dataset_utils = dataset_utils
@@ -75,3 +78,21 @@ class FrameworkReportUtils:
 
         with open(report_file_name, 'w') as f:
             json.dump(collected_data, f, indent=4)
+
+    def dump_troubleshoot_report_to_json(self,
+                                         report_dir: str,
+                                         collected_data: Dict[str, Any]):
+        """
+        Dump the collected data (similarity, etc.) into a JSON file.
+
+        Args:
+            report_dir (str): Directory where the report will be saved.
+            collected_data (Dict[str, Any]): Data collected during report generation.
+
+        """
+        report_file_name = os.path.join(report_dir, TROUBLESHOOT_REPORT_FILENAME)
+        report_file_name = os.path.abspath(report_file_name)
+        Logger.info(f"Dumping report data to: {report_file_name}")
+
+        with open(report_file_name, 'w') as f:
+            json.dump(collected_data, f, indent=4)

model_compression_toolkit/xquant/keras/keras_report_utils.py

@@ -15,12 +15,13 @@
 
 from model_compression_toolkit import get_target_platform_capabilities
 from model_compression_toolkit.constants import TENSORFLOW
+from model_compression_toolkit.core.keras.default_framework_info import DEFAULT_KERAS_INFO
 from model_compression_toolkit.core.keras.keras_implementation import KerasImplementation
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2keras import \
     AttachTpcToKeras
-from model_compression_toolkit.xquant.common.framework_report_utils import FrameworkReportUtils
+from model_compression_toolkit.xquant.keras.framework_report_utils import FrameworkReportUtils
 from model_compression_toolkit.xquant.common.model_folding_utils import ModelFoldingUtils
-from model_compression_toolkit.xquant.common.similarity_calculator import SimilarityCalculator
+from model_compression_toolkit.xquant.keras.similarity_calculator import SimilarityCalculator
 from model_compression_toolkit.xquant.keras.dataset_utils import KerasDatasetUtils
 from model_compression_toolkit.xquant.keras.model_analyzer import KerasModelAnalyzer
 
@@ -39,6 +40,7 @@ class KerasReportUtils(FrameworkReportUtils):
         Args:
             report_dir: Logging dir path.
         """
+        fw_info = DEFAULT_KERAS_INFO
         fw_impl = KerasImplementation()
 
         # Set the default Target Platform Capabilities (TPC) for Keras.
@@ -47,7 +49,8 @@ class KerasReportUtils(FrameworkReportUtils):
         framework_platform_capabilities = attach2pytorch.attach(default_tpc)
 
         dataset_utils = KerasDatasetUtils()
-        model_folding = ModelFoldingUtils(fw_impl=fw_impl,
+        model_folding = ModelFoldingUtils(fw_info=fw_info,
+                                          fw_impl=fw_impl,
                                           fw_default_fqc=framework_platform_capabilities)
 
         similarity_calculator = SimilarityCalculator(dataset_utils=dataset_utils,
@@ -56,8 +59,10 @@ class KerasReportUtils(FrameworkReportUtils):
                                                      model_analyzer_utils=KerasModelAnalyzer())
 
         tb_utils = KerasTensorboardUtils(report_dir=report_dir,
-                                         fw_impl=fw_impl)
-        super().__init__(fw_impl,
+                                         fw_impl=fw_impl,
+                                         fw_info=fw_info)
+        super().__init__(fw_info,
+                         fw_impl,
                          similarity_calculator,
                          dataset_utils,
                          model_folding,

model_compression_toolkit/xquant/keras/similarity_calculator.py

@@ -0,0 +1,199 @@
+#  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 functools import partial
+
+from typing import Tuple, Any, Dict, Callable
+import numpy as np
+
+from model_compression_toolkit.xquant.common.constants import MODEL_OUTPUT_KEY
+from model_compression_toolkit.xquant.common.dataset_utils import DatasetUtils
+from model_compression_toolkit.xquant.common.model_analyzer import ModelAnalyzer
+from model_compression_toolkit.xquant.common.model_folding_utils import ModelFoldingUtils
+from model_compression_toolkit.xquant.common.similarity_functions import SimilarityFunctions
+from model_compression_toolkit.logger import Logger
+
+class SimilarityCalculator:
+    """
+    A class to calculate the similarity between two models (that are often referred as float
+    and quantized models). It utilizes various utility classes for dataset preparation, model folding,
+    similarity computation, and model analysis.
+    """
+
+    def __init__(self,
+                 dataset_utils: DatasetUtils,
+                 model_folding: ModelFoldingUtils,
+                 similarity_functions: SimilarityFunctions,
+                 model_analyzer_utils: ModelAnalyzer,
+                 device: str = None):
+        """
+        Initialize the SimilarityCalculator with required utilities.
+
+        Args:
+            dataset_utils (DatasetUtils): Utility class for dataset preparation.
+            model_folding (ModelFoldingUtils): Utility class for model folding operations.
+            similarity_functions (SimilarityFunctions): Class containing similarity functions.
+            model_analyzer_utils (ModelAnalyzer): Utility class for model analysis.
+            device (str, optional): Device to perform computations on (e.g., 'cpu', 'cuda'). Defaults to None.
+        """
+        self.dataset_utils = dataset_utils
+        self.model_folding = model_folding
+        self.similarity_functions = similarity_functions
+        self.model_analyzer_utils = model_analyzer_utils
+        self.device = device
+
+    @staticmethod
+    def compute_tensors_similarity(tensors_to_compare: Tuple[Any, Any],
+                                   similarity_metrics: Dict[str, Callable]) -> Dict[str, float]:
+        """
+        Compute the similarity between two tensors using provided similarity metrics.
+        If the type of inputs are not tensor, the similarity is 0.0.
+
+        Args:
+            tensors_to_compare (Tuple[Any, Any]): Tensors to compare by computing their similarity.
+            similarity_metrics (Dict[str, Callable]): A dictionary with similarity metric names and functions.
+
+        Returns:
+            Dict[str, float]: A dictionary of similarity metric names and their computed values.
+        """
+        x, y = tensors_to_compare
+        if(isinstance(x, np.ndarray) and isinstance(y, np.ndarray)):
+            similarity_metrics = {k: v(x, y) for k, v in similarity_metrics.items()}
+        else:
+            similarity_metrics = {k: 0.0 for k, v in similarity_metrics.items()}
+        return similarity_metrics
+
+    def _get_float_to_quantized_compare_points(self,
+                                               quantized_model: Any,
+                                               float_model: Any) -> Dict[str, str]:
+        """
+        Map corresponding layers between the float and quantized models for comparison.
+
+        Args:
+            quantized_model (Any): The quantized model.
+            float_model (Any): The float model.
+
+        Returns:
+            Dict[str, str]: A dictionary mapping float model layer names to quantized model layer names.
+        """
+        # Identify the points in the quantized model to compare.
+        quant_points_names = self.model_analyzer_utils.identify_quantized_compare_points(quantized_model)
+
+        float_name2quant_name = {}
+
+        # Extract the names of the layers in the float model.
+        float_layers_names = self.model_analyzer_utils.extract_float_layer_names(float_model)
+
+        # Map each quantized layer to the corresponding float layer.
+        for quant_point in quant_points_names:
+            candidate_float_layer_name = self.model_analyzer_utils.find_corresponding_float_layer(
+                quant_compare_point=quant_point, quantized_model=quantized_model)
+
+            if candidate_float_layer_name in float_layers_names:
+                if candidate_float_layer_name not in float_name2quant_name:
+                    float_name2quant_name[candidate_float_layer_name] = quant_point
+                else:
+                    Logger.critical(f"Duplicate mapping found for layer: {candidate_float_layer_name}.")
+            else:
+                Logger.warning(
+                    f"Could not find a matching layer in the float model for layer with name {quant_point}, "
+                    f"skipping it in similarity metrics comparison points computation.")
+
+        return float_name2quant_name
+
+    def compute_similarity_metrics(self,
+                                   float_model: Any,
+                                   quantized_model: Any,
+                                   dataset: Callable,
+                                   custom_similarity_metrics: Dict[str, Callable] = None,
+                                   is_validation: bool = False) -> Tuple[Dict[str, float], Dict[str, Dict[str, float]]]:
+        """
+        Compute the similarity metrics between the two models (usually, float and quantized models).
+
+        Args:
+            float_model (Any): The float model.
+            quantized_model (Any): The quantized model.
+            dataset (Callable): A callable to provide the dataset.
+            custom_similarity_metrics (Dict[str, Callable], optional): Custom similarity metrics. Defaults to None.
+            is_validation (bool, optional): Flag to indicate if the dataset is for validation. Defaults to False.
+
+        Returns:
+            Tuple[Dict[str, float], Dict[str, Dict[str, float]]]: Aggregated output similarity metrics and
+            intermediate similarity metrics for each layer.
+        """
+        # Prepare the dataset such that the rest of operations are indistinguishable between the representative
+        # dataset and the validation dataset.
+        dataset = partial(self.dataset_utils.prepare_dataset,
+                          dataset=dataset,
+                          is_validation=is_validation,
+                          device=self.device)
+
+        # Create a folded version of the float model.
+        float_model = self.model_folding.create_float_folded_model(float_model=float_model,
+                                                                   representative_dataset=dataset)
+
+        # Gather similarity metrics to compute (default and custom).
+        similarity_metrics_to_compute = self.similarity_functions.get_default_similarity_metrics()
+        if custom_similarity_metrics:
+            if not isinstance(custom_similarity_metrics, dict):
+                Logger.critical(
+                    f"custom_similarity_metrics should be a dictionary but is of type "
+                    f"{type(custom_similarity_metrics)}.")
+            similarity_metrics_to_compute.update(custom_similarity_metrics)
+
+        # Map float model layers to quantized model layers for comparison.
+        float_name2quant_name = self._get_float_to_quantized_compare_points(float_model=float_model,
+                                                                            quantized_model=quantized_model)
+
+        # Initialize dictionaries to store similarity metrics.
+        output_similarity_metrics = {key: [] for key in similarity_metrics_to_compute.keys()}
+        intermediate_similarity_metrics = {layer: {key: [] for key in similarity_metrics_to_compute.keys()} for layer in
+                                           float_name2quant_name.values()}
+
+        # Iterate over the dataset and compute similarity metrics.
+        for x in dataset():
+            # Extract activations and predictions from both models.
+            float_activations, quant_activations = (
+                self.model_analyzer_utils.extract_model_activations(
+                float_model, quantized_model, float_name2quant_name, x))
+
+            float_predictions = float_activations[MODEL_OUTPUT_KEY]
+            quant_predictions = quant_activations[MODEL_OUTPUT_KEY]
+
+            # Compute similarity metrics for the output predictions.
+            output_results = self.compute_tensors_similarity((float_predictions, quant_predictions),
+                                                             similarity_metrics_to_compute)
+            for key in output_similarity_metrics:
+                output_similarity_metrics[key].append(output_results[key])
+
+            # Compute similarity metrics for each intermediate layer.
+            for float_layer, quant_layer in float_name2quant_name.items():
+                intermediate_results = self.compute_tensors_similarity(
+                    (float_activations[float_layer], quant_activations[quant_layer]),
+                    similarity_metrics_to_compute)
+                for key in intermediate_similarity_metrics[quant_layer]:
+                    intermediate_similarity_metrics[quant_layer][key].append(intermediate_results[key])
+
+        # Aggregate the output similarity metrics.
+        aggregated_output_similarity_metrics = {key: sum(value) / len(value) for key, value in
+                                                output_similarity_metrics.items()}
+
+        # Aggregate the intermediate similarity metrics for each layer.
+        for layer_name, layer_similarity_metrics in intermediate_similarity_metrics.items():
+            for similarity_name, similarity_values_list in layer_similarity_metrics.items():
+                if len(similarity_values_list) == 0:
+                    Logger.critical(f"Can not average similarities of an empty list.")
+                intermediate_similarity_metrics[layer_name][similarity_name] = sum(similarity_values_list) / len(similarity_values_list)
+
+        return aggregated_output_similarity_metrics, intermediate_similarity_metrics

model_compression_toolkit/xquant/keras/tensorboard_utils.py

@@ -40,15 +40,18 @@ class KerasTensorboardUtils(TensorboardUtils):
     """
 
     def __init__(self, report_dir: str,
+                 fw_info: FrameworkInfo,
                  fw_impl: FrameworkImplementation):
         """
         Initialize the KerasTensorboardUtils class with the given parameters.
 
         Args:
             report_dir (str): Directory where the TensorBoard files will be stored.
+            fw_info (FrameworkInfo): Information about the framework being used.
             fw_impl (FrameworkImplementation): Implementation functions for the framework.
         """
         super().__init__(report_dir,
+                         fw_info,
                          fw_impl)
 
     def get_graph_for_tensorboard_display(self,

model_compression_toolkit/xquant/pytorch/core_detect_degrade_layer.py

@@ -0,0 +1,77 @@
+#  Copyright 2025 Sony Semiconductor Solutions. 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 Callable, Any, Dict
+from model_compression_toolkit.xquant import XQuantConfig
+from model_compression_toolkit.xquant.pytorch.detect_degrade_utils import make_similarity_graph
+from model_compression_toolkit.logger import Logger
+
+def core_detect_degrade_layer(repl_similarity: tuple[Dict[str, Any], Dict[str, Any]],
+                              val_similarity: tuple[Dict[str, Any], Dict[str, Any]],
+                              xquant_config: XQuantConfig) -> list[str]:
+    """
+    Detect degrade layers by caliculated similarities by XQuant.
+    And Draw and save similarity graphs.
+
+    Args:
+        repr_similarity (tuple[Dict[str, Any], Dict[str, Any]]): Quant error reports of Representative dataset.
+        val_similarity (tuple[Dict[str, Any], Dict[str, Any]]): Quant error reports of Validation dataset.
+        xquant_config (XQuantConfig): Configuration settings for explainable quantization.
+
+    Returns:
+        List[str]: A list of detected degrade layers.
+    """
+
+    degrade_layers = []
+    metrics_names = repl_similarity[0].keys()
+    for metrics_name in metrics_names:
+        # Check xquant_config parameter of custom_similarity_metrics (If not threshold then skip. If not flag of under/above threshold detection then assume above threshold detection.)
+        if(metrics_name not in xquant_config.threshold_quantize_error.keys()):
+            Logger.warning("XQuantConfig.threshold_quantize_error[\'{}\'] is not defined. Skipping detection degrade layers by \'{}\'".format(metrics_name, metrics_name))
+            continue
+        if(metrics_name not in xquant_config.is_detect_under_threshold_quantize_error.keys()):
+            Logger.warning("XQuantConfig.is_detect_under_threshold_quantize_error[{}] is not defined. Assume =False".format(metrics_name))
+            xquant_config.is_detect_under_threshold_quantize_error[metrics_name] = False
+
+        for dataset_similarity, dataset_name in [(repl_similarity, "repr"), (val_similarity, "val")]:
+            degrade_layers_tmp = []
+            intermediate_similarity = dataset_similarity[1]
+            for layer_name in intermediate_similarity.keys():
+                quantize_error = intermediate_similarity[layer_name][metrics_name]
+                threshold_quantize_error = xquant_config.threshold_quantize_error[metrics_name]
+                
+                # Switch by under/above threshold flag of xquant_config
+                is_degrade = False
+                if(xquant_config.is_detect_under_threshold_quantize_error[metrics_name]):
+                    if(quantize_error <= threshold_quantize_error):
+                        is_degrade = True        
+                else:
+                    if(quantize_error >= threshold_quantize_error):
+                        is_degrade = True  
+
+                # Add degrade_layers
+                if(is_degrade):
+                    # Print to Console
+                    if(len(degrade_layers)==0):
+                        Logger.info("This may be problematic because the quantization error is larger than other layers. Refer to the TroubleShooting Documentation (MCT XQuant Extension Tool).")
+                    Logger.info("{}[{}]={}".format(metrics_name, layer_name, quantize_error))
+                    if(layer_name not in degrade_layers_tmp):
+                        degrade_layers_tmp.append(layer_name)
+                    if(layer_name not in degrade_layers):
+                        degrade_layers.append(layer_name)
+            # Draw and save similarity graph by matplotlib
+            make_similarity_graph(metrics_name, dataset_name, intermediate_similarity, degrade_layers_tmp, xquant_config)
+                    
+    return degrade_layers

model_compression_toolkit/xquant/pytorch/core_judge_troubleshoot.py

@@ -0,0 +1,66 @@
+#  Copyright 2025 Sony Semiconductor Solutions. 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.
+#  ==============================================================================
+
+import os
+from typing import Callable, Any, Dict
+from model_compression_toolkit.xquant import XQuantConfig
+from model_compression_toolkit.core.common import Graph
+from model_compression_toolkit.xquant.pytorch.judge_troubleshoot_utils import judge_outlier_removal,  judge_shift_negative_activation, judge_unbalanced_concatnation, judge_mixed_precision_with_model_output_loss_objective
+
+def core_judge_troubleshoot(float_model: Any,
+                            quantized_model: Any,
+                            float_graph: Graph,
+                            degrade_layers: list[str],
+                            dataset: Callable,
+                            xquant_config: XQuantConfig) -> Dict[str, Any]:
+    """
+    Judge whether judgeable troubleshoots and make troubleshoot report.
+
+    Args:
+        float_model (Any): The original floating-point model.
+        quantized_model (Any): The model after quantization.
+        float_graph (Graph): Graph of float_model with histgrams.
+        degrade_layers (list[str]): A list of detected degrade layers.
+        dataset (Callable): Representative dataset used for similarity metrics computation.
+        xquant_config (XQuantConfig): Configuration settings for explainable quantization.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the analyze degrade cause report for degraded layers.
+    """
+
+    _troubleshoot_data = {"outlier_removal":[], "shift_negative_activation":[], "unbalanced_concatenation":[], "mixed_precision_with_model_output_loss_objective":[]}
+
+    # Judge whether the layer has outliers from statistics information
+    # make outlier image folder
+    outlier_histgram_dir = os.path.join(xquant_config.report_dir, "outlier_histgrams")
+    if(not os.path.exists(outlier_histgram_dir)):
+        os.mkdir(outlier_histgram_dir)
+    _troubleshoot_data["outlier_removal"] = judge_outlier_removal(degrade_layers, float_graph, xquant_config)
+
+    # Judge whether the layer combines layers with significantly different value ranges
+    _troubleshoot_data["unbalanced_concatenation"] = judge_unbalanced_concatnation(degrade_layers, float_model, dataset, xquant_config)
+
+    # Judge whether the layer has a negative activation function (PReLU / ELU / Hardswish / SiLU / GELU)
+    _troubleshoot_data["shift_negative_activation"] = judge_shift_negative_activation(float_graph, xquant_config)
+
+    # Judge whether the bitwidth of the final layer is less than threshold
+    _troubleshoot_data["mixed_precision_with_model_output_loss_objective"] = judge_mixed_precision_with_model_output_loss_objective(quantized_model, xquant_config)
+
+    # Delete no data key
+    for troubleshoot_name in list(_troubleshoot_data.keys()):
+        if(len(_troubleshoot_data[troubleshoot_name]) == 0):
+            del _troubleshoot_data[troubleshoot_name]
+
+    return _troubleshoot_data