Remove nncf dependency from openvino configs (#668)

* Remove nncf dependency from openvino configs

* format

* fix

* fix format

* Add quant_method attribute

* format

* set default value to quant_method attribute

Author: echarlaix

.github/workflows/test_openvino.yml

@@ -35,7 +35,11 @@ jobs:
         pip install .[openvino,openvino-tokenizers,tests,diffusers] onnxruntime
     - name: Test with Pytest
       run: |
-        pytest tests/openvino/ --ignore test_modeling_basic --durations=0
+        pytest tests/openvino/ --ignore tests/openvino/test_modeling_basic.py --durations=0
+    - name: Test basic
+      run: |
+        pip uninstall -y nncf
+        pytest tests/openvino/test_modeling_basic.py
     - name: Test openvino-nightly
       run: |
         pip uninstall -y openvino

optimum/intel/__init__.py

@@ -59,9 +59,13 @@
     if not (is_openvino_available() and is_nncf_available()):
         raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
-    _import_structure["utils.dummy_openvino_and_nncf_objects"].extend(["OVQuantizer", "OVTrainingArguments"])
+    _import_structure["utils.dummy_openvino_and_nncf_objects"].extend(
+        ["OVQuantizer", "OVTrainingArguments", "OVQuantizationConfig", "OVWeightQuantizationConfig"]
+    )
 else:
-    _import_structure["openvino"].extend(["OVQuantizer", "OVTrainingArguments"])
+    _import_structure["openvino"].extend(
+        ["OVQuantizer", "OVTrainingArguments", "OVQuantizationConfig", "OVWeightQuantizationConfig"]
+    )
 
 
 try:
@@ -124,8 +128,6 @@
             "OVModelForVision2Seq",
             "OVModelForSequenceClassification",
             "OVModelForTokenClassification",
-            "OVQuantizationConfig",
-            "OVWeightQuantizationConfig",
             "OVConfig",
         ]
     )
@@ -188,9 +190,14 @@
         if not (is_openvino_available() and is_nncf_available()):
             raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
-        from .utils.dummy_openvino_and_nncf_objects import OVQuantizer, OVTrainingArguments
+        from .utils.dummy_openvino_and_nncf_objects import (
+            OVQuantizationConfig,
+            OVQuantizer,
+            OVTrainingArguments,
+            OVWeightQuantizationConfig,
+        )
     else:
-        from .openvino import OVQuantizer, OVTrainingArguments
+        from .openvino import OVQuantizationConfig, OVQuantizer, OVTrainingArguments, OVWeightQuantizationConfig
 
     try:
         if not (is_openvino_available() and is_nncf_available() and is_accelerate_available()):
@@ -244,8 +251,6 @@
             OVModelForSpeechSeq2Seq,
             OVModelForTokenClassification,
             OVModelForVision2Seq,
-            OVQuantizationConfig,
-            OVWeightQuantizationConfig,
         )
 
     try:

optimum/intel/openvino/configuration.py

@@ -18,14 +18,17 @@
 from enum import Enum
 from typing import Any, Dict, List, Optional, Union
 
-import nncf
 import torch
-from nncf.quantization.advanced_parameters import OverflowFix
 from transformers import PretrainedConfig
 from transformers.utils.quantization_config import QuantizationConfigMixin, QuantizationMethod
 
 from optimum.configuration_utils import BaseConfig
 
+from ..utils.import_utils import is_nncf_available
+
+
+if is_nncf_available():
+    import nncf
 
 logger = logging.getLogger(__name__)
 
@@ -52,12 +55,18 @@
 }
 
 
+class OVQuantizationMethod(str, Enum):
+    DEFAULT = "default"
+
+
 @dataclass
 class OVQuantizationConfigBase(QuantizationConfigMixin):
     """
     Base configuration class for quantization parameters
     """
 
