Make quantization config contain only serializable properties.

Author: nikita-savelyevv

Makefile

@@ -21,7 +21,7 @@ REAL_CLONE_URL = $(if $(CLONE_URL),$(CLONE_URL),$(DEFAULT_CLONE_URL))
 
 # Run code quality checks
 style_check:
-	black --check .
+	black .
 	ruff check .
 
 style:

optimum/intel/openvino/configuration.py

@@ -11,13 +11,13 @@
 #  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 json
+import copy
+import inspect
 import logging
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Union
 
-import datasets
 import nncf
 import torch
 from nncf.quantization.advanced_parameters import OverflowFix
@@ -52,36 +52,6 @@
 }
 
 
-class _replace_properties_values:
-    """
-    A context manager for temporarily overriding an object's properties
-    """
-
-    def __init__(self, obj, property_names, property_values):
-        self.obj = obj
-        self.property_names = property_names
-        self.new_property_values = property_values
-        self.old_property_values = [None] * len(property_names)
-        for i, property_name in enumerate(self.property_names):
-            self.old_property_values[i] = getattr(obj, property_name)
-
-    def __enter__(self):
-        for property_name, new_property_value in zip(self.property_names, self.new_property_values):
-            setattr(self.obj, property_name, new_property_value)
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        for property_name, old_property_value in zip(self.property_names, self.old_property_values):
-            setattr(self.obj, property_name, old_property_value)
-
-
-def _is_serializable(obj):
-    try:
-        json.dumps(obj)
-        return True
-    except Exception:
-        return False
-
-
 @dataclass
 class OVQuantizationConfigBase(QuantizationConfigMixin):
     """
@@ -90,53 +60,41 @@ class OVQuantizationConfigBase(QuantizationConfigMixin):
 
     def __init__(
         self,
-        dataset: Optional[Union[str, List[str], nncf.Dataset, datasets.Dataset]] = None,
-        ignored_scope: Optional[Union[dict, nncf.IgnoredScope]] = None,
+        ignored_scope: Optional[dict] = None,
         num_samples: Optional[int] = None,
+        weight_only: Optional[bool] = None,
+        **kwargs,
     ):
         """
         Args:
-            dataset (`str or List[str] or nncf.Dataset or datasets.Dataset`, *optional*):
-                 The dataset used for data-aware weight compression or quantization with NNCF.
-            ignored_scope (`dict or nncf.IgnoredScope`, *optional*):
-                An ignored scope that defines the list of model nodes to be ignored during quantization.
+            ignored_scope (`dict`, *optional*):
+                An ignored scope that defines a 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.
+            weight_only (`bool`, *optional*):
+                Used to explicitly specify type of quantization (weight-only of full) to apply.
         """
-        self.dataset = dataset
-        if isinstance(ignored_scope, dict):
-            ignored_scope = nncf.IgnoredScope(**ignored_scope)
+        if isinstance(ignored_scope, nncf.IgnoredScope):
+            ignored_scope = ignored_scope.__dict__
         self.ignored_scope = ignored_scope
         self.num_samples = num_samples
+        self.weight_only = weight_only
 
     def post_init(self):
-        if not (self.dataset is None or isinstance(self.dataset, (str, list, nncf.Dataset, datasets.Dataset))):
+        try:
+            self.get_ignored_scope_instance()
+        except Exception as e:
             raise ValueError(
-                "Dataset must be a instance of either string, list of strings, nncf.Dataset or "
-                f"dataset.Dataset, but found {type(self.dataset)}"
-            )
-        if not (self.ignored_scope is None or isinstance(self.ignored_scope, nncf.IgnoredScope)):
-            raise ValueError(
-                "Ignored scope must be a instance of either dict, or nncf.IgnoredScope but found "
-                f"{type(self.dataset)}"
+                f"Can't create an `IgnoredScope` object from the provided ignored scope dict: {self.ignored_scope}.\n{e}"
             )
+        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 _to_dict_without_properties(self, property_names: Union[List[str], Tuple[str]]) -> Dict[str, Any]:
-        """
-        Calls to_dict() with given properties overwritten with None. Useful for hiding non-serializable properties.
-        """
-        if len(property_names) == 0:
-            return super().to_dict()
-        with _replace_properties_values(self, property_names, [None] * len(property_names)):
-            result = super().to_dict()
-        return result
-
-    def to_dict(self) -> Dict[str, Any]:
-        properties_to_omit = [] if _is_serializable(self.dataset) else ["dataset"]
-        if isinstance(self.ignored_scope, nncf.IgnoredScope):
-            with _replace_properties_values(self, ["ignored_scope"], [self.ignored_scope.__dict__]):
-                return self._to_dict_without_properties(properties_to_omit)
-        return self._to_dict_without_properties(properties_to_omit)
+    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))
 
 
 class OVConfig(BaseConfig):
@@ -155,16 +113,11 @@ def __init__(
         self.input_info = input_info
         self.save_onnx_model = save_onnx_model
         self.optimum_version = kwargs.pop("optimum_version", None)
+        if isinstance(quantization_config, dict):
+            quantization_config = self._quantization_config_from_dict(quantization_config)
         self.quantization_config = quantization_config
         self.compression = None  # A backward-compatability field for training-time compression parameters
 
-        if isinstance(self.quantization_config, dict):
-            # Config is loaded as dict during deserialization
-            logger.info(
-                "`quantization_config` was provided as a dict, in this form it can't be used for quantization. "
-                "Please provide config as an instance of OVWeightQuantizationConfig or OVQuantizationConfig"
-            )
-
         bits = (
             self.quantization_config.bits if isinstance(self.quantization_config, OVWeightQuantizationConfig) else None
         )
@@ -180,12 +133,40 @@ def add_input_info(self, model_inputs: Dict, force_batch_one: bool = False):
             for name, value in model_inputs.items()
         ]
 
+    @staticmethod
+    def _quantization_config_from_dict(quantization_config: dict) -> OVQuantizationConfigBase:
+        wq_args = inspect.getfullargspec(OVWeightQuantizationConfig.__init__).args
+        q_args = inspect.getfullargspec(OVQuantizationConfig.__init__).args
+        config_keys = quantization_config.keys()
+        matches_wq_config_signature = all(arg_name in wq_args for arg_name in config_keys)
+        matches_q_config_signature = all(arg_name in q_args for arg_name in config_keys)
+        if matches_wq_config_signature == matches_q_config_signature:
+            weight_only = quantization_config.get("weight_only", None)
+            if weight_only is None:
+                logger.warning(
+                    "Can't determine type of OV quantization config. Please specify explicitly whether you intend to "
+                    "run weight-only quantization or not with `weight_only` parameter. Creating an instance of "
+                    "OVWeightQuantizationConfig."
+                )
+                return OVWeightQuantizationConfig.from_dict(quantization_config)
+            matches_wq_config_signature = weight_only
+
+        config_type = OVWeightQuantizationConfig if matches_wq_config_signature else OVQuantizationConfig
+        return config_type.from_dict(quantization_config)
+
     def _to_dict_safe(self, to_diff_dict: bool = False) -> Dict[str, Any]:
+        class ConfigStub:
+            def to_dict(self):
+                return None
+
+            def to_diff_dict(self):
+                return None
+
         if self.quantization_config is None:
             # Parent to_dict() implementation does not support quantization_config being None
-            with _replace_properties_values(self, ("quantization_config",), (OVQuantizationConfigBase(),)):
-                result = super().to_diff_dict() if to_diff_dict else super().to_dict()
-                del result["quantization_config"]
+            self_copy = copy.deepcopy(self)
+            self_copy.quantization_config = ConfigStub()
+            result = self_copy.to_diff_dict() if to_diff_dict else self_copy.to_dict()
         else:
             result = super().to_diff_dict() if to_diff_dict else super().to_dict()
         return result
@@ -212,9 +193,8 @@ class OVWeightQuantizationConfig(OVQuantizationConfigBase):
             The number of bits to quantize to.
         sym (`bool`, defaults to `False`):
             Whether to use symmetric quantization.
-        tokenizer (`str` or `PreTrainedTokenizerBase`, *optional*):
+        tokenizer (`str`, *optional*):
             The tokenizer used to process the dataset. You can pass either:
-                - A custom tokenizer object.
                 - A string, the *model id* of a predefined tokenizer hosted inside a model repo on huggingface.co.
                     Valid model ids can be located at the root-level, like `bert-base-uncased`, or namespaced under a
                     user or organization name, like `dbmdz/bert-base-german-cased`.
@@ -224,6 +204,8 @@ class OVWeightQuantizationConfig(OVQuantizationConfigBase):
             The dataset used for data-aware compression or quantization with NNCF. You can provide your own dataset
             in a list of strings or just use the one from the list ['wikitext','c4','c4-new','ptb','ptb-new'] for LLLMs
             or ['conceptual_captions','laion/220k-GPT4Vision-captions-from-LIVIS','laion/filtered-wit'] for diffusion models.
+            Alternatively, you can provide data objects via `calibration_dataset` argument
+            of `OVQuantizer.quantize()` method.
         ratio (`float`, defaults to 1.0):
             The ratio between baseline and backup precisions (e.g. 0.9 means 90% of layers quantized to INT4_ASYM
             and the rest to INT8_ASYM).
@@ -235,32 +217,44 @@ class OVWeightQuantizationConfig(OVQuantizationConfigBase):
             The sensitivity metric for assigning quantization precision to layers. In order to
             preserve the accuracy of the model, the more sensitive layers receives a higher precision.
         ignored_scope (`dict`, *optional*):
-            An ignored scope that defined the list of model control flow graph nodes to be ignored during quantization.
+            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.
         quant_method (`str`, defaults of OVQuantizationMethod.DEFAULT):
             Weight compression method to apply.
+            weight_only (`bool`, *optional*):
+                Used to explicitly specify type of quantization to apply.
+        weight_only (`bool`, *optional*):
+            Used to explicitly specify type of quantization (weight-only of full) to apply.
     """
 
     def __init__(
         self,
         bits: int = 8,
         sym: bool = False,
-        tokenizer: Optional[Any] = None,
-        dataset: Optional[Union[str, List[str], nncf.Dataset, datasets.Dataset]] = None,
+        tokenizer: Optional[str] = None,
+        dataset: Optional[Union[str, List[str]]] = None,
         ratio: float = 1.0,
         group_size: Optional[int] = None,
         all_layers: Optional[bool] = None,
         sensitivity_metric: Optional[str] = None,
-        ignored_scope: Optional[Union[dict, nncf.IgnoredScope]] = None,
+        ignored_scope: Optional[dict] = None,
         num_samples: Optional[int] = None,
         quant_method: Optional[Union[QuantizationMethod, OVQuantizationMethod]] = OVQuantizationMethod.DEFAULT,
+        weight_only: Optional[bool] = True,
         **kwargs,
     ):
