Addressed minor comments

nikita-savelyevv · nikita-savelyevv · commit 20fd76191787 · 2024-04-11T11:39:52.000+02:00
diff --git a/optimum/intel/openvino/configuration.py b/optimum/intel/openvino/configuration.py
@@ -52,7 +52,7 @@
 }
 
 
-class replace_properties_values:
+class _replace_properties_values:
     """
     A context manager for temporarily overriding an object's properties
     """
@@ -74,7 +74,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
             setattr(self.obj, property_name, old_property_value)
 
 
-def is_serializable(obj):
+def _is_serializable(obj):
     try:
         json.dumps(obj)
         return True
@@ -92,22 +92,22 @@ def __init__(
         self,
         dataset: Optional[Union[str, List[str], nncf.Dataset, datasets.Dataset]] = None,
         ignored_scope: Optional[Union[dict, nncf.IgnoredScope]] = None,
-        subset_size: Optional[int] = None,
+        num_samples: Optional[int] = None,
     ):
         """
         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.
-            subset_size (`int`, *optional*):
+            num_samples (`int`, *optional*):
                 The maximum number of samples composing the calibration dataset.
         """
         self.dataset = dataset
         if isinstance(ignored_scope, dict):
             ignored_scope = nncf.IgnoredScope(**ignored_scope)
         self.ignored_scope = ignored_scope
-        self.subset_size = subset_size
+        self.num_samples = num_samples
 
     def post_init(self):
         if not (self.dataset is None or isinstance(self.dataset, (str, list, nncf.Dataset, datasets.Dataset))):
@@ -121,22 +121,22 @@ def post_init(self):
                 f"{type(self.dataset)}"
             )
 
-    def to_dict_without_properties(self, property_names: Union[List[str], Tuple[str]]) -> Dict[str, Any]:
+    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)):
+        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"]
+        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)
+            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)
 
 
 class OVConfig(BaseConfig):
@@ -180,21 +180,21 @@ def add_input_info(self, model_inputs: Dict, force_batch_one: bool = False):
             for name, value in model_inputs.items()
         ]
 
-    def to_dict_safe(self, to_diff_dict: bool = False) -> Dict[str, Any]:
+    def _to_dict_safe(self, to_diff_dict: bool = False) -> Dict[str, Any]:
         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(),)):
+            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"]
         else:
             result = super().to_diff_dict() if to_diff_dict else super().to_dict()
         return result
 
     def to_dict(self) -> Dict[str, Any]:
-        return self.to_dict_safe(to_diff_dict=False)
+        return self._to_dict_safe(to_diff_dict=False)
 
     def to_diff_dict(self) -> Dict[str, Any]:
-        return self.to_dict_safe(to_diff_dict=True)
+        return self._to_dict_safe(to_diff_dict=True)
 
 
 class OVQuantizationMethod(str, Enum):
@@ -236,7 +236,7 @@ class OVWeightQuantizationConfig(OVQuantizationConfigBase):
             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.
-        subset_size (`int`, *optional*):
+        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.
@@ -253,19 +253,18 @@ def __init__(
         all_layers: Optional[bool] = None,
         sensitivity_metric: Optional[str] = None,
         ignored_scope: Optional[Union[dict, nncf.IgnoredScope]] = None,
-        subset_size: Optional[int] = None,
+        num_samples: Optional[int] = None,
         quant_method: Optional[Union[QuantizationMethod, OVQuantizationMethod]] = OVQuantizationMethod.DEFAULT,
         **kwargs,
     ):
-        super().__init__(dataset, ignored_scope, subset_size)
+        super().__init__(dataset, ignored_scope, num_samples)
         self.bits = bits
         self.sym = sym
         self.tokenizer = tokenizer
         self.group_size = group_size or (-1 if bits == 8 else 128)
         self.ratio = ratio
         self.all_layers = all_layers
         self.sensitivity_metric = sensitivity_metric
-        self.subset_size = subset_size
         self.quant_method = quant_method
         self.post_init()
 
@@ -305,8 +304,8 @@ def post_init(self):
                 )
 
     def to_dict(self) -> Dict[str, Any]:
-        if not is_serializable(self.tokenizer):
-            return self.to_dict_without_properties(("tokenizer",))
+        if not _is_serializable(self.tokenizer):
+            return self._to_dict_without_properties(("tokenizer",))
         return super().to_dict()
 
 
