Fix Cuda CI failures due to Transformers and AWQ incompatibility (#882)

* Resolving CI issues caused by incompatibility between Transformers and awq

Signed-off-by: Zhang, Weiwei1 <weiwei1.zhang@intel.com>

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* fix import typo

Signed-off-by: Zhang, Weiwei1 <weiwei1.zhang@intel.com>

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

---------

Signed-off-by: Zhang, Weiwei1 <weiwei1.zhang@intel.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: WeiweiZhang1

auto_round/inference/backend.py

@@ -396,7 +396,7 @@ def fp8_static_scheme_checker(
     data_type=["int"],
     act_bits=WOQ_DEFAULT_ACT_BITS,
     alias=["auto_awq:gemm", "awq", "awq:gemm", "auto_awq"],
-    requirements=["autoawq"],
+    requirements=["autoawq", "transformers<4.57.0"],
 )
 
 BackendInfos["qbits"] = BackendInfo(

auto_round/testing_utils.py

@@ -14,10 +14,14 @@
 
 import importlib.util
 import unittest
+from functools import wraps
+from typing import Callable, Literal
 
 import torch
 from transformers.utils.versions import require_version
 
+from auto_round.logger import logger
+
 
 def is_gguf_available():
     return importlib.util.find_spec("gguf") is not None
@@ -211,3 +215,56 @@ def require_vlm_env(test_case):
     env_check &= importlib.util.find_spec("xformers") is not None
 
     return unittest.skipUnless(env_check, "Environment is not satisfactory")(test_case)
+
+
+def require_package_version(
+    package: str, version_spec: str, on_fail: Literal["skip", "warn", "error"] = "skip"
+) -> bool:
+    """
+    Check if a package satisfies a version requirement.
+
+    Args:
+        package (str): Name of the Python package (e.g., "transformers").
+        version_spec (str): Version specifier string (e.g., ">=0.5.0", "<4.57.0").
+        on_fail (str, optional): Behavior when requirement is not met:
+            - "skip": return False (used for skipping tests)
+            - "warn": issue a warning but return True
+            - "error": raise ImportError
+        Defaults to "skip".
+
+    Returns:
+        bool: True if requirement satisfied or on_fail=="warn", False if skipped
+    """
+    try:
+        require_version(f"{package}{version_spec}")
+        return True
+    except ImportError as e:
+        msg = f"Requirement not satisfied: {package}{version_spec}"
+        if on_fail == "skip":
+            return False
+        elif on_fail == "warn":
+            logger.warning_once(msg)
+            return True
+        else:  # on_fail == "error"
+            raise ImportError(msg) from e
+
+
+def require_package_version_ut(package: str, version_spec: str) -> Callable:
+    """
+    Decorator for unittest.TestCase methods to enforce a package version requirement.
+
+    The decorated test will be skipped if the package version does not satisfy the requirement.
+
+    Args:
+        package (str): Name of the package (e.g., "transformers", "auto-round").
+        version_spec (str): Version specifier string (e.g., ">=0.5.0", "<4.57.0").
+
+    Returns:
+        Callable: A decorator to wrap unittest test methods.
+    """
+
+    def decorator(test_func: Callable) -> Callable:
+        reason = f"Test requires {package}{version_spec}"
+        return unittest.skipUnless(require_package_version(package, version_spec, on_fail="skip"), reason)(test_func)
+
+    return decorator

test/test_cuda/test_auto_round_format.py

@@ -10,7 +10,13 @@
 
 from auto_round import AutoRound, AutoRoundConfig
 from auto_round.eval.evaluation import simple_evaluate_user_model
-from auto_round.testing_utils import require_autogptq, require_awq, require_greater_than_050, require_ipex
+from auto_round.testing_utils import (
+    require_autogptq,
+    require_awq,
+    require_greater_than_050,
+    require_ipex,
+    require_package_version_ut,
+)
 
 
 class LLMDataLoader:
@@ -73,6 +79,7 @@ def tearDownClass(self):
         shutil.rmtree("runs", ignore_errors=True)
 
     @require_greater_than_050
+    @require_package_version_ut("transformers", "<4.57.0")
     def test_autoround_asym(self):
         for bits in [2, 3, 4, 8]:
             model = AutoModelForCausalLM.from_pretrained(self.model_name, torch_dtype="auto", trust_remote_code=True)
@@ -131,6 +138,7 @@ def test_mixed_precision(self):
         self.assertGreater(result["results"]["lambada_openai"]["acc,none"], 0.32)
 
     @require_awq
+    @require_package_version_ut("transformers", "<4.57.0")
     def test_awq_backend(self):
         model = AutoModelForCausalLM.from_pretrained(self.model_name, torch_dtype="auto", trust_remote_code=True)
         tokenizer = AutoTokenizer.from_pretrained(self.model_name, trust_remote_code=True)
@@ -235,6 +243,7 @@ def test_autoround_gptq_sym_format(self):
 
     @require_awq
     @require_ipex
+    @require_package_version_ut("transformers", "<4.57.0")
     def test_autoround_awq_sym_format(self):
         model = AutoModelForCausalLM.from_pretrained(self.model_name, torch_dtype="auto", trust_remote_code=True)
         tokenizer = AutoTokenizer.from_pretrained(self.model_name, trust_remote_code=True)

test/test_cuda/test_export.py

@@ -9,7 +9,7 @@
 from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer
 
 from auto_round import AutoRound
-from auto_round.testing_utils import require_awq, require_optimum
+from auto_round.testing_utils import require_awq, require_optimum, require_package_version_ut
 
 
 class LLMDataLoader:
@@ -185,6 +185,7 @@ def test_autoround_format(self):
         shutil.rmtree("./saved", ignore_errors=True)
 
     @require_awq
+    @require_package_version_ut("transformers", "<4.57.0")
     def test_autoawq_format(self):
         model = AutoModelForCausalLM.from_pretrained(self.model_name, torch_dtype="auto", trust_remote_code=True)
         tokenizer = AutoTokenizer.from_pretrained(self.model_name, trust_remote_code=True)
@@ -218,6 +219,7 @@ def test_autoawq_format(self):
 
     @require_optimum
     @require_awq
+    @require_package_version_ut("transformers", "<4.57.0")
     def test_autoawq_format_fp_qsave_layers(self):
         model = AutoModelForCausalLM.from_pretrained(self.model_name, torch_dtype="auto", trust_remote_code=True)
         layer_config = {

test/test_cuda/test_main_func.py

@@ -9,10 +9,11 @@
 import transformers
 from lm_eval.utils import make_table  # pylint: disable=E0401
 from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers.utils.versions import require_version
 
 from auto_round import AutoRound, AutoRoundAdam
 from auto_round.eval.evaluation import simple_evaluate
-from auto_round.testing_utils import require_awq, require_gptqmodel, require_optimum
+from auto_round.testing_utils import require_awq, require_gptqmodel, require_optimum, require_package_version_ut
 
 
 def get_accuracy(data):
@@ -38,7 +39,6 @@ def tearDownClass(self):
 
     @require_gptqmodel
     @require_optimum
-    @require_awq
     def test_backend(self):
         model_name = "/models/opt-125m"
         model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, device_map="auto")
@@ -64,6 +64,16 @@ def test_backend(self):
         assert accuracy > 0.35
         shutil.rmtree("./saved", ignore_errors=True)
 
+    @require_optimum
+    @require_awq
+    @require_package_version_ut("transformers", "<4.57.0")
+    def test_backend_awq(self):
+        model_name = "/models/opt-125m"
+        model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, device_map="auto")
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        autoround = AutoRound(model, tokenizer, bits=4, group_size=128)
+        autoround.quantize()
+
         ##test auto_awq format
         autoround.save_quantized(self.save_dir, format="auto_awq", inplace=False)
         model_args = f"pretrained={self.save_dir}"
@@ -75,7 +85,6 @@ def test_backend(self):
 
     @unittest.skipIf(torch.cuda.is_available() is False, "Skipping because no cuda")
     @require_gptqmodel
-    @require_awq
     def test_fp_layers(self):
         model_name = "/models/opt-125m"
         model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, device_map="auto")