+    quant_method = OVQuantizationMethod.DEFAULT
+
     def __init__(
         self,
         ignored_scope: Optional[dict] = None,
@@ -91,7 +100,7 @@ def post_init(self):
         if not (self.num_samples is None or isinstance(self.num_samples, int) and self.num_samples > 0):
             raise ValueError(f"`num_samples` is expected to be a positive integer, but found: {self.num_samples}")
 
-    def get_ignored_scope_instance(self) -> nncf.IgnoredScope:
+    def get_ignored_scope_instance(self) -> "nncf.IgnoredScope":
         if self.ignored_scope is None:
             return nncf.IgnoredScope()
         return nncf.IgnoredScope(**copy.deepcopy(self.ignored_scope))
@@ -178,10 +187,6 @@ def to_diff_dict(self) -> Dict[str, Any]:
         return self._to_dict_safe(to_diff_dict=True)
 
 
-class OVQuantizationMethod(str, Enum):
-    DEFAULT = "default"
-
-
 @dataclass
 class OVWeightQuantizationConfig(OVQuantizationConfigBase):
     """
@@ -240,7 +245,7 @@ def __init__(
         sensitivity_metric: Optional[str] = None,
         ignored_scope: Optional[dict] = None,
         num_samples: Optional[int] = None,
-        quant_method: Optional[Union[QuantizationMethod, OVQuantizationMethod]] = OVQuantizationMethod.DEFAULT,
+        quant_method: Union[QuantizationMethod, OVQuantizationMethod] = OVQuantizationMethod.DEFAULT,
         weight_only: Optional[bool] = True,
         **kwargs,
     ):
@@ -309,12 +314,12 @@ def post_init(self):
 class OVQuantizationConfig(OVQuantizationConfigBase):
     def __init__(
         self,
+        sym: bool = False,
         ignored_scope: Optional[dict] = None,
         num_samples: Optional[int] = 300,
-        preset: nncf.QuantizationPreset = None,
-        model_type: nncf.ModelType = nncf.ModelType.TRANSFORMER,
+        model_type: str = "transformer",
         fast_bias_correction: bool = True,
-        overflow_fix: OverflowFix = OverflowFix.DISABLE,
+        overflow_fix: str = "disable",
         weight_only: Optional[bool] = False,
         **kwargs,
     ):
@@ -323,23 +328,18 @@ def __init__(
         compression, during quantization both weights and activations are converted to lower precision.
         For weight-only model quantization please see OVWeightQuantizationConfig.
         Args:
+            sym (`bool`, defaults to `False`):
+                Whether to use symmetric quantization on the activations. Symmetric quantization will be applied on the weights in any case.
             ignored_scope (`dict`, *optional*):
                 An ignored scope that defines the list of model nodes to be ignored during quantization. Dictionary
                 entries provided via this argument are used to create an instance of `nncf.IgnoredScope` class.
             num_samples (`int`, *optional*):
                 The maximum number of samples composing the calibration dataset.
-            preset (`nncf.QuantizationPreset`, *optional*):
-                A preset controls the quantization mode (symmetric and asymmetric).
-                It can take the following values:
-                - `performance`: Symmetric quantization of weights and activations.
-                - `mixed`: Symmetric quantization of weights and asymmetric quantization of activations.
-                Default value is None. In this case, `mixed` preset is used for `transformer`
-                model type otherwise `performance`.
-            model_type (`nncf.ModelType`, defaults to nncf.ModelType.TRANSFORMER):
+            model_type (`str`, defaults to "transformer"):
                 Model type is needed to specify additional patterns in the model. Supported only `transformer` now.
             fast_bias_correction (`bool`, defaults to True):
                 Whether to apply fast or full bias correction algorithm.
-            overflow_fix (`nncf.OverflowFix`, default to OverflowFix.DISABLE):
+            overflow_fix (`str`, default to "disable"):
                 Parameter for controlling overflow fix setting.
             weight_only (`bool`, *optional*):
                 Used to explicitly specify type of quantization (weight-only of full) to apply. Useful when building
@@ -351,37 +351,12 @@ def __init__(
                 "Please check your configuration."
             )
         super().__init__(ignored_scope, num_samples, False)
-        # TODO: remove checks below once NNCF is updated to 2.10
-        if isinstance(overflow_fix, str):
-            overflow_fix = OverflowFix(overflow_fix)
-        if isinstance(preset, str):
-            preset = nncf.QuantizationPreset(preset)
-
-        self.preset = preset
+        self.sym = sym
         self.model_type = model_type
         self.fast_bias_correction = fast_bias_correction
         self.overflow_fix = overflow_fix
         self.post_init()
 
-    def to_dict(self) -> Dict[str, Any]:
-        # TODO: remove code below once NNCF is updated to 2.10
-        if isinstance(self.overflow_fix, Enum) or isinstance(self.preset, Enum):
-            overflow_fix_value = (
-                None
-                if self.overflow_fix is None
-                else self.overflow_fix
-                if isinstance(self.overflow_fix, str)
-                else self.overflow_fix.value
-            )
-            preset_value = (
-                None if self.preset is None else self.preset if isinstance(self.preset, str) else self.preset.value
-            )
-            self_copy = copy.deepcopy(self)
-            self_copy.overflow_fix = overflow_fix_value
-            self_copy.preset = preset_value
-            return self_copy.to_dict()
-        return super().to_dict()
-
 
 def _check_default_4bit_configs(config: PretrainedConfig):
     return _DEFAULT_4BIT_CONFIGS.get(config.name_or_path, None)

optimum/intel/openvino/quantization.py

@@ -26,7 +26,7 @@
 import torch
 import transformers
 from nncf import CompressWeightsMode, SensitivityMetric
-from nncf.quantization.advanced_parameters import AdvancedSmoothQuantParameters
+from nncf.quantization.advanced_parameters import AdvancedSmoothQuantParameters, OverflowFix
 from nncf.torch import register_module
 from nncf.torch.initialization import PTInitializingDataLoader
 from openvino._offline_transformations import compress_quantize_weights_transformation
@@ -378,10 +378,12 @@ def _quantize_ovbasemodel(
             quantization_dataset,
             subset_size=quantization_config.num_samples,
             ignored_scope=quantization_config.get_ignored_scope_instance(),
-            model_type=quantization_config.model_type,
-            preset=quantization_config.preset,
+            model_type=nncf.ModelType(quantization_config.model_type),
+            preset=nncf.QuantizationPreset.PERFORMANCE if quantization_config.sym else nncf.QuantizationPreset.MIXED,
             fast_bias_correction=quantization_config.fast_bias_correction,
-            advanced_parameters=nncf.AdvancedQuantizationParameters(overflow_fix=quantization_config.overflow_fix),
+            advanced_parameters=nncf.AdvancedQuantizationParameters(
+                overflow_fix=OverflowFix(quantization_config.overflow_fix)
+            ),
             **kwargs,
         )
         self.model.model = quantized_model
@@ -476,10 +478,14 @@ def _quantize_torchmodel(
                 quantization_dataset,
                 subset_size=quantization_config.num_samples,
                 ignored_scope=quantization_config.get_ignored_scope_instance(),
-                model_type=quantization_config.model_type,
-                preset=quantization_config.preset,
+                model_type=nncf.ModelType(quantization_config.model_type),
+                preset=nncf.QuantizationPreset.PERFORMANCE
+                if quantization_config.sym
+                else nncf.QuantizationPreset.MIXED,
                 fast_bias_correction=quantization_config.fast_bias_correction,
-                advanced_parameters=nncf.AdvancedQuantizationParameters(overflow_fix=quantization_config.overflow_fix),
+                advanced_parameters=nncf.AdvancedQuantizationParameters(
+                    overflow_fix=OverflowFix(quantization_config.overflow_fix)
+                ),
                 **kwargs,
             )
 

optimum/intel/utils/dummy_openvino_and_nncf_objects.py

@@ -46,3 +46,25 @@ def __init__(self, *args, **kwargs):
     @classmethod
     def from_pretrained(cls, *args, **kwargs):
         requires_backends(cls, ["openvino", "nncf"])
+
+
+class OVWeightQuantizationConfig(metaclass=DummyObject):
+    _backends = ["openvino", "nncf"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["openvino", "nncf"])
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        requires_backends(cls, ["openvino", "nncf"])
+
+
+class OVQuantizationConfig(metaclass=DummyObject):
+    _backends = ["openvino", "nncf"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["openvino", "nncf"])
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        requires_backends(cls, ["openvino", "nncf"])

optimum/intel/utils/dummy_openvino_objects.py

@@ -189,14 +189,3 @@ def __init__(self, *args, **kwargs):
     @classmethod
     def from_pretrained(cls, *args, **kwargs):
         requires_backends(cls, ["openvino"])
-
-
-class OVWeightQuantizationConfig(metaclass=DummyObject):
-    _backends = ["openvino"]
-
-    def __init__(self, *args, **kwargs):
-        requires_backends(self, ["openvino"])
-
-    @classmethod
-    def from_pretrained(cls, *args, **kwargs):
-        requires_backends(cls, ["openvino"])

tests/openvino/test_quantization.py

@@ -748,10 +748,10 @@ class OVQuantizationConfigTest(unittest.TestCase):
             OVQuantizationConfig(
                 ignored_scope={"names": ["op_name"]},
                 num_samples=100,
-                preset=nncf.QuantizationPreset.MIXED,
-                model_type=nncf.ModelType.TRANSFORMER,
+                sym=False,
+                model_type="transformer",
                 fast_bias_correction=True,
-                overflow_fix=OverflowFix.DISABLE,
+                overflow_fix="disable",
             ),
         ),
         (OVQuantizationConfig(ignored_scope=nncf.IgnoredScope(names=["op_name"])),),
@@ -789,15 +789,15 @@ class OVQuantizationConfigTest(unittest.TestCase):
             OVWeightQuantizationConfig,
             "Can't determine type of OV quantization config",
         ),
-        (dict(model_type=nncf.ModelType.TRANSFORMER), OVQuantizationConfig, None),
+        (dict(model_type="transformer"), OVQuantizationConfig, None),
         (
             dict(
                 ignored_scope={"names": ["op_name"]},
                 num_samples=100,
-                preset=nncf.QuantizationPreset.MIXED,
-                model_type=nncf.ModelType.TRANSFORMER,
+                sym=False,
+                model_type="transformer",
                 fast_bias_correction=True,
-                overflow_fix=OverflowFix.DISABLE,
+                overflow_fix="disable",
             ),
             OVQuantizationConfig,
             None,
@@ -809,21 +809,11 @@ class OVQuantizationConfigTest(unittest.TestCase):
         (dict(bits=8, fast_bias_correction=True, weight_only=True), OVWeightQuantizationConfig, None),
         (dict(bits=8, fast_bias_correction=True, weight_only=False), OVQuantizationConfig, None),
         (dict(bits=8, sym=True, weight_only=False), OVWeightQuantizationConfig, "Please check your configuration"),
-        (
-            dict(model_type=nncf.ModelType.TRANSFORMER, weight_only=True),
-            OVQuantizationConfig,
-            "Please check your configuration",
-        ),
+        (dict(model_type="transformer", weight_only=True), OVQuantizationConfig, "Please check your configuration"),
     )
 
     @parameterized.expand(QUANTIZATION_CONFIGS)
     def test_config_serialization(self, quantization_config: OVQuantizationConfigBase):
-        def str_to_enum(enum_cls, value):
-            for k, v in enum_cls.__members__.items():
-                if getattr(enum_cls, k).value == value:
-                    return v
-            raise ValueError(f"Could not convert string {value} to enum value of type {enum_cls}")
-
         ov_config = OVConfig(quantization_config=quantization_config)
         with tempfile.TemporaryDirectory() as tmp_dir:
             ov_config.save_pretrained(tmp_dir)
@@ -834,14 +824,6 @@ def str_to_enum(enum_cls, value):
                 return
             for key, value in loaded_ov_config.quantization_config.to_dict().items():
                 initial_value = getattr(ov_config.quantization_config, key)
-                if key == "preset" or key == "overflow_fix":
-                    # TODO: remove once NNCF is updated to 2.10
-                    if getattr(quantization_config, key) is not None:
-                        self.assertTrue(isinstance(value, str))
-                        if key == "preset":
-                            value = str_to_enum(nncf.QuantizationPreset, value)
-                        else:
-                            value = str_to_enum(OverflowFix, value)
                 self.assertEqual(value, initial_value)
 
     @parameterized.expand(QUANTIZATION_CONFIG_DICTS)