-        super().__init__(dataset, ignored_scope, num_samples)
+        if weight_only is False:
+            logger.warning(
+                "Trying to create an instance of `OVWeightQuantizationConfig` with `weight_only` being "
+                "False. Please check your configuration."
+            )
+        super().__init__(ignored_scope, num_samples, True)
         self.bits = bits
         self.sym = sym
         self.tokenizer = tokenizer
+        self.dataset = dataset
         self.group_size = group_size or (-1 if bits == 8 else 128)
         self.ratio = ratio
         self.all_layers = all_layers
@@ -277,6 +271,11 @@ def post_init(self):
             raise ValueError("`ratio` must between 0 and 1.")
         if self.group_size is not None and self.group_size != -1 and self.group_size <= 0:
             raise ValueError("`group_size` must be greater than 0 or equal to -1")
+        if not (self.dataset is None or isinstance(self.dataset, (str, list))):
+            raise ValueError(
+                f"Dataset must be a instance of either string or list of strings, but found {type(self.dataset)}. "
+                f"If you wish to provide a custom dataset please pass it via `calibration_dataset` argument."
+            )
         if self.dataset is not None and isinstance(self.dataset, str):
             llm_datasets = ["wikitext", "c4", "c4-new", "ptb", "ptb-new"]
             stable_diffusion_datasets = [
@@ -303,34 +302,31 @@ def post_init(self):
                     f"For 8-bit quantization, `group_size` is expected to be set to -1, but was set to {self.group_size}"
                 )
 
