Fix torch and ITREX dependencies (#640)

Author: echarlaix

optimum/intel/neural_compressor/modeling_base.py

@@ -47,7 +47,6 @@
     _torch_version,
     is_intel_extension_for_transformers_available,
     is_torch_version,
-    requires_backends,
 )
 from .configuration import INCConfig
 from .utils import WEIGHTS_NAME
@@ -141,25 +140,29 @@ def _from_pretrained(
         model_save_dir = Path(model_cache_path).parent
         inc_config = None
         msg = None
-        try:
-            requires_backends(cls, ["intel_extension_for_transformers"])
-            quantization_config = WeightOnlyQuantConfig.from_pretrained(model_id)
-            if getattr(
-                quantization_config, "algorithm", None
-            ) is not None and quantization_config.algorithm.lower() in ["rtn", "gptq", "awq", "autoaround"]:
-                return ITREX_WOQ_MODEL.from_pretrained(
-                    pretrained_model_name_or_path=model_id,
-                    use_auth_token=use_auth_token,
-                    revision=revision,
-                    force_download=force_download,
-                    cache_dir=cache_dir,
-                    local_files_only=local_files_only,
-                    subfolder=subfolder,
-                    trust_remote_code=trust_remote_code,
-                    **kwargs,
-                )
-        except EnvironmentError:
-            msg = "The model is not quantized with weight-only quantization."
+        if is_intel_extension_for_transformers_available():
+            try:
+                quantization_config = WeightOnlyQuantConfig.from_pretrained(model_id)
+                algorithm = getattr(quantization_config, "algorithm", None)
+                if algorithm is not None and quantization_config.algorithm.lower() in {
+                    "rtn",
+                    "gptq",
+                    "awq",
+                    "autoaround",
+                }:
+                    return ITREX_WOQ_MODEL.from_pretrained(
+                        pretrained_model_name_or_path=model_id,
+                        use_auth_token=use_auth_token,
+                        revision=revision,
+                        force_download=force_download,
+                        cache_dir=cache_dir,
+                        local_files_only=local_files_only,
+                        subfolder=subfolder,
+                        trust_remote_code=trust_remote_code,
+                        **kwargs,
+                    )
+            except EnvironmentError:
+                msg = "The model is not quantized with weight-only quantization."
         try:
             inc_config = INCConfig.from_pretrained(model_id)
             if not is_torch_version("==", inc_config.torch_version):

optimum/intel/neural_compressor/quantization.py

@@ -47,6 +47,7 @@
 
 from ..utils.constant import _TASK_ALIASES, MIN_QDQ_ONNX_OPSET, ONNX_WEIGHTS_NAME, WEIGHTS_NAME
 from ..utils.import_utils import (
+    INTEL_EXTENSION_FOR_TRANSFORMERS_IMPORT_ERROR,
     _intel_extension_for_transformers_version,
     _ipex_version,
     _neural_compressor_version,
@@ -78,26 +79,17 @@
             f"Found an incompatible version of `intel-extension-for-transformers`. Found version {_intel_extension_for_transformers_version}, "
             f"but only version {INTEL_EXTENSION_FOR_TRANSFORMERS_MINIMUM_VERSION} is supported."
         )
-    TORCH_VERSION = "2.1.0"
-    if is_torch_version("!=", TORCH_VERSION):
-        raise ImportError(
-            f"Found an incompatible version of `torch`. Found version {_torch_version}, "
-            f"but only version {TORCH_VERSION} is supported."
-        )
-
     from intel_extension_for_transformers.llm.quantization.utils import convert_to_quantized_model
     from intel_extension_for_transformers.transformers.modeling.modeling_auto import save_low_bit
     from intel_extension_for_transformers.transformers.utils.config import WeightOnlyQuantConfig
 
-    Config = Union[PostTrainingQuantConfig, WeightOnlyQuantConfig]
-else:
-    Config = PostTrainingQuantConfig
 
 logger = logging.getLogger(__name__)
 
 NEURAL_COMPRESSOR_MINIMUM_VERSION = "2.1.0"
 NEURAL_COMPRESSOR_WEIGHT_ONLY_MINIMUM_VERSION = "2.3.0"
 IPEX_MINIMUM_VERSION = "2.1.0"
+_ITREX_TORCH_VERSION = "2.1.0"
 
 if is_neural_compressor_version("<", NEURAL_COMPRESSOR_MINIMUM_VERSION):
     raise ImportError(
@@ -160,7 +152,7 @@ def from_pretrained(cls, model: PreTrainedModel, **kwargs):
 
     def quantize(
         self,
-        quantization_config: Config,
+        quantization_config: Union["PostTrainingQuantConfig", "WeightOnlyQuantConfig"],
         save_directory: Union[str, Path],
         calibration_dataset: Dataset = None,
         batch_size: int = 8,
@@ -213,9 +205,12 @@ def quantize(
                     f"but only version {NEURAL_COMPRESSOR_WEIGHT_ONLY_MINIMUM_VERSION} or higher supports weight-only quantization."
                 )
             if not is_intel_extension_for_transformers_available():
+                raise ImportError(INTEL_EXTENSION_FOR_TRANSFORMERS_IMPORT_ERROR.format("Weight only quantization"))
+
+            if is_torch_version("!=", _ITREX_TORCH_VERSION):
                 raise ImportError(
-                    "Didn't find out intel-etension-for-transformers package. "
-                    "Please install packages: pip install intel-etension-for-transformers and pip install peft."
+                    f"Found an incompatible version of `torch`. Found version {_torch_version}, "
+                    f"but only version {_ITREX_TORCH_VERSION} is supported."
                 )
 
             if quantization_config is None:

tests/neural_compressor/test_optimization.py

@@ -88,10 +88,10 @@ class OptimizationTest(INCTestMixin):
     )
 
     WEIGHT_ONLY_CONFIG = (
-        (False, "RTN", "int4_clip"),
-        (False, "GPTQ", "int4_clip"),
-        (False, "RTN", "int8"),
-        (True, "", ""),
+        ("RTN", "int4_clip"),
+        ("GPTQ", "int4_clip"),
+        ("RTN", "int8"),
+        ("", ""),
     )
 
     @parameterized.expand(SUPPORTED_ARCHITECTURES_DYNAMIC)
@@ -212,7 +212,7 @@ def test_ipex_static_quantization_with_smoothquant(self, task, model_name, expec
     @unittest.skipIf(
         not is_intel_extension_for_transformers_available(), reason="Intel-extension-for-transformers not available!"
     )
-    def test_weight_only_quantization(self, no_config, algo, weight_dtype):
+    def test_weight_only_quantization(self, methodology, weight_dtype):
         model_name = "hf-internal-testing/tiny-random-GPTNeoForCausalLM"
         model = AutoModelForCausalLM.from_pretrained(model_name)
         tokenizer = AutoTokenizer.from_pretrained(model_name)
@@ -221,29 +221,30 @@ def test_weight_only_quantization(self, no_config, algo, weight_dtype):
         calibration_dataset = _generate_dataset(quantizer, tokenizer, num_samples=2)
 
         with tempfile.TemporaryDirectory() as tmp_dir:
-            if not no_config:
-                if algo == "GPTQ":
-                    algorithm_args = {
-                        "percdamp": 0.01,
-                        "act_order": False,
-                        "scheme": "sym",
-                    }
+            if methodology:
+                gptq_args = {
+                    "percdamp": 0.01,
+                    "act_order": False,
+                    "scheme": "sym",
+                }
+
                 quantization_config = WeightOnlyQuantConfig(
-                    algorithm=algo,
-                    algorithm_args=algorithm_args if algo == "GPTQ" else None,
+                    algorithm=methodology,
+                    algorithm_args=gptq_args if methodology == "GPTQ" else None,
                     weight_dtype=weight_dtype,
                 )
-                q_model = quantizer.quantize(
+                quantizer.quantize(
                     quantization_config=quantization_config,
-                    calibration_dataset=calibration_dataset if algo == "GPTQ" else None,
+                    calibration_dataset=calibration_dataset,
                     save_directory=tmp_dir,
                 )
             else:
-                q_model = quantizer.quantize(
+                quantizer.quantize(
                     quantization_config=None,
                     save_directory=tmp_dir,
                     weight_only=True,  # use RTN quantization method and NF4 weight data type is default.
                 )
+
             q_model = INCModelForCausalLM.from_pretrained(tmp_dir)
             inp = torch.tensor([calibration_dataset[0]["input_ids"]])
             out = model(inp)[0]