@@ -316,7 +315,7 @@ def __init__(
         self,
         dataset: Union[str, List[str], nncf.Dataset, datasets.Dataset],
         ignored_scope: Optional[Union[dict, nncf.IgnoredScope]] = None,
-        subset_size: Optional[int] = 300,
+        num_samples: Optional[int] = 300,
         preset: nncf.QuantizationPreset = None,
         model_type: nncf.ModelType = nncf.ModelType.TRANSFORMER,
         fast_bias_correction: bool = True,
@@ -332,7 +331,7 @@ def __init__(
                  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.
-            subset_size (`int`, *optional*):
+            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).
@@ -345,10 +344,10 @@ def __init__(
                 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 (`bool`, default to OverflowFix.DISABLE):
+            overflow_fix (`nncf.OverflowFix`, default to OverflowFix.DISABLE):
                 Parameter for controlling overflow fix setting.
         """
-        super().__init__(dataset, ignored_scope, subset_size)
+        super().__init__(dataset, ignored_scope, num_samples)
         self.preset = preset
         self.model_type = model_type
         self.fast_bias_correction = fast_bias_correction
@@ -370,7 +369,7 @@ 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)):
+        with _replace_properties_values(self, ("overflow_fix", "preset"), (overflow_fix_value, preset_value)):
             return super().to_dict()
 
 
diff --git a/optimum/intel/openvino/modeling_decoder.py b/optimum/intel/openvino/modeling_decoder.py
@@ -640,7 +640,7 @@ def _from_pretrained(
                 # from optimum.gptq.utils import get_seqlen
 
                 # seqlen = get_seqlen(causal_model)
-                nsamples = quantization_config.subset_size if quantization_config.subset_size else 128
+                nsamples = quantization_config.num_samples if quantization_config.num_samples else 128
                 dataset = get_dataset(quantization_config.dataset, tokenizer, seqlen=32, nsamples=nsamples)
                 dataset = prepare_dataset(dataset)
                 quantization_config = copy.deepcopy(quantization_config)
diff --git a/optimum/intel/openvino/modeling_diffusion.py b/optimum/intel/openvino/modeling_diffusion.py
@@ -321,7 +321,7 @@ def _from_pretrained(
             if not isinstance(sd_model, supported_pipelines):
                 raise NotImplementedError(f"Quantization in hybrid mode is not supported for {cls.__name__}")
 
-            nsamples = quantization_config.subset_size if quantization_config.subset_size else 200
+            nsamples = quantization_config.num_samples if quantization_config.num_samples else 200
             unet_inputs = sd_model._prepare_unet_inputs(quantization_config.dataset, nsamples)
 
             from .quantization import _hybrid_quantization
diff --git a/optimum/intel/openvino/quantization.py b/optimum/intel/openvino/quantization.py
@@ -209,6 +209,7 @@ def quantize(
         batch_size: int = 1,
         data_collator: Optional[DataCollator] = None,
         remove_unused_columns: bool = True,
+        weights_only: bool = None,
         **kwargs,
     ):
         """
@@ -228,6 +229,10 @@ def quantize(
                 The function to use to form a batch from a list of elements of the calibration dataset.
             remove_unused_columns (`bool`, defaults to `True`):
                 Whether to remove the columns unused by the model forward method.
+            weights_only (`bool`, *optional*):
+                Being deprecated.
+                Compress weights to integer precision (8-bit by default) while keeping activations
+                floating-point. Fits best for LLM footprint reduction and performance acceleration.
 
         Examples:
         ```python
@@ -257,9 +262,9 @@ def quantize(
                 "`calibration_dataset` argument is deprecated. Please provide calibration dataset "
                 "with `ov_config.quantization_config.dataset`."
             )
-        if "weights_only" in kwargs:
-            raise ValueError(
-                "`weights_only` argument is deprecated. Please provide `ov_config.quantization_config` "
+        if weights_only is not None:
+            logger.warning(
+                "`weights_only` argument is deprecated. In the future please provide `ov_config.quantization_config` "
                 "as an instance of OVWeightQuantizationConfig for weight-only compression."
             )
 
@@ -274,8 +279,14 @@ def quantize(
                 raise TypeError(f"`ov_config` should be an `OVConfig`, but got: {type(ov_config)} instead.")
         quantization_config = ov_config.quantization_config
         if quantization_config is None:
-            ov_config.quantization_config = OVWeightQuantizationConfig(bits=8, sym=True)
-            logger.info("`quantization_config` was not provided, 8-bit symmetric weight quantization will be applied.")
+            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."
+                    )
+                ov_config.quantization_config = OVWeightQuantizationConfig(bits=8, sym=True)
+            else:
+                ov_config.quantization_config = OVQuantizationConfig()
 
         if isinstance(self.model, OVBaseModel):
             self._quantize_ovbasemodel(
@@ -335,7 +346,7 @@ def _quantize_ovbasemodel(
                 try:
                     for data in calibration_dataloader:
                         self.model.generate(**data, max_new_tokens=1)
-                        if len(collected_inputs) >= quantization_config.subset_size:
+                        if len(collected_inputs) >= quantization_config.num_samples:
                             break
                 finally:
                     self.model.request = self.model.request.request
@@ -347,7 +358,7 @@ def _quantize_ovbasemodel(
         quantized_model = nncf.quantize(
             self.model.model,
             quantization_dataset,
-            subset_size=quantization_config.subset_size,
+            subset_size=quantization_config.num_samples,
             ignored_scope=quantization_config.ignored_scope,
             model_type=quantization_config.model_type,
             preset=quantization_config.preset,
@@ -446,7 +457,7 @@ def _quantize_torchmodel(
             model = nncf.quantize(
                 model,
                 quantization_dataset,
-                subset_size=quantization_config.subset_size,
+                subset_size=quantization_config.num_samples,
                 ignored_scope=quantization_config.ignored_scope,
                 model_type=quantization_config.model_type,
                 preset=quantization_config.preset,
@@ -603,7 +614,7 @@ def _weight_only_quantization(
 
         from optimum.gptq.data import get_dataset, prepare_dataset
 
-        nsamples = config.subset_size if config.subset_size else 128
+        nsamples = config.num_samples if config.num_samples else 128
         dataset = get_dataset(config.dataset, tokenizer, seqlen=32, nsamples=nsamples)
         dataset = prepare_dataset(dataset)
 
@@ -626,7 +637,7 @@ def _weight_only_quantization(
         # awq=config.quant_method == QuantizationMethod.AWQ,    # TODO : enable from nncf v2.9.0
         ignored_scope=config.ignored_scope,
         dataset=dataset,
-        # subset_size=config.subset_size if config.subset_size else 128,    # TODO : enable from nncf v2.9.0
+        # subset_size=config.num_samples if config.num_samples else 128,    # TODO : enable from nncf v2.9.0
     )
 
 
@@ -705,7 +716,7 @@ def _hybrid_quantization(
     wc_quantization_config.ignored_scope.types.append("Convolution")
     compressed_model = _weight_only_quantization(model, wc_quantization_config)
 
-    subset_size = quantization_config.subset_size if quantization_config.subset_size else 200
+    subset_size = quantization_config.num_samples if quantization_config.num_samples else 200
     quantized_model = nncf.quantize(
         model=compressed_model,
         calibration_dataset=nncf.Dataset(dataset),
diff --git a/tests/openvino/test_quantization.py b/tests/openvino/test_quantization.py
@@ -392,7 +392,7 @@ def test_ovmodel_load_with_compressed_weights(self, model_cls, model_type):
     @parameterized.expand(SUPPORTED_ARCHITECTURES_WITH_HYBRID_QUANTIZATION)
     def test_ovmodel_hybrid_quantization(self, model_cls, model_type, expected_num_fake_quantize, expected_ov_int8):
         model_id = MODEL_NAMES[model_type]
-        quantization_config = OVWeightQuantizationConfig(bits=8, dataset="conceptual_captions", subset_size=2)
+        quantization_config = OVWeightQuantizationConfig(bits=8, dataset="conceptual_captions", num_samples=2)
         with tempfile.TemporaryDirectory() as tmp_dir:
             model = model_cls.from_pretrained(model_id, export=True, quantization_config=quantization_config)
 
@@ -414,7 +414,7 @@ def test_ovmodel_hybrid_quantization_with_custom_dataset(
         model = model_cls.from_pretrained(
             model_id,
             export=True,
-            quantization_config=OVWeightQuantizationConfig(bits=8, dataset=dataset, subset_size=3),
+            quantization_config=OVWeightQuantizationConfig(bits=8, dataset=dataset, num_samples=3),
         )
         num_fake_quantize, num_int8, num_int4 = get_num_quantized_nodes(model.unet)
         self.assertEqual(expected_num_fake_quantize, num_fake_quantize)
@@ -749,7 +749,7 @@ class OVQuantizationConfigTest(unittest.TestCase):
                 group_size=128,
                 all_layers=True,
                 sensitivity_metric="mean_activation_magnitude",
-                subset_size=100,
+                num_samples=100,
                 quant_method=OVQuantizationMethod.DEFAULT,
             ),
             ["ignored_scope"],
@@ -768,7 +768,7 @@ class OVQuantizationConfigTest(unittest.TestCase):
             OVQuantizationConfig(
                 dataset="wikitext",
                 ignored_scope={"names": ["op_name"]},
-                subset_size=100,
+                num_samples=100,
                 preset=nncf.QuantizationPreset.MIXED,
                 model_type=nncf.ModelType.TRANSFORMER,
                 fast_bias_correction=True,