-    def to_dict(self) -> Dict[str, Any]:
-        if not _is_serializable(self.tokenizer):
-            return self._to_dict_without_properties(("tokenizer",))
-        return super().to_dict()
+        if self.tokenizer is not None and not isinstance(self.tokenizer, str):
+            raise ValueError(f"Tokenizer is expected to be a string, but found {self.tokenizer}")
 
 
 @dataclass
 class OVQuantizationConfig(OVQuantizationConfigBase):
     def __init__(
         self,
-        dataset: Union[str, List[str], nncf.Dataset, datasets.Dataset],
-        ignored_scope: Optional[Union[dict, nncf.IgnoredScope]] = None,
+        ignored_scope: Optional[dict] = None,
         num_samples: Optional[int] = 300,
         preset: nncf.QuantizationPreset = None,
         model_type: nncf.ModelType = nncf.ModelType.TRANSFORMER,
         fast_bias_correction: bool = True,
         overflow_fix: OverflowFix = OverflowFix.DISABLE,
+        weight_only: Optional[bool] = False,
         **kwargs,
     ):
         """
         Configuration class containing parameters related to model quantization with NNCF. Compared to weight
         compression, during quantization both weights and activations are converted to lower precision.
         For weight-only model quantization please see OVWeightQuantizationConfig.
         Args:
-            dataset (`str or List[str] or nncf.Dataset or datasets.Dataset`):
-                 A dataset used for quantization parameters calibration. Required parameter.
-            ignored_scope (`dict or nncf.IgnoredScope`, *optional*):
-                An ignored scope that defines the list of model nodes to be ignored during quantization.
+            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*):
@@ -346,31 +342,45 @@ def __init__(
                 Whether to apply fast or full bias correction algorithm.
             overflow_fix (`nncf.OverflowFix`, default to OverflowFix.DISABLE):
                 Parameter for controlling overflow fix setting.
+            weight_only (`bool`, *optional*):
+                Used to explicitly specify type of quantization (weight-only of full) to apply.
         """
-        super().__init__(dataset, ignored_scope, num_samples)
+        if weight_only is True:
+            logger.warning(
+                "Trying to create an instance of `OVQuantizationConfig` with `weight_only` being True. "
+                "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.model_type = model_type
         self.fast_bias_correction = fast_bias_correction
         self.overflow_fix = overflow_fix
         self.post_init()
 
-    def post_init(self):
-        """
-        Safety checker that arguments are correct
-        """
-        super().post_init()
-        if self.dataset is None:
-            raise ValueError(
-                "`dataset` is needed to compute the activations range during the calibration step and was not provided."
-                " In case you only want to apply quantization on the weights, please run weight-only quantization."
-            )
-
     def to_dict(self) -> Dict[str, Any]:
         # TODO: remove code below once NNCF is updated to 2.10
-        overflow_fix_value = None if self.overflow_fix is None else self.overflow_fix.value
-        preset_value = None if self.preset is None else self.preset.value
-        with _replace_properties_values(self, ("overflow_fix", "preset"), (overflow_fix_value, preset_value)):
-            return super().to_dict()
+        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):

optimum/intel/openvino/modeling_base.py

@@ -18,6 +18,7 @@
 from tempfile import TemporaryDirectory, gettempdir
 from typing import Dict, Optional, Union
 
+import nncf
 import openvino
 from huggingface_hub import hf_hub_download
 from openvino import Core, convert_model