@@ -98,6 +107,22 @@ def test_fp_layers(self):
         assert accuracy > 0.35
         shutil.rmtree("./saved", ignore_errors=True)
 
+    @unittest.skipIf(torch.cuda.is_available() is False, "Skipping because no cuda")
+    @require_awq
+    @require_package_version_ut("transformers", "<4.57.0")
+    def test_fp_layers_awq(self):
+        model_name = "/models/opt-125m"
+        model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, device_map="auto")
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        from auto_round.utils import get_fp_layer_names
+
+        layer_names = get_fp_layer_names(model, "model.decoder.layers.0,model.decoder.layers.1")
+        layer_configs = {}
+        for name in layer_names:
+            layer_configs[name] = {"bits": 16}
+        autoround = AutoRound(model, tokenizer, bits=4, group_size=128)
+        autoround.quantize()
+
         ##test auto_awq format
         autoround.save_quantized(self.save_dir, format="auto_awq", inplace=False)
         model_args = f"pretrained={self.save_dir}"

test/test_cuda/test_support_vlms.py

@@ -9,7 +9,7 @@
 from PIL import Image
 
 from auto_round import AutoRoundConfig  # # must import for auto-round format
-from auto_round.testing_utils import require_gptqmodel, require_vlm_env
+from auto_round.testing_utils import require_gptqmodel, require_package_version_ut, require_vlm_env
 
 
 class TestSupportVLMS(unittest.TestCase):
@@ -128,6 +128,7 @@ def test_phi3(self):
         shutil.rmtree(quantized_model_path, ignore_errors=True)
 
     @require_vlm_env
+    @require_package_version_ut("transformers", "<4.57.0")
     def test_phi3_vision_awq(self):
         model_path = "/models/Phi-3.5-vision-instruct/"
         ## test tune