mct-nightly 1.11.0.20240321.357__py3-none-any.whl → 1.11.0.20240323.408__py3-none-any.whl

model_compression_toolkit/core/pytorch/reader/reader.py

@@ -89,8 +89,8 @@ def fx_graph_module_generation(pytorch_model: torch.nn.Module,
     try:
         symbolic_traced = symbolic_trace(pytorch_model)
     except torch.fx.proxy.TraceError as e:
-        Logger.error(f'Error parsing model with torch.fx\n'
-                     f'fx error: {e}')
+        Logger.critical(f'Error parsing model with torch.fx\n'
+                        f'fx error: {e}')
     inputs = next(representative_data_gen())
     input_for_shape_infer = [to_tensor(i) for i in inputs]
     ShapeProp(symbolic_traced).propagate(*input_for_shape_infer)

model_compression_toolkit/core/pytorch/{kpi_data_facade.py → resource_utilization_data_facade.py}

@@ -18,9 +18,9 @@ from typing import Callable
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import PYTORCH
 from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi import KPI
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core.common.framework_info import FrameworkInfo
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi_data import compute_kpi_data
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization_data import compute_resource_utilization_data
 from model_compression_toolkit.core.common.quantization.core_config import CoreConfig
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import MixedPrecisionQuantizationConfig
 from model_compression_toolkit.constants import FOUND_TORCH
@@ -36,13 +36,14 @@ if FOUND_TORCH:
     PYTORCH_DEFAULT_TPC = get_target_platform_capabilities(PYTORCH, DEFAULT_TP_MODEL)
 
 
-    def pytorch_kpi_data(in_model: Module,
-                         representative_data_gen: Callable,
-                         core_config: CoreConfig = CoreConfig(),
-                         target_platform_capabilities: TargetPlatformCapabilities = PYTORCH_DEFAULT_TPC) -> KPI:
+    def pytorch_resource_utilization_data(in_model: Module,
+                                          representative_data_gen: Callable,
+                                          core_config: CoreConfig = CoreConfig(),
+                                          target_platform_capabilities: TargetPlatformCapabilities = PYTORCH_DEFAULT_TPC
+                                          ) -> ResourceUtilization:
         """
-        Computes KPI data that can be used to calculate the desired target KPI for mixed-precision quantization.
-        Builds the computation graph from the given model and target platform capabilities, and uses it to compute the KPI data.
+        Computes resource utilization data that can be used to calculate the desired target resource utilization for mixed-precision quantization.
+        Builds the computation graph from the given model and target platform capabilities, and uses it to compute the resource utilization data.
 
         Args:
             in_model (Model): PyTorch model to quantize.
@@ -52,7 +53,7 @@ if FOUND_TORCH:
 
         Returns:
 
-            A KPI object with total weights parameters sum and max activation tensor.
+            A ResourceUtilization object with total weights parameters sum and max activation tensor.
 
         Examples:
 
@@ -66,29 +67,30 @@ if FOUND_TORCH:
             >>> import numpy as np
             >>> def repr_datagen(): yield [np.random.random((1, 3, 224, 224))]
 
-            Import mct and call for KPI data calculation:
+            Import mct and call for resource utilization data calculation:
 
             >>> import model_compression_toolkit as mct
-            >>> kpi_data = mct.core.pytorch_kpi_data(module, repr_datagen)
+            >>> ru_data = mct.core.pytorch_resource_utilization_data(module, repr_datagen)
 
         """
 
         if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
-            Logger.error("KPI data computation can't be executed without MixedPrecisionQuantizationConfig object."
-                         "Given quant_config is not of type MixedPrecisionQuantizationConfig.")
+            Logger.critical("Resource utilization data computation requires a MixedPrecisionQuantizationConfig object. "
+                            "The provided 'mixed_precision_config' is not of this type.")
 
         fw_impl = PytorchImplementation()
 
-        return compute_kpi_data(in_model,
-                                representative_data_gen,
-                                core_config,
-                                target_platform_capabilities,
-                                DEFAULT_PYTORCH_INFO,
-                                fw_impl)
+        return compute_resource_utilization_data(in_model,
+                                                 representative_data_gen,
+                                                 core_config,
+                                                 target_platform_capabilities,
+                                                 DEFAULT_PYTORCH_INFO,
+                                                 fw_impl)
 
 else:
     # If torch is not installed,
     # we raise an exception when trying to use this function.
-    def pytorch_kpi_data(*args, **kwargs):
-        Logger.critical('Installing torch is mandatory when using pytorch_kpi_data. '
-                        'Could not find Tensorflow package.')  # pragma: no cover
+    def pytorch_resource_utilization_data(*args, **kwargs):
+        Logger.critical("PyTorch must be installed to use 'pytorch_resource_utilization_data'. "
+                        "The 'torch' package is missing.")  # pragma: no cover
+

model_compression_toolkit/core/pytorch/utils.py

@@ -16,6 +16,7 @@ import torch
 import numpy as np
 from typing import Union
 from model_compression_toolkit.core.pytorch.pytorch_device_config import get_working_device
+from model_compression_toolkit.logger import Logger
 
 
 def set_model(model: torch.nn.Module, train_mode: bool = False):
@@ -58,7 +59,7 @@ def to_torch_tensor(tensor):
     elif isinstance(tensor, (int, float)):
         return torch.from_numpy(np.array(tensor).astype(np.float32)).to(working_device)
     else:
-        raise Exception(f'Conversion of type {type(tensor)} to {type(torch.Tensor)} is not supported')
+        Logger.critical(f'Unsupported type for conversion to Torch.tensor: {type(tensor)}.')
 
 
 def torch_tensor_to_numpy(tensor: Union[torch.Tensor, list, tuple]) -> Union[np.ndarray, list, tuple]:
@@ -79,4 +80,4 @@ def torch_tensor_to_numpy(tensor: Union[torch.Tensor, list, tuple]) -> Union[np.
     elif isinstance(tensor, torch.Tensor):
         return tensor.cpu().detach().contiguous().numpy()
     else:
-        raise Exception(f'Conversion of type {type(tensor)} to {type(np.ndarray)} is not supported')
+        Logger.critical(f'Unsupported type for conversion to Numpy array: {type(tensor)}.')

model_compression_toolkit/core/runner.py

@@ -26,10 +26,10 @@ from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
 from model_compression_toolkit.core.common.graph.base_graph import Graph
 from model_compression_toolkit.core.common.mixed_precision.bit_width_setter import set_bit_widths
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi import KPI, KPITarget
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi_aggregation_methods import MpKpiAggregation
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi_functions_mapping import kpi_functions_mapping
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi_methods import MpKpiMetric
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization, RUTarget
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_aggregation_methods import MpRuAggregation
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_functions_mapping import ru_functions_mapping
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_methods import MpRuMetric
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_search_facade import search_bit_width
 from model_compression_toolkit.core.common.network_editors.edit_network import edit_network_graph
 from model_compression_toolkit.core.common.quantization.core_config import CoreConfig
@@ -47,7 +47,7 @@ def core_runner(in_model: Any,
                 fw_info: FrameworkInfo,
                 fw_impl: FrameworkImplementation,
                 tpc: TargetPlatformCapabilities,
-                target_kpi: KPI = None,
+                target_resource_utilization: ResourceUtilization = None,
                 tb_w: TensorboardWriter = None):
     """
     Quantize a trained model using post-training quantization.
@@ -67,7 +67,7 @@ def core_runner(in_model: Any,
         fw_impl: FrameworkImplementation object with a specific framework methods implementation.
         tpc: TargetPlatformCapabilities object that models the inference target platform and
                                               the attached framework operator's information.
-        target_kpi: KPI to constraint the search of the mixed-precision configuration for the model.
+        target_resource_utilization: ResourceUtilization to constraint the search of the mixed-precision configuration for the model.
         tb_w: TensorboardWriter object for logging
 
     Returns:
@@ -84,9 +84,9 @@ def core_runner(in_model: Any,
                        ' consider increasing the batch size')
 
     # Checking whether to run mixed precision quantization
-    if target_kpi is not None:
+    if target_resource_utilization is not None:
         if core_config.mixed_precision_config is None:
-            Logger.critical("Provided an initialized target_kpi, that means that mixed precision quantization is "
+            Logger.critical("Provided an initialized target_resource_utilization, that means that mixed precision quantization is "
                             "enabled, but the provided MixedPrecisionQuantizationConfig is None.")
         core_config.mixed_precision_config.set_mixed_precision_enable()
 
@@ -119,7 +119,7 @@ def core_runner(in_model: Any,
             bit_widths_config = search_bit_width(tg,
                                                  fw_info,
                                                  fw_impl,
-                                                 target_kpi,
+                                                 target_resource_utilization,
                                                  core_config.mixed_precision_config,
                                                  representative_data_gen,
                                                  hessian_info_service=hessian_info_service)
@@ -139,11 +139,11 @@ def core_runner(in_model: Any,
     # This is since some actions regard the final configuration and should be edited.
     edit_network_graph(tg, fw_info, core_config.debug_config.network_editor)
 
-    _set_final_kpi(graph=tg,
-                   final_bit_widths_config=bit_widths_config,
-                   kpi_functions_dict=kpi_functions_mapping,
-                   fw_info=fw_info,
-                   fw_impl=fw_impl)
+    _set_final_resource_utilization(graph=tg,
+                                    final_bit_widths_config=bit_widths_config,
+                                    ru_functions_dict=ru_functions_mapping,
+                                    fw_info=fw_info,
+                                    fw_impl=fw_impl)
 
     if core_config.mixed_precision_enable:
         # Retrieve lists of tuples (node, node's final weights/activation bitwidth)
@@ -164,49 +164,50 @@ def core_runner(in_model: Any,
     return tg, bit_widths_config, hessian_info_service
 
 
-def _set_final_kpi(graph: Graph,
-                   final_bit_widths_config: List[int],
-                   kpi_functions_dict: Dict[KPITarget, Tuple[MpKpiMetric, MpKpiAggregation]],
-                   fw_info: FrameworkInfo,
-                   fw_impl: FrameworkImplementation):
+def _set_final_resource_utilization(graph: Graph,
+                                    final_bit_widths_config: List[int],
+                                    ru_functions_dict: Dict[RUTarget, Tuple[MpRuMetric, MpRuAggregation]],
+                                    fw_info: FrameworkInfo,
+                                    fw_impl: FrameworkImplementation):
     """
-    Computing the KPIs of the model according to the final bit-width configuration,
+    Computing the resource utilization of the model according to the final bit-width configuration,
     and setting it (inplace) in the graph's UserInfo field.
 
     Args:
-        graph: Graph to compute the KPI for.
+        graph: Graph to compute the resource utilization for.
         final_bit_widths_config: The final bit-width configuration to quantize the model accordingly.
-        kpi_functions_dict: A mapping between a KPITarget and a pair of kpi method and kpi aggregation functions.
+        ru_functions_dict: A mapping between a RUTarget and a pair of resource utilization method and resource utilization aggregation functions.
         fw_info: A FrameworkInfo object.
         fw_impl: FrameworkImplementation object with specific framework methods implementation.
 
     """
 
-    final_kpis_dict = {}
-    for kpi_target, kpi_funcs in kpi_functions_dict.items():
-        kpi_method, kpi_aggr = kpi_funcs
-        if kpi_target == KPITarget.BOPS:
-            final_kpis_dict[kpi_target] = kpi_aggr(kpi_method(final_bit_widths_config, graph, fw_info, fw_impl, False), False)[0]
+    final_ru_dict = {}
+    for ru_target, ru_funcs in ru_functions_dict.items():
+        ru_method, ru_aggr = ru_funcs
+        if ru_target == RUTarget.BOPS:
+            final_ru_dict[ru_target] = \
+            ru_aggr(ru_method(final_bit_widths_config, graph, fw_info, fw_impl, False), False)[0]
         else:
-            non_conf_kpi = kpi_method([], graph, fw_info, fw_impl)
-            conf_kpi = kpi_method(final_bit_widths_config, graph, fw_info, fw_impl)
-            if len(final_bit_widths_config) > 0 and len(non_conf_kpi) > 0:
-                final_kpis_dict[kpi_target] = kpi_aggr(np.concatenate([conf_kpi, non_conf_kpi]), False)[0]
-            elif len(final_bit_widths_config) > 0 and len(non_conf_kpi) == 0:
-                final_kpis_dict[kpi_target] = kpi_aggr(conf_kpi, False)[0]
-            elif len(final_bit_widths_config) == 0 and len(non_conf_kpi) > 0:
+            non_conf_ru = ru_method([], graph, fw_info, fw_impl)
+            conf_ru = ru_method(final_bit_widths_config, graph, fw_info, fw_impl)
+            if len(final_bit_widths_config) > 0 and len(non_conf_ru) > 0:
+                final_ru_dict[ru_target] = ru_aggr(np.concatenate([conf_ru, non_conf_ru]), False)[0]
+            elif len(final_bit_widths_config) > 0 and len(non_conf_ru) == 0:
+                final_ru_dict[ru_target] = ru_aggr(conf_ru, False)[0]
+            elif len(final_bit_widths_config) == 0 and len(non_conf_ru) > 0:
                 # final_bit_widths_config == 0 ==> no configurable nodes,
-                # thus, KPI can be computed from non_conf_kpi alone
-                final_kpis_dict[kpi_target] = kpi_aggr(non_conf_kpi, False)[0]
+                # thus, ru can be computed from non_conf_ru alone
+                final_ru_dict[ru_target] = ru_aggr(non_conf_ru, False)[0]
             else:
                 # No relevant nodes have been quantized with affect on the given target - since we only consider
                 # in the model's final size the quantized layers size, this means that the final size for this target
                 # is zero.
-                Logger.warning(f"No relevant quantized layers for the KPI target {kpi_target} were found, the recorded"
-                               f"final KPI for this target would be 0.")
-                final_kpis_dict[kpi_target] = 0
+                Logger.warning(f"No relevant quantized layers for the ru target {ru_target} were found, the recorded"
+                               f"final ru for this target would be 0.")
+                final_ru_dict[ru_target] = 0
 
-    final_kpi = KPI()
-    final_kpi.set_kpi_by_target(final_kpis_dict)
-    graph.user_info.final_kpi = final_kpi
+    final_ru = ResourceUtilization()
+    final_ru.set_resource_utilization_by_target(final_ru_dict)
+    graph.user_info.final_resource_utilization = final_ru
     graph.user_info.mixed_precision_cfg = final_bit_widths_config

model_compression_toolkit/data_generation/common/data_generation.py

@@ -64,53 +64,53 @@ def get_data_generation_classes(
 
     # Check if the image pipeline type is valid
     if image_pipeline is None:
-        Logger.exception(
-            f'Invalid image_pipeline_type {data_generation_config.image_pipeline_type}.'
-            f'Please choose one of {ImagePipelineType.get_values()}')
+        Logger.critical(
+            f'Invalid image_pipeline_type {data_generation_config.image_pipeline_type}. '
+            f'Please select one from {ImagePipelineType.get_values()}.')
 
     # Get the normalization values corresponding to the specified type
     normalization = image_normalization_dict.get(data_generation_config.image_normalization_type)
 
     # Check if the image normalization type is valid
     if normalization is None:
-        Logger.exception(
-            f'Invalid image_normalization_type {data_generation_config.image_normalization_type}.'
-            f'Please choose one of {ImageNormalizationType.get_values()}')
+        Logger.critical(
+            f'Invalid image_normalization_type {data_generation_config.image_normalization_type}. '
+            f'Please select one from {ImageNormalizationType.get_values()}.')
 
     # Get the layer weighting function corresponding to the specified type
     bn_layer_weighting_fn = bn_layer_weighting_function_dict.get(data_generation_config.layer_weighting_type)
 
     if bn_layer_weighting_fn is None:
-        Logger.exception(
-            f'Invalid layer_weighting_type {data_generation_config.layer_weighting_type}.'
-            f'Please choose one of {BNLayerWeightingType.get_values()}')
+        Logger.critical(
+            f'Invalid layer_weighting_type {data_generation_config.layer_weighting_type}. '
+            f'Please select one from {BNLayerWeightingType.get_values()}.')
 
     # Get the image initialization function corresponding to the specified type
     image_initialization_fn = image_initialization_function_dict.get(data_generation_config.data_init_type)
 
     # Check if the data initialization type is valid
     if image_initialization_fn is None:
-        Logger.exception(
-            f'Invalid data_init_type {data_generation_config.data_init_type}.'
-            f'Please choose one of {DataInitType.get_values()}')
+        Logger.critical(
+            f'Invalid data_init_type {data_generation_config.data_init_type}. '
+            f'Please select one from {DataInitType.get_values()}.')
 
     # Get the BatchNorm alignment loss function corresponding to the specified type
     bn_alignment_loss_fn = bn_alignment_loss_function_dict.get(data_generation_config.bn_alignment_loss_type)
 
     # Check if the BatchNorm alignment loss type is valid
     if bn_alignment_loss_fn is None:
-        Logger.exception(
-            f'Invalid bn_alignment_loss_type {data_generation_config.bn_alignment_loss_type}.'
-            f'Please choose one of {BatchNormAlignemntLossType.get_values()}')
+        Logger.critical(
+            f'Invalid bn_alignment_loss_type {data_generation_config.bn_alignment_loss_type}. '
+            f'Please select one from {BatchNormAlignemntLossType.get_values()}.')
 
     # Get the output loss function corresponding to the specified type
     output_loss_fn = output_loss_function_dict.get(data_generation_config.output_loss_type)
 
     # Check if the output loss type is valid
     if output_loss_fn is None:
-        Logger.exception(
-            f'Invalid output_loss_type {data_generation_config.output_loss_type}.'
-            f'Please choose one of {OutputLossType.get_values()}')
+        Logger.critical(
+            f'Invalid output_loss_type {data_generation_config.output_loss_type}. '
+            f'Please select one from {OutputLossType.get_values()}.')
 
     # Initialize the dataset for data generation
     init_dataset = image_initialization_fn(

model_compression_toolkit/data_generation/common/model_info_exctractors.py

@@ -35,7 +35,7 @@ class OriginalBNStatsHolder:
         """
         self.bn_params = self.get_bn_params(model, bn_layer_types)
         if self.get_num_bn_layers() == 0:
-            Logger.exception(
+            Logger.critical(
                 f'Data generation requires a model with at least one BatchNorm layer.')
 
     def get_bn_layer_names(self) -> List[str]:

model_compression_toolkit/data_generation/keras/keras_data_generation.py

@@ -181,18 +181,16 @@ if FOUND_TF:
                                                        output_loss_function_dict=output_loss_function_dict)
 
         if not all(normalization[1]):
-            Logger.exception(
-                f'Invalid normalization std {normalization[1]} set to zero,'
-                f'will lead to division by zero., Please choose non-zero normalization std')
+            Logger.critical(
+                f'Invalid normalization standard deviation {normalization[1]} set to zero, which will lead to division by zero. Please select a non-zero normalization standard deviation.')
 
         # Get the scheduler functions corresponding to the specified scheduler type
         scheduler_get_fn = scheduler_step_function_dict.get(data_generation_config.scheduler_type)
 
         # Check if the scheduler type is valid
         if scheduler_get_fn is None:
-            Logger.exception(
-                f'Invalid scheduler_type {data_generation_config.scheduler_type}.'
-                f'Please choose one of {SchedulerType.get_values()}')
+            Logger.critical(
+                f'Invalid scheduler_type {data_generation_config.scheduler_type}. Please select one from {SchedulerType.get_values()}.')
 
         # Create a scheduler object with the specified number of iterations
         scheduler = scheduler_get_fn(n_iter=data_generation_config.n_iter,
@@ -358,10 +356,9 @@ if FOUND_TF:
 
 else:
     def get_keras_data_generation_config(*args, **kwargs):
-        Logger.critical('Installing tensorflow is mandatory when using get_keras_data_generation_config. '
-                        'Could not find Tensorflow package.')  # pragma: no cover
+        Logger.critical(
+            "Tensorflow must be installed to use get_tensorflow_data_generation_config. The 'tensorflow' package is missing.")  # pragma: no cover
 
 
     def keras_data_generation_experimental(*args, **kwargs):
-        Logger.critical('Installing tensorflow is mandatory when using pytorch_data_generation_experimental. '
-                        'Could not find Tensorflow package.')  # pragma: no cover
+        Logger.critical("Tensorflow must be installed to use tensorflow_data_generation_experimental. The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/data_generation/keras/model_info_exctractors.py

@@ -21,6 +21,7 @@ from tensorflow.keras.layers import BatchNormalization
 from model_compression_toolkit.data_generation.common.enums import ImageGranularity
 from model_compression_toolkit.data_generation.common.model_info_exctractors import OriginalBNStatsHolder, \
     ActivationExtractor
+from model_compression_toolkit.logger import Logger
 
 
 class KerasOriginalBNStatsHolder(OriginalBNStatsHolder):
@@ -95,7 +96,7 @@ class KerasActivationExtractor(ActivationExtractor):
         self.bn_layer_names = [layer.name for layer in model.layers if isinstance(layer,
                                                                                   self.layer_types_to_extract_inputs)]
         self.num_layers = len(self.bn_layer_names)
-        print(f'Number of layers = {self.num_layers}')
+        Logger.info(f'Number of layers = {self.num_layers}')
 
         # Initialize stats containers
         self.activations = {}

model_compression_toolkit/data_generation/keras/optimization_functions/image_initilization.py

@@ -21,6 +21,7 @@ from tensorflow.data import Dataset
 
 from model_compression_toolkit.data_generation.common.constants import NUM_INPUT_CHANNELS
 from model_compression_toolkit.data_generation.common.enums import DataInitType
+from model_compression_toolkit.logger import Logger
 
 
 # Define a function to generate a dataset of Gaussian noise images.
@@ -91,7 +92,7 @@ def get_random_gaussian_data(
     Returns:
         Tuple[int, Any]: A tuple containing the number of batches and a data loader iterator.
     """
-    print(f'Start generating random Gaussian data')
+    Logger.info(f'Start generating random Gaussian data')
     image_shape = size + (NUM_INPUT_CHANNELS,)
     dataset = generate_gaussian_noise_images(num_samples=n_images, image_shape=image_shape,
                                              mean=mean_factor, std=std_factor, batch_size=batch_size)

model_compression_toolkit/data_generation/keras/optimization_functions/output_loss_functions.py

@@ -43,10 +43,8 @@ def regularized_min_max_diff(
         tf.Tensor: The calculated loss.
     """
     if activation_extractor.last_linear_layers is None:
-        Logger.exception(
-            f'Cannot compute regularized min max output loss for the input model. The regularized min max output loss '
-            f'requires linear layer without a following BatchNormalization layer. Please choose one of '
-            f'{OutputLossType.get_values()}.')
+        Logger.critical(
+            f'Cannot compute regularized min-max output loss for the input model. This loss requires a linear layer without a subsequent BatchNormalization layer. Please select one from {OutputLossType.get_values()}.')
 
     with tape.stop_recording():
         weights_last_layer = activation_extractor.last_linear_layers.get_weights()[0]

model_compression_toolkit/data_generation/pytorch/model_info_exctractors.py

@@ -23,6 +23,7 @@ from model_compression_toolkit.data_generation.common.model_info_exctractors imp
     ActivationExtractor
 from model_compression_toolkit.data_generation.pytorch.constants import OUTPUT
 from model_compression_toolkit.data_generation.common.constants import IMAGE_INPUT, NUM_INPUT_CHANNELS
+from model_compression_toolkit.logger import Logger
 
 
 class PytorchOriginalBNStatsHolder(OriginalBNStatsHolder):
@@ -125,7 +126,7 @@ class PytorchActivationExtractor(ActivationExtractor):
         self.layer_types_to_extract_inputs = tuple(layer_types_to_extract_inputs)
         self.last_layer_types_to_extract_inputs = tuple(last_layer_types_to_extract_inputs)
         self.num_layers = sum([1 if isinstance(layer, tuple(layer_types_to_extract_inputs)) else 0 for layer in model.modules()])
-        print(f'Number of layers = {self.num_layers}')
+        Logger.info(f'Number of layers = {self.num_layers}')
         self.hooks = {}  # Dictionary to store InputHook instances by layer name
         self.last_linear_layers_hooks = {}  # Dictionary to store InputHook instances by layer name
         self.hook_handles = []  # List to store hook handles

model_compression_toolkit/data_generation/pytorch/pytorch_data_generation.py

@@ -198,9 +198,8 @@ if FOUND_TORCH:
 
         # Check if the scheduler type is valid
         if scheduler_get_fn is None or scheduler_step_fn is None:
-            Logger.exception(
-                f'Invalid scheduler_type {data_generation_config.scheduler_type}. Please choose one of '
-                f'{SchedulerType.get_values()}')
+            Logger.critical(f'Invalid output_loss_type {data_generation_config.scheduler_type}. '
+                            f'Please select one from {SchedulerType.get_values()}.')
 
         # Create a scheduler object with the specified number of iterations
         scheduler = scheduler_get_fn(data_generation_config.n_iter)
@@ -218,8 +217,8 @@ if FOUND_TORCH:
         # Create an orig_bn_stats_holder object to hold original BatchNorm statistics
         orig_bn_stats_holder = PytorchOriginalBNStatsHolder(model, data_generation_config.bn_layer_types)
         if orig_bn_stats_holder.get_num_bn_layers() == 0:
-            Logger.exception(
-                f'Data generation requires a model with at least one Batch Norm layer.')
+            Logger.critical(
+                f'Data generation requires a model with at least one BatchNorm layer.')
 
         # Create an ImagesOptimizationHandler object for handling optimization
         all_imgs_opt_handler = PytorchImagesOptimizationHandler(model=model,
@@ -355,12 +354,10 @@ else:
     # If torch is not installed,
     # we raise an exception when trying to use these functions.
     def get_pytorch_data_generation_config(*args, **kwargs):
-        Logger.critical('Installing Pytorch is mandatory '
-                        'when using get_pytorch_data_generation_config. '
-                        'Could not find torch package.')  # pragma: no cover
+        Logger.critical('PyTorch must be installed to use get_pytorch_data_generation_config. '
+                        "The 'torch' package is missing.")  # pragma: no cover
 
 
     def pytorch_data_generation_experimental(*args, **kwargs):
-        Logger.critical('Installing Pytorch is mandatory '
-                        'when using pytorch_data_generation_experimental. '
-                        'Could not find the torch package.')  # pragma: no cover
+        Logger.critical("PyTorch must be installed to use 'pytorch_data_generation_experimental'. "
+                        "The 'torch' package is missing.")  # pragma: no cover

model_compression_toolkit/exporter/model_exporter/keras/fakely_quant_keras_exporter.py

@@ -99,7 +99,7 @@ class FakelyQuantKerasExporter(BaseKerasExporter):
                     elif isinstance(layer.layer, (layers.Conv2D, layers.Dense, layers.Conv2DTranspose)):
                         weights_list.append(layer.get_quantized_weights()['kernel'])
                     else:
-                        Logger.error(f'KerasQuantizationWrapper should wrap only DepthwiseConv2D, Conv2D, Dense'
+                        Logger.critical(f'KerasQuantizationWrapper should wrap only DepthwiseConv2D, Conv2D, Dense'
                                      f' and Conv2DTranspose layers but wrapped layer is {layer.layer}')
 
                     if layer.layer.bias is not None:

model_compression_toolkit/exporter/model_exporter/keras/keras_export_facade.py

@@ -101,6 +101,5 @@ if FOUND_TF:
         return exporter.get_custom_objects()
 else:
     def keras_export_model(*args, **kwargs):
-        Logger.error('Installing tensorflow is mandatory '
-                     'when using keras_export_model. '
-                     'Could not find some or all of TensorFlow packages.')  # pragma: no cover
+        Logger.critical("Tensorflow must be installed to use keras_export_model. "
+                        "The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/exporter/model_exporter/pytorch/pytorch_export_facade.py

@@ -103,6 +103,5 @@ if FOUND_TORCH:
 
 else:
     def pytorch_export_model(*args, **kwargs):
-        Logger.error('Installing torch is mandatory '
-                     'when using pytorch_export_model. '
-                     'Could not find PyTorch packages.')  # pragma: no cover
+        Logger.critical("PyTorch must be installed to use 'pytorch_export_model'. "
+                        "The 'torch' package is missing.")  # pragma: no cover

model_compression_toolkit/exporter/model_wrapper/keras/builder/fully_quantized_model_builder.py

@@ -65,7 +65,7 @@ if FOUND_TF:
         if len(activation_quantizers) == 1:
             return KerasActivationQuantizationHolder(activation_quantizers[0])
 
-        Logger.error(
+        Logger.critical(
             f'ActivationQuantizationHolder supports a single quantizer but {len(activation_quantizers)} quantizers '
             f'were found for node {node}')
 
@@ -89,9 +89,13 @@ if FOUND_TF:
                                                         get_activation_quantizer_holder(n,
                                                                                         fw_impl=C.keras.keras_implementation.KerasImplementation())).build_model()
         exportable_model.trainable = False
+
+        Logger.info("Please run your accuracy evaluation on the exported quantized model to verify it's accuracy.\n"
+                    "Checkout the FAQ and Troubleshooting pages for resolving common issues and improving the quantized model accuracy:\n"
+                    "FAQ: https://github.com/sony/model_optimization/tree/main/FAQ.md"
+                    "Quantization Troubleshooting: https://github.com/sony/model_optimization/tree/main/quantization_troubleshooting.md")
         return exportable_model, user_info
 else:
     def get_exportable_keras_model(*args, **kwargs):  # pragma: no cover
-        Logger.error('Installing tensorflow is mandatory '
-                     'when using get_exportable_keras_model. '
-                     'Could not find Tensorflow package.')
+        Logger.critical("Tensorflow must be installed to use get_exportable_keras_model. "
+                        "The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizer.py

@@ -44,7 +44,7 @@ def get_inferable_quantizer_kwargs(node_qc: BaseNodeQuantizationConfig,
 
     if quantization_target == QuantizationTarget.Weights:
         if not isinstance(node_qc, NodeWeightsQuantizationConfig):
-            Logger.error(f"Non-compatible node quantization config was given for quantization target Weights.")  # pragma: no cover
+            Logger.critical(f"Non-compatible node quantization config was given for quantization target Weights.")  # pragma: no cover
 
         if attr_name is None:
             Logger.error(f"Attribute name was not specified for retrieving weights quantizer kwargs.")
@@ -84,7 +84,7 @@ def get_inferable_quantizer_kwargs(node_qc: BaseNodeQuantizationConfig,
 
     elif quantization_target == QuantizationTarget.Activation:
         if not isinstance(node_qc, NodeActivationQuantizationConfig):
-            Logger.error(f"Non-compatible node quantization config was given for quantization target Activation.")  # pragma: no cover
+            Logger.critical(f"Non-compatible node quantization config was given for quantization target Activation.")  # pragma: no cover
 
         quantization_method = node_qc.activation_quantization_method