@@ -100,7 +101,11 @@ def __init__(
             self._openvino_config = OVConfig(quantization_config=quantization_config)
 
     @staticmethod
-    def load_model(file_name: Union[str, Path], quantization_config: Union[OVWeightQuantizationConfig, Dict] = None):
+    def load_model(
+        file_name: Union[str, Path],
+        quantization_config: Union[OVWeightQuantizationConfig, Dict] = None,
+        calibration_dataset: Optional[nncf.Dataset] = None,
+    ):
         """
         Loads the model.
 
@@ -135,7 +140,7 @@ def fix_op_names_duplicates(model: openvino.runtime.Model):
 
             from optimum.intel.openvino.quantization import _weight_only_quantization
 
-            model = _weight_only_quantization(model, quantization_config)
+            model = _weight_only_quantization(model, quantization_config, calibration_dataset=calibration_dataset)
 
         return model
 

optimum/intel/openvino/modeling_decoder.py

@@ -19,6 +19,7 @@
 from tempfile import TemporaryDirectory
 from typing import Dict, Optional, Tuple, Union
 
+import nncf
 import numpy as np
 import openvino
 import torch
@@ -572,7 +573,8 @@ def _from_pretrained(
         from_onnx: bool = False,
         local_files_only: bool = False,
         load_in_8bit: bool = False,
-        quantization_config: Union[OVWeightQuantizationConfig, Dict] = None,
+        quantization_config: Optional[Union[OVWeightQuantizationConfig, Dict]] = None,
+        calibration_dataset: Optional[nncf.Dataset] = None,
         **kwargs,
     ):
         model_path = Path(model_id)
@@ -596,7 +598,11 @@ def _from_pretrained(
         quantization_config = cls._prepare_weight_quantization_config(quantization_config, load_in_8bit)
 
         load_in_4bit = quantization_config.bits == 4 if quantization_config else False
-        model = cls.load_model(model_cache_path, quantization_config=None if load_in_4bit else quantization_config)
+        model = cls.load_model(
+            model_cache_path,
+            quantization_config=None if load_in_4bit else quantization_config,
+            calibration_dataset=calibration_dataset,
+        )
 
         model_type = config.model_type.replace("_", "-")
         if model_type == "bloom":
@@ -632,7 +638,7 @@ def _from_pretrained(
                     f"For the given model, we recommend the following `quantization_config` : {default_config}"
                 )
 
-            if isinstance(quantization_config.dataset, str):
+            if calibration_dataset is None and isinstance(quantization_config.dataset, str):
                 tokenizer = quantization_config.tokenizer or AutoTokenizer.from_pretrained(model_id)
 
                 from optimum.gptq.data import get_dataset, prepare_dataset
@@ -644,9 +650,9 @@ def _from_pretrained(
                 dataset = get_dataset(quantization_config.dataset, tokenizer, seqlen=32, nsamples=nsamples)
                 dataset = prepare_dataset(dataset)
                 quantization_config = copy.deepcopy(quantization_config)
-                quantization_config.dataset = nncf.Dataset(dataset, lambda x: causal_model.prepare_inputs(**x))
+                calibration_dataset = nncf.Dataset(dataset, lambda x: causal_model.prepare_inputs(**x))
 
-            _weight_only_quantization(model, quantization_config)
+            _weight_only_quantization(model, quantization_config, calibration_dataset)
 
         return causal_model
 

optimum/intel/openvino/quantization.py

@@ -18,8 +18,9 @@
 import os
 from collections import deque
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union
 
+import datasets
 import nncf
 import openvino
 import torch
@@ -203,6 +204,7 @@ def from_pretrained(cls, model: PreTrainedModel, **kwargs):
 
     def quantize(
         self,
+        calibration_dataset: Optional[Union[datasets.Dataset, nncf.Dataset, Iterable]] = None,
         save_directory: Union[str, Path] = None,
         ov_config: OVConfig = None,
         file_name: Optional[str] = None,
@@ -216,6 +218,9 @@ def quantize(
         Quantize a model given the optimization specifications defined in `quantization_config`.
 
         Args:
+            calibration_dataset (`datasets.Dataset` or `nncf.Dataset` or `Iterable`, *optional*):
+                A collection of data samples to use for quantization calibration. Is optional for weight-only
+                quantization and is required for full quantization.
             save_directory (`Union[str, Path]`):
                 The directory where the quantized model should be saved.
             ov_config (`OVConfig`, *optional*):
@@ -235,6 +240,16 @@ def quantize(
                 floating-point. Fits best for LLM footprint reduction and performance acceleration.
 
         Examples:
+        ```python
+        >>> from optimum.intel.openvino import OVQuantizer, OVModelForCausalLM
+        >>> from transformers import AutoModelForCausalLM
+        >>> model = AutoModelForCausalLM.from_pretrained("databricks/dolly-v2-3b")
+        >>> quantizer = OVQuantizer.from_pretrained(model, task="text-generation")
+        >>> ov_config = OVConfig(quantization_config=OVWeightQuantizationConfig(bits=8, sym=True))
+        >>> quantizer.quantize(ov_config=ov_config, save_directory="./quantized_model")
+        >>> optimized_model = OVModelForCausalLM.from_pretrained("./quantized_model")
+        ```
+
         ```python
         >>> from optimum.intel.openvino import OVQuantizer, OVModelForSequenceClassification
         >>> from transformers import AutoModelForSequenceClassification
@@ -243,25 +258,10 @@ def quantize(
         >>> model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased-finetuned-sst-2-english")
         >>> quantizer = OVQuantizer.from_pretrained(model, task="text-classification")
         >>> ov_config = OVConfig(quantization_config=OVQuantizationConfig(dataset=calibration_dataset))
-        >>> quantizer.quantize(ov_config=ov_config, save_directory="./quantized_model")
+        >>> quantizer.quantize(calibration_dataset=dataset, ov_config=ov_config, save_directory="./quantized_model")
         >>> optimized_model = OVModelForSequenceClassification.from_pretrained("./quantized_model")
         ```
-
-        ```python
-        >>> from optimum.intel.openvino import OVQuantizer, OVModelForCausalLM
-        >>> from transformers import AutoModelForCausalLM
-        >>> model = AutoModelForCausalLM.from_pretrained("databricks/dolly-v2-3b")
-        >>> quantizer = OVQuantizer.from_pretrained(model, task="text-generation")
-        >>> ov_config = OVConfig(quantization_config=OVWeightQuantizationConfig(bits=8, sym=True))
-        >>> quantizer.quantize(ov_config=ov_config, save_directory="./quantized_model")
-        >>> optimized_model = OVModelForCausalLM.from_pretrained("./quantized_model")
-        ```
         """
-        if "calibration_dataset" in kwargs:
-            raise ValueError(
-                "`calibration_dataset` argument is deprecated. Please provide calibration dataset "
-                "with `ov_config.quantization_config.dataset`."
-            )
         if weights_only is not None:
             logger.warning(
                 "`weights_only` argument is deprecated. In the future please provide `ov_config.quantization_config` "
@@ -282,15 +282,21 @@ def quantize(
             if weights_only is None or weights_only is True:
                 if weights_only is None:
                     logger.info(
-                        "`quantization_config` was not provided, 8-bit symmetric weight quantization will be applied."
+                        "`quantization_config` was not provided, 8-bit asymmetric weight quantization will be applied."
                     )
-                ov_config.quantization_config = OVWeightQuantizationConfig(bits=8, sym=True)
+                ov_config.quantization_config = OVWeightQuantizationConfig(bits=8)
             else:
                 ov_config.quantization_config = OVQuantizationConfig()
 
         if isinstance(self.model, OVBaseModel):
             self._quantize_ovbasemodel(
-                ov_config, save_directory, batch_size, data_collator, remove_unused_columns, **kwargs
+                ov_config,
+                save_directory,
+                calibration_dataset,
+                batch_size,
+                data_collator,
+                remove_unused_columns,
+                **kwargs,
             )
 
         elif isinstance(self.model, torch.nn.Module):
@@ -299,7 +305,14 @@ def quantize(
                 "To convert a PyTorch model to OpenVINO, you can set `export=True` when loading your model as `OVModelForXxx.from_pretrained(..., export=True)`"
             )
             self._quantize_torchmodel(
-                ov_config, save_directory, file_name, batch_size, data_collator, remove_unused_columns, **kwargs
+                ov_config,
+                save_directory,
+                calibration_dataset,
+                file_name,
+                batch_size,
+                data_collator,
+                remove_unused_columns,
+                **kwargs,
             )
         else:
             raise TypeError(f"Unsupported model type: {type(self.model)}")
@@ -308,6 +321,7 @@ def _quantize_ovbasemodel(
         self,
         ov_config: OVConfig,
         save_directory: Union[str, Path],
+        calibration_dataset: Optional[Union[datasets.Dataset, nncf.Dataset, Iterable]] = None,
         batch_size: int = 1,
         data_collator: Optional[DataCollator] = None,
         remove_unused_columns: bool = True,
@@ -318,19 +332,18 @@ def _quantize_ovbasemodel(
 
         quantization_config = ov_config.quantization_config
         if isinstance(quantization_config, OVWeightQuantizationConfig):
-            _weight_only_quantization(self.model.model, quantization_config)
+            _weight_only_quantization(self.model.model, quantization_config, calibration_dataset)
             self.model.save_pretrained(save_directory)
             ov_config.save_pretrained(save_directory)
             return
         if not isinstance(quantization_config, OVQuantizationConfig):
             raise ValueError(f"Unsupported type of quantization config: {type(quantization_config)}")
 
-        calibration_dataset = quantization_config.dataset
         if isinstance(calibration_dataset, nncf.Dataset):
             quantization_dataset = calibration_dataset
-        else:
+        elif isinstance(calibration_dataset, datasets.Dataset):
             calibration_dataloader = self._get_calibration_dataloader(
-                calibration_dataset=quantization_config.dataset,
+                calibration_dataset=calibration_dataset,
                 batch_size=batch_size,
                 remove_unused_columns=remove_unused_columns,
                 data_collator=data_collator,
@@ -353,13 +366,17 @@ def _quantize_ovbasemodel(
                 quantization_dataset = nncf.Dataset(collected_inputs)
             else:
                 quantization_dataset = nncf.Dataset(calibration_dataloader)
+        else:
+            if calibration_dataset is None:
+                raise ValueError("Calibration dataset is required to run quantization.")
+            quantization_dataset = nncf.Dataset(calibration_dataset)
 
         # Actual model quantization
         quantized_model = nncf.quantize(
             self.model.model,
             quantization_dataset,
             subset_size=quantization_config.num_samples,
-            ignored_scope=quantization_config.ignored_scope,
+            ignored_scope=quantization_config.get_ignored_scope_instance(),
             model_type=quantization_config.model_type,
             preset=quantization_config.preset,
             fast_bias_correction=quantization_config.fast_bias_correction,
@@ -374,6 +391,7 @@ def _quantize_torchmodel(
         self,
         ov_config: OVConfig,
         save_directory: Union[str, Path],
+        calibration_dataset: Optional[Union[datasets.Dataset, nncf.Dataset, Iterable]] = None,
         file_name: Optional[str] = None,
         batch_size: int = 1,
         data_collator: Optional[DataCollator] = None,
@@ -416,24 +434,18 @@ def _quantize_torchmodel(
 
         quantization_config = ov_config.quantization_config
         if isinstance(quantization_config, OVWeightQuantizationConfig):
-            dataset = quantization_config.dataset
-            if not isinstance(dataset, nncf.Dataset):
-                if dataset is not None:
-                    raise ValueError(
-                        "Please provide `dataset` for weight compression as an instance of `nncf.Dataset`."
-                    )
-                if stateful:
-                    # patch model before weight compression
-                    model = patch_model_with_bettertransformer(model)
-
-                dummy_inputs = onnx_config.generate_dummy_inputs(framework="pt")
-                device = get_model_device(model)
-                dummy_inputs = tree_map(
-                    lambda value: value.to(device) if isinstance(value, torch.Tensor) else value, dummy_inputs
-                )
-                check_dummy_inputs_are_allowed(model, dummy_inputs)
-                dataset = nncf.Dataset([dummy_inputs])
-            nncf.compress_weights(model, dataset=dataset)
+            if stateful:
+                # patch model before weight compression
+                model = patch_model_with_bettertransformer(model)
+
+            dummy_inputs = onnx_config.generate_dummy_inputs(framework="pt")
+            device = get_model_device(model)
+            dummy_inputs = tree_map(
+                lambda value: value.to(device) if isinstance(value, torch.Tensor) else value, dummy_inputs
+            )
+            check_dummy_inputs_are_allowed(model, dummy_inputs)
+
+            nncf.compress_weights(model, dataset=nncf.Dataset([dummy_inputs]))
         else:
             if not isinstance(quantization_config, OVQuantizationConfig):
                 raise ValueError(f"Unsupported type of quantization config: {type(quantization_config)}")
@@ -444,21 +456,25 @@ def _quantize_torchmodel(
                 )
                 stateful = False
 
-            if isinstance(quantization_config.dataset, nncf.Dataset):
-                quantization_dataset = quantization_config.dataset
-            else:
+            if isinstance(calibration_dataset, nncf.Dataset):
+                quantization_dataset = calibration_dataset
+            elif isinstance(calibration_dataset, datasets.Dataset):
                 calibration_dataloader = self._get_calibration_dataloader(
-                    calibration_dataset=quantization_config.dataset,
+                    calibration_dataset=calibration_dataset,
                     batch_size=batch_size,
                     remove_unused_columns=remove_unused_columns,
                     data_collator=data_collator,
                 )
                 quantization_dataset = nncf.Dataset(calibration_dataloader)
+            else:
+                if calibration_dataset is None:
+                    raise ValueError("Calibration dataset is required to run quantization.")
+                quantization_dataset = nncf.Dataset(calibration_dataset)
             model = nncf.quantize(
                 model,
                 quantization_dataset,
                 subset_size=quantization_config.num_samples,
-                ignored_scope=quantization_config.ignored_scope,
+                ignored_scope=quantization_config.get_ignored_scope_instance(),
                 model_type=quantization_config.model_type,
                 preset=quantization_config.preset,
                 fast_bias_correction=quantization_config.fast_bias_correction,
@@ -522,7 +538,7 @@ def get_calibration_dataset(
         preprocess_batch: bool = True,
         use_auth_token: bool = False,
         cache_dir: Optional[str] = None,
-    ) -> "Dataset":
+    ) -> datasets.Dataset:
         """
         Create the calibration `datasets.Dataset` to use for the post-training static quantization calibration step.
 
@@ -599,18 +615,33 @@ def _remove_unused_columns(self, dataset: "Dataset"):
 
 
 def _weight_only_quantization(
-    model: openvino.runtime.Model, quantization_config: Union[OVWeightQuantizationConfig, Dict]
+    model: openvino.runtime.Model,
+    quantization_config: Union[OVWeightQuantizationConfig, Dict],
+    calibration_dataset: Optional[Union[nncf.Dataset, Iterable]] = None,
 ) -> openvino.runtime.Model:
     config = quantization_config
     if isinstance(config, dict):
         config = OVWeightQuantizationConfig.from_dict(quantization_config)
 
-    dataset = config.dataset
-
-    if config.dataset is not None and isinstance(config.dataset, str):
-        tokenizer = config.tokenizer
-        if isinstance(tokenizer, str):
-            tokenizer = AutoTokenizer.from_pretrained(tokenizer)
+    if config.dataset is not None and calibration_dataset is not None:
+        logger.info(
+            "Both `quantization_config.dataset` and `calibration_dataset` were provided for weight only "
+            "quantization. Will rely on `calibration_dataset`."
+        )
+    dataset = None
+    if calibration_dataset is not None:
+        if isinstance(calibration_dataset, datasets.Dataset):
+            raise ValueError(
+                "Providing calibration dataset as an instance of `datasets.Dataset` for OV weight-only "
+                "quantization is not supported. Please provide it as `nncf.Dataset` or as iterable of "
+                "model inputs."
+            )
+        elif isinstance(calibration_dataset, nncf.Dataset):
+            dataset = calibration_dataset
+        else:
+            dataset = nncf.Dataset(calibration_dataset)
+    elif config.dataset is not None and isinstance(config.dataset, str):
+        tokenizer = AutoTokenizer.from_pretrained(config.tokenizer)
 
         from optimum.gptq.data import get_dataset, prepare_dataset
 
@@ -635,7 +666,7 @@ def _weight_only_quantization(
         all_layers=config.all_layers,
         sensitivity_metric=sensitivity_metric,
         # awq=config.quant_method == QuantizationMethod.AWQ,    # TODO : enable from nncf v2.9.0
-        ignored_scope=config.ignored_scope,
+        ignored_scope=config.get_ignored_scope_instance(),
         dataset=dataset,
         # subset_size=config.num_samples if config.num_samples else 128,    # TODO : enable from nncf v2.9.0
     )
@@ -706,16 +737,13 @@ def _hybrid_quantization(
     """
     ops_to_compress = _collect_ops_with_weights(model)
 
-    ignored_scope: Union[nncf.IgnoredScope, None] = quantization_config.ignored_scope
-    ignored_scope = ignored_scope or nncf.IgnoredScope()
-    ptq_ignored_scope = copy.deepcopy(ignored_scope)
-    ptq_ignored_scope.names += ops_to_compress
-
-    wc_quantization_config = copy.deepcopy(quantization_config)
-    wc_quantization_config.ignored_scope = ignored_scope
-    wc_quantization_config.ignored_scope.types.append("Convolution")
-    compressed_model = _weight_only_quantization(model, wc_quantization_config)
+    wc_config = copy.deepcopy(quantization_config)
+    wc_config.ignored_scope = wc_config.ignored_scope or {}
+    wc_config.ignored_scope["types"] = wc_config.ignored_scope.get("types", []) + ["Convolution"]
+    compressed_model = _weight_only_quantization(model, wc_config)
 
+    ptq_ignored_scope = quantization_config.get_ignored_scope_instance()
+    ptq_ignored_scope.names += ops_to_compress
     subset_size = quantization_config.num_samples if quantization_config.num_samples else 200
     quantized_model = nncf.quantize(
         model=compressed_model,

tests/openvino/test_quantization.py

@@ -15,12 +15,13 @@
 # ruff: noqa
 
 import itertools
+import logging
 import tempfile
 import unittest
 from collections import defaultdict
 from enum import Enum
 from functools import partial
-from typing import List
+from typing import List, Union
 
 import evaluate
 import numpy as np
@@ -104,9 +105,13 @@ def preprocess_function(examples, tokenizer):
                 num_samples=10,
                 dataset_split="train",
             )
-            quantization_config = OVQuantizationConfig(dataset=calibration_dataset)
-            ov_config = OVConfig(quantization_config=quantization_config)
-            quantizer.quantize(save_directory=tmp_dir, ov_config=ov_config, file_name=file_name)
+            ov_config = OVConfig(quantization_config=OVQuantizationConfig())
+            quantizer.quantize(
+                save_directory=tmp_dir,
+                calibration_dataset=calibration_dataset,
+                file_name=file_name,
+                ov_config=ov_config,
+            )
             model = model_cls.from_pretrained(tmp_dir, file_name=file_name)
 
             # TODO: uncomment once move to a newer version of NNCF which has some fixes (addmm, baddmm)
@@ -120,7 +125,7 @@ def preprocess_function(examples, tokenizer):
 
             # Verify that the configuration is correctly saved and loaded
             loaded_config = OVConfig.from_pretrained(tmp_dir)
-            self.assertEqual(ov_config.quantization_config.to_dict(), loaded_config.quantization_config)
+            self.assertEqual(ov_config.quantization_config.to_dict(), loaded_config.quantization_config.to_dict())
 
     @parameterized.expand(SUPPORTED_ARCHITECTURES_WITH_EXPECTED_QUANTIZED_MATMULS)
     def test_ovmodel_static_quantization(self, model_cls, model_name, expected_fake_quantize, expected_int8):
@@ -146,9 +151,8 @@ def preprocess_function(examples, tokenizer):
                 num_samples=10,
                 dataset_split="train",
             )
-            quantization_config = OVQuantizationConfig(dataset=calibration_dataset)
-            ov_config = OVConfig(quantization_config=quantization_config)
-            quantizer.quantize(save_directory=tmp_dir, ov_config=ov_config)
+            ov_config = OVConfig(quantization_config=OVQuantizationConfig())
+            quantizer.quantize(save_directory=tmp_dir, calibration_dataset=calibration_dataset, ov_config=ov_config)
 
             model = model_cls.from_pretrained(tmp_dir)
 
@@ -162,7 +166,7 @@ def preprocess_function(examples, tokenizer):
 
             # Verify that the configuration is correctly saved and loaded
             loaded_config = OVConfig.from_pretrained(tmp_dir)
-            self.assertEqual(ov_config.quantization_config.to_dict(), loaded_config.quantization_config)
+            self.assertEqual(ov_config.quantization_config.to_dict(), loaded_config.quantization_config.to_dict())
 
 
 class OVWeightCompressionTest(unittest.TestCase):
@@ -281,12 +285,12 @@ def test_automodel_weight_compression(self, model_cls, model_name, expected_pt_i
 
             # Verify that the configuration is correctly saved and loaded
             loaded_config = OVConfig.from_pretrained(tmp_dir)
-            original_config_as_dict = OVWeightQuantizationConfig(bits=8, sym=True).to_dict()
+            original_config_as_dict = OVWeightQuantizationConfig().to_dict()
             for k in original_config_as_dict.keys():
                 v = original_config_as_dict[k]
                 if isinstance(v, Enum):
                     original_config_as_dict[k] = v.value
-            self.assertEqual(original_config_as_dict, loaded_config.quantization_config)
+            self.assertEqual(original_config_as_dict, loaded_config.quantization_config.to_dict())
 
     @parameterized.expand(SUPPORTED_ARCHITECTURES_WITH_EXPECTED_8BIT_COMPRESSED_MATMULS)
     def test_ovmodel_8bit_weight_compression(self, model_cls, model_name, expected_pt_int8, expected_ov_int8):
@@ -311,7 +315,7 @@ def test_ovmodel_8bit_weight_compression(self, model_cls, model_name, expected_p
 
             # Verify that the configuration is correctly saved and loaded
             loaded_config = OVConfig.from_pretrained(tmp_dir)
-            self.assertEqual(OVWeightQuantizationConfig(bits=8, sym=True).to_dict(), loaded_config.quantization_config)
+            self.assertEqual(OVWeightQuantizationConfig().to_dict(), loaded_config.quantization_config.to_dict())
 
     @parameterized.expand(SUPPORTED_ARCHITECTURES_WITH_EXPECTED_4BIT_COMPRESSED_MATMULS)
     def test_ovmodel_4bit_weight_compression(self, model_cls, model_name, expected_int8, expected_int4):
@@ -342,7 +346,7 @@ def test_ovmodel_4bit_weight_compression(self, model_cls, model_name, expected_i
 
             # Verify that the configuration is correctly saved and loaded
             loaded_config = OVConfig.from_pretrained(tmp_dir)
-            self.assertEqual(ov_config.quantization_config.to_dict(), loaded_config.quantization_config)
+            self.assertEqual(ov_config.quantization_config.to_dict(), loaded_config.quantization_config.to_dict())
 
     @parameterized.expand(SUPPORTED_ARCHITECTURES_STATEFUL_WITH_EXPECTED_8BIT_COMPRESSED_MATMULS)
     @unittest.skipIf(not IS_SUPPORT_STATEFUL, "Stateful models supported only in 2023.3 and above")
@@ -368,7 +372,7 @@ def test_ovmodel_8bit_weight_compression_stateful(self, model_cls, model_id, exp
 
             # Verify that the configuration is correctly saved and loaded
             loaded_config = OVConfig.from_pretrained(tmp_dir)
-            self.assertEqual(OVWeightQuantizationConfig(bits=8, sym=True).to_dict(), loaded_config.quantization_config)
+            self.assertEqual(OVWeightQuantizationConfig().to_dict(), loaded_config.quantization_config.to_dict())
 
     @parameterized.expand(SUPPORTED_ARCHITECTURES_WITH_AUTO_COMPRESSION)
     def test_ovmodel_load_with_compressed_weights(self, model_cls, model_type):
@@ -439,11 +443,11 @@ def test_ovmodel_4bit_auto_compression(self, model_cls, model_type, expected_ov_
             model.save_pretrained(tmp_dir)
 
             openvino_config = OVConfig.from_pretrained(tmp_dir)
-            self.assertEqual(openvino_config.quantization_config["bits"], 4)
+            self.assertEqual(openvino_config.quantization_config.bits, 4)
             self.assertEqual(openvino_config.dtype, "int4")
             if model_id == "facebook/opt-125m":
                 for key, value in self.DEFAULT_INT4_CONFIG.items():
-                    self.assertEqual(value, openvino_config.quantization_config[key])
+                    self.assertEqual(value, getattr(openvino_config.quantization_config, key))
 
     @parameterized.expand(LOAD_IN_4_BITS_SCOPE)
     def test_ovmodel_4bit_auto_compression_with_config(
@@ -461,7 +465,7 @@ def test_ovmodel_4bit_auto_compression_with_config(
             model.save_pretrained(tmp_dir)
 
             openvino_config = OVConfig.from_pretrained(tmp_dir)
-            self.assertEqual(openvino_config.quantization_config["bits"], 4)
+            self.assertEqual(openvino_config.quantization_config.bits, 4)
             self.assertEqual(openvino_config.dtype, "int4")
 
     @parameterized.expand(SUPPORTED_ARCHITECTURES_WITH_EXPECTED_4BIT_AUTO_COMPRESSED_MATMULS)
@@ -492,9 +496,8 @@ def transform_fn(data, tokenizer):
         model = model_cls.from_pretrained(
             model_id,
             export=True,
-            quantization_config=OVWeightQuantizationConfig(
-                bits=4, sym=True, group_size=-1, ratio=0.8, dataset=quantization_dataset
-            ),
+            quantization_config=OVWeightQuantizationConfig(bits=4, sym=True, group_size=-1, ratio=0.8),
+            calibration_dataset=quantization_dataset,
         )
 
         _, num_int8, num_int4 = get_num_quantized_nodes(model)
@@ -584,7 +587,7 @@ def test_ovmodel_load_large_model_with_additional_quantization_config(self):
                             "all_layers": None,
                             "sensitivity_metric": None,
                             "dataset": None,
-                            "ignored_scope": None,
+                            "ignored_scope": nncf.IgnoredScope(),
                         }
                         compress_weights_patch.assert_called_with(unittest.mock.ANY, **compression_params)
 
@@ -610,9 +613,8 @@ def preprocess_function(examples, tokenizer):
                 num_samples=10,
                 dataset_split="test",
             )
-            quantization_config = OVQuantizationConfig(dataset=calibration_dataset)
-            ov_config = OVConfig(quantization_config=quantization_config)
-            quantizer.quantize(save_directory=tmp_dir, ov_config=ov_config)
+            ov_config = OVConfig(quantization_config=OVQuantizationConfig())
+            quantizer.quantize(save_directory=tmp_dir, calibration_dataset=calibration_dataset, ov_config=ov_config)
 
             # Test that inference on quantized model works
             model = OVModelForQuestionAnswering.from_pretrained(tmp_dir)
@@ -629,7 +631,7 @@ def preprocess_function(examples, tokenizer):
 
             # Verify that the configuration is correctly saved and loaded
             loaded_config = OVConfig.from_pretrained(tmp_dir)
-            self.assertEqual(ov_config.quantization_config.to_dict(), loaded_config.quantization_config)
+            self.assertEqual(ov_config.quantization_config.to_dict(), loaded_config.quantization_config.to_dict())
 
     @parameterized.expand(SUPPORTED_ARCHITECTURES)
     def test_ovmodel_static_quantization(self, model_name):
@@ -649,9 +651,8 @@ def preprocess_function(examples, tokenizer):
                 num_samples=10,
                 dataset_split="test",
             )
-            quantization_config = OVQuantizationConfig(dataset=calibration_dataset)
-            ov_config = OVConfig(quantization_config=quantization_config)
-            quantizer.quantize(save_directory=tmp_dir, ov_config=ov_config)
+            ov_config = OVConfig(quantization_config=OVQuantizationConfig())
+            quantizer.quantize(save_directory=tmp_dir, calibration_dataset=calibration_dataset, ov_config=ov_config)
 
             # Test that inference on quantized model works
             model = OVModelForQuestionAnswering.from_pretrained(tmp_dir)
@@ -668,7 +669,7 @@ def preprocess_function(examples, tokenizer):
 
             # Verify that the configuration is correctly saved and loaded
             loaded_config = OVConfig.from_pretrained(tmp_dir)
-            self.assertEqual(ov_config.quantization_config.to_dict(), loaded_config.quantization_config)
+            self.assertEqual(ov_config.quantization_config.to_dict(), loaded_config.quantization_config.to_dict())
 
 
 class OVTrainerTest(unittest.TestCase):
@@ -719,24 +720,13 @@ def compute_metrics(p):
 
 class OVQuantizationConfigTest(unittest.TestCase):
     QUANTIZATION_CONFIGS = (
-        (
-            None,
-            [],
-        ),
-        (OVWeightQuantizationConfig(), []),
+        (None,),
+        (OVWeightQuantizationConfig(),),
         (
             OVWeightQuantizationConfig(
                 bits=8,
                 sym=True,
             ),
-            [],
-        ),
-        (
-            {
-                "bits": 8,
-                "sym": True,
-            },
-            [],
         ),
         (
             OVWeightQuantizationConfig(
@@ -752,43 +742,82 @@ class OVQuantizationConfigTest(unittest.TestCase):
                 num_samples=100,
                 quant_method=OVQuantizationMethod.DEFAULT,
             ),
-            ["ignored_scope"],
         ),
-        (OVWeightQuantizationConfig(dataset=["wikitext", "c4"]), []),
-        (OVWeightQuantizationConfig(dataset=load_dataset("wikitext", "wikitext-2-raw-v1", split="test")), ["dataset"]),
-        (OVWeightQuantizationConfig(dataset=nncf.Dataset([np.zeros((1, 10))])), ["dataset"]),
+        (OVWeightQuantizationConfig(dataset=["hello world", "i'm alive"]),),
         (
-            OVWeightQuantizationConfig(tokenizer=AutoTokenizer.from_pretrained("dbmdz/bert-base-german-cased")),
-            ["tokenizer"],
+            OVQuantizationConfig(
+                ignored_scope={"names": ["op_name"]},
+                num_samples=100,
+                preset=nncf.QuantizationPreset.MIXED,
+                model_type=nncf.ModelType.TRANSFORMER,
+                fast_bias_correction=True,
+                overflow_fix=OverflowFix.DISABLE,
+            ),
         ),
-        (OVWeightQuantizationConfig(ignored_scope=nncf.IgnoredScope(names=["op_name"])), ["ignored_scope"]),
-        (OVQuantizationConfig(dataset="wikitext"), []),
-        ({"dataset": "wikitext"}, []),
+        (OVQuantizationConfig(ignored_scope=nncf.IgnoredScope(names=["op_name"])),),
+    )
+
+    QUANTIZATION_CONFIG_DICTS = (
+        (dict(bits=8, sym=True), OVWeightQuantizationConfig, None),
         (
-            OVQuantizationConfig(
+            dict(
                 dataset="wikitext",
+                bits=4,
+                ignored_scope={"names": ["op_name"]},
+                sym=False,
+                tokenizer="dbmdz/bert-base-german-cased",
+                ratio=1.0,
+                group_size=128,
+                all_layers=True,
+                sensitivity_metric="mean_activation_magnitude",
+                num_samples=100,
+                quant_method=OVQuantizationMethod.DEFAULT,
+            ),
+            OVWeightQuantizationConfig,
+            None,
+        ),
+        (dict(), OVWeightQuantizationConfig, "Can't determine type of OV quantization config"),
+        (
+            dict(ignored_scope={"names": ["op_name"]}),
+            OVWeightQuantizationConfig,
+            "Can't determine type of OV quantization config",
+        ),
+        (dict(num_samples=100), OVWeightQuantizationConfig, "Can't determine type of OV quantization config"),
+        (dict(abc="def"), OVWeightQuantizationConfig, "Can't determine type of OV quantization config"),
+        (
+            dict(bits=8, fast_bias_correction=True),
+            OVWeightQuantizationConfig,
+            "Can't determine type of OV quantization config",
+        ),
+        (dict(model_type=nncf.ModelType.TRANSFORMER), OVQuantizationConfig, None),
+        (
+            dict(
                 ignored_scope={"names": ["op_name"]},
                 num_samples=100,
                 preset=nncf.QuantizationPreset.MIXED,
                 model_type=nncf.ModelType.TRANSFORMER,
                 fast_bias_correction=True,
                 overflow_fix=OverflowFix.DISABLE,
             ),
-            ["ignored_scope"],
+            OVQuantizationConfig,
+            None,
         ),
-        (OVQuantizationConfig(dataset=["wikitext", "c4"]), []),
-        (OVQuantizationConfig(dataset=load_dataset("wikitext", "wikitext-2-raw-v1", split="test")), ["dataset"]),
-        (OVQuantizationConfig(dataset=nncf.Dataset([np.zeros((1, 10))])), ["dataset"]),
+        (dict(weight_only=True), OVWeightQuantizationConfig, None),
+        (dict(weight_only=False), OVQuantizationConfig, None),
+        (dict(abc="def", weight_only=False), OVQuantizationConfig, None),
+        (dict(abc="def", weight_only=True), OVWeightQuantizationConfig, None),
+        (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"),
         (
-            OVQuantizationConfig(dataset=["wikitext", "c4"], ignored_scope=nncf.IgnoredScope(names=["op_name"])),
-            ["ignored_scope"],
+            dict(model_type=nncf.ModelType.TRANSFORMER, weight_only=True),
+            OVQuantizationConfig,
+            "Please check your configuration",
         ),
     )
 
     @parameterized.expand(QUANTIZATION_CONFIGS)
-    def test_config_serialization(
-        self, quantization_config: OVQuantizationConfigBase, non_equal_property_names: List[str]
-    ):
+    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:
@@ -803,12 +832,8 @@ def str_to_enum(enum_cls, value):
             if quantization_config is None:
                 self.assertEqual(loaded_ov_config.quantization_config, None)
                 return
-            for key, value in loaded_ov_config.quantization_config.items():
-                initial_value = (
-                    quantization_config[key]
-                    if isinstance(quantization_config, dict)
-                    else getattr(ov_config.quantization_config, key)
-                )
+            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:
@@ -817,10 +842,24 @@ def str_to_enum(enum_cls, value):
                             value = str_to_enum(nncf.QuantizationPreset, value)
                         else:
                             value = str_to_enum(OverflowFix, value)
-                if key in non_equal_property_names:
-                    self.assertNotEqual(value, initial_value)
-                else:
-                    self.assertEqual(value, initial_value)
+                self.assertEqual(value, initial_value)
+
+    @parameterized.expand(QUANTIZATION_CONFIG_DICTS)
+    def test_config_from_dict(self, quantization_config: dict, config_type: type, warning_log: Union[str, None]):
+        from optimum.intel.openvino.configuration import logger as configuration_logger
+
+        if warning_log is not None:
+            with self.assertLogs(configuration_logger, logging.WARN) as cm:
+                ov_config = OVConfig(quantization_config=quantization_config)
+                self.assertTrue(any(warning_log in log for log in cm.output))
+        else:
+            ov_config = OVConfig(quantization_config=quantization_config)
+        self.assertIsInstance(ov_config.quantization_config, config_type)
+        for k, v in quantization_config.items():
+            if k == "weight_only" and warning_log == "Please check your configuration":
+                continue
+            if hasattr(ov_config.quantization_config, k):
+                self.assertEqual(getattr(ov_config.quantization_config, k), v)
 
 
 class InferRequestWrapperTest(unittest.TestCase):