mct-nightly 2.2.0.20250113.527__py3-none-any.whl → 2.2.0.20250114.84821__py3-none-any.whl

model_compression_toolkit/xquant/common/model_folding_utils.py

@@ -23,7 +23,8 @@ from model_compression_toolkit.core.graph_prep_runner import graph_preparation_r
 from typing import Any, Callable
 
 from model_compression_toolkit.core.common import Graph
-from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework import \
+    FrameworkQuantizationCapabilities
 
 
 class ModelFoldingUtils:
@@ -35,19 +36,19 @@ class ModelFoldingUtils:
     def __init__(self,
                  fw_info: FrameworkInfo,
                  fw_impl: FrameworkImplementation,
-                 fw_default_tpc: TargetPlatformCapabilities):
+                 fw_default_fqc: FrameworkQuantizationCapabilities):
         """
         Initialize the ModelFoldingUtils class with framework-specific information, implementation details,
-        and default TPC.
+        and default FQC.
 
         Args:
             fw_info: Framework-specific information.
             fw_impl: Implementation functions for the framework.
-            fw_default_tpc: Default target platform capabilities for the handled 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_tpc = fw_default_tpc
+        self.fw_default_fqc = fw_default_fqc
 
     def create_float_folded_model(self, float_model: Any, representative_dataset: Any = None) -> Any:
         """
@@ -101,5 +102,5 @@ class ModelFoldingUtils:
                                          fw_impl=self.fw_impl,
                                          fw_info=self.fw_info,
                                          quantization_config=DEFAULTCONFIG,
-                                         tpc=self.fw_default_tpc)
+                                         fqc=self.fw_default_fqc)
         return graph

model_compression_toolkit/xquant/keras/keras_report_utils.py

@@ -17,6 +17,8 @@ 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.common.model_folding_utils import ModelFoldingUtils
 from model_compression_toolkit.xquant.common.similarity_calculator import SimilarityCalculator
@@ -27,8 +29,6 @@ from model_compression_toolkit.xquant.keras.similarity_functions import KerasSim
 from model_compression_toolkit.xquant.keras.tensorboard_utils import KerasTensorboardUtils
 from mct_quantizers.keras.metadata import get_metadata
 from model_compression_toolkit.target_platform_capabilities.constants import DEFAULT_TP_MODEL
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2keras import \
-    AttachTpcToKeras
 
 
 class KerasReportUtils(FrameworkReportUtils):
@@ -46,12 +46,12 @@ class KerasReportUtils(FrameworkReportUtils):
         # Set the default Target Platform Capabilities (TPC) for Keras.
         default_tpc = get_target_platform_capabilities(TENSORFLOW, DEFAULT_TP_MODEL)
         attach2pytorch = AttachTpcToKeras()
