linters

Author: nikita-savelyevv

optimum/intel/openvino/modeling_diffusion.py

@@ -11,7 +11,7 @@
 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
-import copy
+
 import importlib
 import logging
 import os
@@ -57,14 +57,13 @@
 )
 
 from ...exporters.openvino import main_export
-from .configuration import OVConfig, OVWeightQuantizationConfig, OVQuantizationMethod
+from .configuration import OVConfig, OVQuantizationMethod, OVWeightQuantizationConfig
 from .loaders import OVTextualInversionLoaderMixin
 from .modeling_base import OVBaseModel
 from .utils import (
     ONNX_WEIGHTS_NAME,
     OV_TO_NP_TYPE,
     OV_XML_FILE_NAME,
-    PREDEFINED_SD_DATASETS,
     _print_compiled_model_properties,
 )
 
@@ -300,7 +299,7 @@ def _from_pretrained(
             # load the UNet model uncompressed to apply hybrid quantization further
             unet = cls.load_model(unet_path)
             # Apply weights compression to other `components` without dataset
-            quantization_config_without_dataset = copy.deepcopy(quantization_config)
+            quantization_config_without_dataset = deepcopy(quantization_config)
             quantization_config_without_dataset.dataset = None
         else:
             quantization_config_without_dataset = quantization_config
@@ -333,7 +332,7 @@ def _from_pretrained(
             from optimum.intel import OVQuantizer
 
             quantizer = OVQuantizer(sd_model)
-            quantization_config_copy = copy.deepcopy(quantization_config)
+            quantization_config_copy = deepcopy(quantization_config)
             quantization_config_copy.quant_method = OVQuantizationMethod.HYBRID
             quantizer.quantize(ov_config=OVConfig(quantization_config=quantization_config_copy))
 

optimum/intel/openvino/quantization.py

@@ -50,7 +50,7 @@
 from ..utils.constant import _TASK_ALIASES
 from ..utils.import_utils import DATASETS_IMPORT_ERROR, is_datasets_available
 from ..utils.modeling_utils import get_model_device
-from .configuration import OVConfig, OVQuantizationConfig, OVWeightQuantizationConfig, OVQuantizationMethod
+from .configuration import OVConfig, OVQuantizationConfig, OVQuantizationMethod, OVWeightQuantizationConfig
 from .modeling_base import OVBaseModel
 from .utils import (
     MAX_ONNX_OPSET,
@@ -339,8 +339,8 @@ def _quantize_ovbasemodel(
 
             if isinstance(self.model, OVStableDiffusionPipelineBase):
                 calibration_dataset = self._prepare_unet_dataset(
-                    quantization_config.num_samples,
-                    dataset=calibration_dataset)
+                    quantization_config.num_samples, dataset=calibration_dataset
+                )
             elif Dataset is not None and isinstance(calibration_dataset, Dataset):
                 calibration_dataloader = self._get_calibration_dataloader(
                     calibration_dataset=calibration_dataset,
@@ -351,14 +351,17 @@ def _quantize_ovbasemodel(
 
                 if self.model.export_feature == "text-generation" and self.model.use_cache:
                     calibration_dataset = self._prepare_text_generation_dataset(
-                        quantization_config, calibration_dataloader)
+                        quantization_config, calibration_dataloader
+                    )
                 else:
                     calibration_dataset = nncf.Dataset(calibration_dataloader)
             elif isinstance(calibration_dataset, collections.abc.Iterable):
                 calibration_dataset = nncf.Dataset(calibration_dataset)
             elif not isinstance(calibration_dataset, nncf.Dataset):
-                raise ValueError("`calibration_dataset` must be either an `Iterable` object or an instance of "
-                                 f"`nncf.Dataset` or `datasets.Dataset`. Found: {type(calibration_dataset)}.")
+                raise ValueError(
+                    "`calibration_dataset` must be either an `Iterable` object or an instance of "
+                    f"`nncf.Dataset` or `datasets.Dataset`. Found: {type(calibration_dataset)}."
+                )
 
         if isinstance(quantization_config, OVWeightQuantizationConfig):
             if quantization_config.dataset is not None and calibration_dataset is not None:
@@ -374,8 +377,8 @@ def _quantize_ovbasemodel(
                     calibration_dataset = self._prepare_gptq_dataset(quantization_config)
                 elif isinstance(self.model, OVStableDiffusionPipelineBase):
                     calibration_dataset = self._prepare_unet_dataset(
-                        quantization_config.num_samples,
-                        dataset_name=quantization_config.dataset)
+                        quantization_config.num_samples, dataset_name=quantization_config.dataset
+                    )
                 else:
                     raise ValueError(
                         f"Can't create weight compression calibration dataset from string for {type(self.model)}"
@@ -385,7 +388,9 @@ def _quantize_ovbasemodel(
                 if calibration_dataset is None:
                     raise ValueError("Calibration dataset is required to run hybrid quantization.")
                 if isinstance(self.model, OVStableDiffusionPipelineBase):
-                    self.model.unet.model = _hybrid_quantization(self.model.unet.model, quantization_config, calibration_dataset)
+                    self.model.unet.model = _hybrid_quantization(
+                        self.model.unet.model, quantization_config, calibration_dataset
+                    )
                 else:
                     self.model.model = _hybrid_quantization(self.model.model, quantization_config, calibration_dataset)
             else:
@@ -672,18 +677,15 @@ def _prepare_gptq_dataset(self, quantization_config: OVWeightQuantizationConfig)
 
         tokenizer = AutoTokenizer.from_pretrained(quantization_config.tokenizer)
         nsamples = quantization_config.num_samples if quantization_config.num_samples else 128
-        calibration_dataset = get_dataset(
-            quantization_config.dataset, tokenizer, seqlen=32, nsamples=nsamples
-        )
+        calibration_dataset = get_dataset(quantization_config.dataset, tokenizer, seqlen=32, nsamples=nsamples)
         calibration_dataset = prepare_dataset(calibration_dataset)
         calibration_dataset = nncf.Dataset(calibration_dataset, lambda x: self.model.prepare_inputs(**x))
 
         return calibration_dataset
 
     def _prepare_text_generation_dataset(
-            self,
-            quantization_config: OVQuantizationConfig,
-            calibration_dataloader: OVDataLoader) -> nncf.Dataset:
+        self, quantization_config: OVQuantizationConfig, calibration_dataloader: OVDataLoader
+    ) -> nncf.Dataset:
         # TODO: this function is not covered by tests, remove if not relevant anymore or cover by tests otherwise
 
         # Prefetch past_key_values
@@ -705,10 +707,11 @@ def _prepare_text_generation_dataset(
         return calibration_dataset
 
     def _prepare_unet_dataset(
-            self,
-            num_samples: Optional[int] = None,
-            dataset_name: Optional[str] = None,
-            dataset: Optional[Union[Iterable, "Dataset"]] = None) -> nncf.Dataset:
+        self,
+        num_samples: Optional[int] = None,
+        dataset_name: Optional[str] = None,
+        dataset: Optional[Union[Iterable, "Dataset"]] = None,
+    ) -> nncf.Dataset:
         self.model.compile()
 
         size = self.model.unet.config.get("sample_size", 64) * self.model.vae_scale_factor
@@ -735,16 +738,20 @@ def transform_fn(data_item):
             from datasets import load_dataset
 
             dataset_metadata = PREDEFINED_SD_DATASETS[dataset_name]
-            dataset = load_dataset(dataset_name, split=dataset_metadata["split"], streaming=True).shuffle(seed=self.seed)
+            dataset = load_dataset(dataset_name, split=dataset_metadata["split"], streaming=True).shuffle(
+                seed=self.seed
+            )
             input_names = dataset_metadata["inputs"]
             dataset = dataset.select_columns(list(input_names.values()))
 
             def transform_fn(data_item):
                 return {inp_name: data_item[column] for inp_name, column in input_names.items()}
 
         else:
-            raise ValueError("For UNet inputs collection either quantization_config.dataset or custom "
-                             "calibration_dataset must be provided.")
+            raise ValueError(
+                "For UNet inputs collection either quantization_config.dataset or custom "
+                "calibration_dataset must be provided."
+            )
 
         calibration_data = []
         try:

tests/openvino/test_quantization.py

@@ -21,21 +21,17 @@
 from collections import defaultdict
 from enum import Enum
 from functools import partial
-from typing import List, Union
+from typing import Union
 
 import evaluate
 import numpy as np
 import torch
 from datasets import load_dataset
-from nncf.quantization.advanced_parameters import OverflowFix
 from parameterized import parameterized
-import openvino.runtime as ov
 import nncf
 from transformers import (
     AutoModelForQuestionAnswering,
     AutoModelForSequenceClassification,
-    AutoModelForCausalLM,
-    AutoModelForTokenClassification,
     AutoTokenizer,
     AutoProcessor,
     TrainingArguments,
@@ -415,7 +411,9 @@ def test_ovmodel_hybrid_quantization_with_custom_dataset(
             export=True,
         )
         quantizer = OVQuantizer(model)
-        quantization_config = OVWeightQuantizationConfig(bits=8, num_samples=3, quant_method=OVQuantizationMethod.HYBRID)
+        quantization_config = OVWeightQuantizationConfig(
+            bits=8, num_samples=3, quant_method=OVQuantizationMethod.HYBRID
+        )
         quantizer.quantize(ov_config=OVConfig(quantization_config=quantization_config), calibration_dataset=dataset)
         num_fake_quantize, num_int8, num_int4 = get_num_quantized_nodes(model.unet)
         self.assertEqual(expected_num_fake_quantize, num_fake_quantize)