-        target_platform_capabilities = attach2pytorch.attach(default_tpc)
+        framework_platform_capabilities = attach2pytorch.attach(default_tpc)
 
         dataset_utils = KerasDatasetUtils()
         model_folding = ModelFoldingUtils(fw_info=fw_info,
                                           fw_impl=fw_impl,
-                                          fw_default_tpc=target_platform_capabilities)
+                                          fw_default_fqc=framework_platform_capabilities)
 
         similarity_calculator = SimilarityCalculator(dataset_utils=dataset_utils,
                                                      model_folding=model_folding,

model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py

@@ -16,7 +16,7 @@ from model_compression_toolkit import get_target_platform_capabilities
 from model_compression_toolkit.constants import PYTORCH
 from model_compression_toolkit.core.pytorch.utils import get_working_device
 from model_compression_toolkit.target_platform_capabilities.constants import DEFAULT_TP_MODEL
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2pytorch import \
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2pytorch import \
     AttachTpcToPytorch
 
 from model_compression_toolkit.xquant.common.framework_report_utils import FrameworkReportUtils
@@ -44,12 +44,12 @@ class PytorchReportUtils(FrameworkReportUtils):
         # Set the default Target Platform Capabilities (TPC) for PyTorch.
         default_tpc = get_target_platform_capabilities(PYTORCH, DEFAULT_TP_MODEL)
         attach2pytorch = AttachTpcToPytorch()
-        target_platform_capabilities = attach2pytorch.attach(default_tpc)
+        framework_quantization_capabilities = attach2pytorch.attach(default_tpc)
 
         dataset_utils = PytorchDatasetUtils()
         model_folding = ModelFoldingUtils(fw_info=fw_info,
                                           fw_impl=fw_impl,
-                                          fw_default_tpc=target_platform_capabilities)
+                                          fw_default_fqc=framework_quantization_capabilities)
 
         similarity_calculator = SimilarityCalculator(dataset_utils=dataset_utils,
                                                      model_folding=model_folding,

model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/ru_aggregation_methods.py

@@ -1,105 +0,0 @@
-# Copyright 2022 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.
-# ==============================================================================
-import copy
-from enum import Enum
-from functools import partial
-from typing import List, Any
-import numpy as np
-
-from pulp import lpSum
-
-
-def sum_ru_values(ru_vector: np.ndarray, set_constraints: bool = True) -> List[Any]:
-    """
-    Aggregates resource utilization vector to a single resource utilization measure by summing all values.
-
-    Args:
-        ru_vector: A vector with nodes' resource utilization values.
-        set_constraints: A flag for utilizing the method for resource utilization computation of a
-            given config not for LP formalization purposes.
-
-    Returns: A list with an lpSum object for lp problem definition with the vector's sum.
-
-    """
-    if set_constraints:
-        return [lpSum(ru_vector)]
-    return [0] if len(ru_vector) == 0 else [sum(ru_vector)]
-
-
-
-def max_ru_values(ru_vector: np.ndarray, set_constraints: bool = True) -> List[float]:
-    """
-    Aggregates resource utilization vector to allow max constraint in the linear programming problem formalization.
-    In order to do so, we need to define a separate constraint on each value in the resource utilization vector,
-    to be bounded by the target resource utilization.
-
-    Args:
-        ru_vector: A vector with nodes' resource utilization values.
-        set_constraints: A flag for utilizing the method for resource utilization computation of a
-            given config not for LP formalization purposes.
-
-    Returns: A list with the vector's values, to be used to define max constraint
-    in the linear programming problem formalization.
-
-    """
-    if set_constraints:
-        return [ru for ru in ru_vector]
-    return [0] if len(ru_vector) == 0 else [max(ru_vector)]
-
-
-
-def total_ru(ru_tensor: np.ndarray, set_constraints: bool = True) -> List[float]:
-    """
-    Aggregates resource utilization vector to allow weights and activation total utilization constraint in the linear programming
-    problem formalization. In order to do so, we need to define a separate constraint on each activation memory utilization value in
-    the resource utilization vector, combined with the sum weights memory utilization.
-    Note that the given ru_tensor should contain weights and activation utilization values in each entry.
-
-    Args:
-        ru_tensor: A tensor with nodes' resource utilization values for weights and activation.
-        set_constraints: A flag for utilizing the method for resource utilization computation of a
-            given config not for LP formalization purposes.
-
-    Returns: A list with lpSum objects, to be used to define total constraint
-    in the linear programming problem formalization.
-
-    """
-    if set_constraints:
-        weights_ru = lpSum([ru[0] for ru in ru_tensor])
-        return [weights_ru + activation_ru for _, activation_ru in ru_tensor]
-    else:
-        weights_ru = sum([ru[0] for ru in ru_tensor])
-        activation_ru = max([ru[1] for ru in ru_tensor])
-        return [weights_ru + activation_ru]
-
-
-class MpRuAggregation(Enum):
-    """
-    Defines resource utilization aggregation functions that can be used to compute final resource utilization metric.
-    The enum values can be used to call a function on a set of arguments.
-
-     SUM - applies the sum_ru_values function
-
-     MAX - applies the max_ru_values function
-
-     TOTAL - applies the total_ru function
-
-    """
-    SUM = partial(sum_ru_values)
-    MAX = partial(max_ru_values)
-    TOTAL = partial(total_ru)
-
-    def __call__(self, *args):
-        return self.value(*args)

model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/ru_functions_mapping.py

@@ -1,33 +0,0 @@
-# Copyright 2022 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 NamedTuple
-
-from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import 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_methods import MpRuMetric
-
-
-# When adding a RUTarget that we want to consider in our mp search,
-# a matching pair of resource_utilization_tools computation function and a resource_utilization_tools
-# aggregation function should be added to this dictionary
-class RuFunctions(NamedTuple):
-    metric_fn: MpRuMetric
-    aggregate_fn: MpRuAggregation
-
-
-ru_functions_mapping = {RUTarget.WEIGHTS: RuFunctions(MpRuMetric.WEIGHTS_SIZE, MpRuAggregation.SUM),
-                        RUTarget.ACTIVATION: RuFunctions(MpRuMetric.ACTIVATION_MAXCUT_SIZE, MpRuAggregation.MAX),
-                        RUTarget.TOTAL: RuFunctions(MpRuMetric.TOTAL_WEIGHTS_ACTIVATION_SIZE, MpRuAggregation.TOTAL),
-                        RUTarget.BOPS: RuFunctions(MpRuMetric.BOPS_COUNT, MpRuAggregation.SUM)}

model_compression_toolkit/target_platform_capabilities/target_platform/__init__.py

@@ -1,23 +0,0 @@
-# Copyright 2022 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 model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attribute_filter import AttributeFilter
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import TargetPlatformCapabilities, OperationsSetToLayers, Smaller, SmallerEq, NotEq, Eq, GreaterEq, Greater, LayerFilterParams, OperationsToLayers, get_current_tpc
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel, OperatorsSet, \
-    OperatorSetConcat, Signedness, AttributeQuantizationConfig, OpQuantizationConfig, QuantizationConfigOptions, Fusing
-
-from mct_quantizers import QuantizationMethod
-
-