transformers 5.0.0__py3-none-any.whl → 5.0.0rc0__py3-none-any.whl

transformers/utils/import_utils.py

@@ -55,15 +55,9 @@ def _is_package_available(pkg_name: str, return_version: bool = False) -> tuple[
             # importlib.metadata works with the distribution package, which may be different from the import
             # name (e.g. `PIL` is the import name, but `pillow` is the distribution name)
             distributions = PACKAGE_DISTRIBUTION_MAPPING[pkg_name]
-            # Per PEP 503, underscores and hyphens are equivalent in package names.
-            # Prefer the distribution that matches the (normalized) package name.
-            normalized_pkg_name = pkg_name.replace("_", "-")
-            if normalized_pkg_name in distributions:
-                distribution_name = normalized_pkg_name
-            elif pkg_name in distributions:
-                distribution_name = pkg_name
-            else:
-                distribution_name = distributions[0]
+            # In most cases, the packages are well-behaved and both have the same name. If it's not the case, we
+            # pick the first item of the list as best guess (it's almost always a list of length 1 anyway)
+            distribution_name = pkg_name if pkg_name in distributions else distributions[0]
             package_version = importlib.metadata.version(distribution_name)
         except (importlib.metadata.PackageNotFoundError, KeyError):
             # If we cannot find the metadata (because of editable install for example), try to import directly.
@@ -77,16 +71,6 @@ def _is_package_available(pkg_name: str, return_version: bool = False) -> tuple[
         return package_exists
 
 
-def is_env_variable_true(env_variable: str) -> bool:
-    """Detect whether `env_variable` has been set to a true value in the environment"""
-    return os.getenv(env_variable, "false").lower() in ("true", "1", "y", "yes", "on")
-
-
-def is_env_variable_false(env_variable: str) -> bool:
-    """Detect whether `env_variable` has been set to a false value in the environment"""
-    return os.getenv(env_variable, "true").lower() in ("false", "0", "n", "no", "off")
-
-
 ENV_VARS_TRUE_VALUES = {"1", "ON", "YES", "TRUE"}
 ENV_VARS_TRUE_AND_AUTO_VALUES = ENV_VARS_TRUE_VALUES.union({"AUTO"})
 
@@ -552,11 +536,6 @@ def is_torch_flex_attn_available() -> bool:
     return is_torch_available() and version.parse(get_torch_version()) >= version.parse("2.5.0")
 
 
-@lru_cache
-def is_grouped_mm_available() -> bool:
-    return is_torch_available() and version.parse(get_torch_version()) >= version.parse("2.9.0")
-
-
 @lru_cache
 def is_kenlm_available() -> bool:
     return _is_package_available("kenlm")
@@ -890,17 +869,14 @@ def is_flash_attn_2_available() -> bool:
 
     import torch
 
-    try:
-        if torch.version.cuda:
-            return version.parse(flash_attn_version) >= version.parse("2.1.0")
-        elif torch.version.hip:
-            # TODO: Bump the requirement to 2.1.0 once released in https://github.com/ROCmSoftwarePlatform/flash-attention
-            return version.parse(flash_attn_version) >= version.parse("2.0.4")
-        elif is_torch_mlu_available():
-            return version.parse(flash_attn_version) >= version.parse("2.3.3")
-        else:
-            return False
-    except packaging.version.InvalidVersion:
+    if torch.version.cuda:
+        return version.parse(flash_attn_version) >= version.parse("2.1.0")
+    elif torch.version.hip:
+        # TODO: Bump the requirement to 2.1.0 once released in https://github.com/ROCmSoftwarePlatform/flash-attention
+        return version.parse(flash_attn_version) >= version.parse("2.0.4")
+    elif is_torch_mlu_available():
+        return version.parse(flash_attn_version) >= version.parse("2.3.3")
+    else:
         return False
 
 
@@ -918,12 +894,7 @@ def is_flash_attn_greater_or_equal_2_10() -> bool:
 @lru_cache
 def is_flash_attn_greater_or_equal(library_version: str) -> bool:
     is_available, flash_attn_version = _is_package_available("flash_attn", return_version=True)
-    if not is_available:
-        return False
-    try:
-        return version.parse(flash_attn_version) >= version.parse(library_version)
-    except packaging.version.InvalidVersion:
-        return False
+    return is_available and version.parse(flash_attn_version) >= version.parse(library_version)
 
 
 @lru_cache
@@ -1007,7 +978,7 @@ def is_optimum_available() -> bool:
 
 
 @lru_cache
-def is_llm_awq_available() -> bool:
+def is_auto_awq_available() -> bool:
     return _is_package_available("awq")
 
 
@@ -1044,11 +1015,21 @@ def is_compressed_tensors_available() -> bool:
     return _is_package_available("compressed_tensors")
 
 
+@lru_cache
+def is_auto_gptq_available() -> bool:
+    return _is_package_available("auto_gptq")
+
+
 @lru_cache
 def is_gptqmodel_available() -> bool:
     return _is_package_available("gptqmodel")
 
 
+@lru_cache
+def is_eetq_available() -> bool:
+    return _is_package_available("eetq")
+
+
 @lru_cache
 def is_fbgemm_gpu_available() -> bool:
     return _is_package_available("fbgemm_gpu")
@@ -1084,11 +1065,6 @@ def is_pytest_available() -> bool:
     return _is_package_available("pytest")
 
 
-@lru_cache
-def is_pytest_order_available() -> bool:
-    return is_pytest_available() and _is_package_available("pytest_order")
-
-
 @lru_cache
 def is_spacy_available() -> bool:
     return _is_package_available("spacy")
@@ -1124,16 +1100,6 @@ def is_nltk_available() -> bool:
     return _is_package_available("nltk")
 
 
-@lru_cache
-def is_numba_available() -> bool:
-    is_available = _is_package_available("numba")
-    if not is_available:
-        return False
-
-    numpy_available, numpy_version = _is_package_available("numpy", return_version=True)
-    return not numpy_available or version.parse(numpy_version) < version.parse("2.2.0")
-
-
 @lru_cache
 def is_torchaudio_available() -> bool:
     return _is_package_available("torchaudio")
@@ -1314,10 +1280,15 @@ def is_torchdynamo_exporting() -> bool:
 
         return torch.compiler.is_exporting()
     except Exception:
-        return False
+        try:
+            import torch._dynamo as dynamo
+
+            return dynamo.is_exporting()
+        except Exception:
+            return False
 
 
-def is_torch_fx_proxy(x) -> bool:
+def is_torch_fx_proxy(x):
     try:
         import torch.fx
 
@@ -1326,43 +1297,6 @@ def is_torch_fx_proxy(x) -> bool:
         return False
 
 
-def is_fake_tensor(x) -> bool:
-    try:
-        import torch
-
-        return isinstance(x, torch._subclasses.FakeTensor)
-    except Exception:
-        return False
-
-
-def is_jax_jitting(x):
-    """returns True if we are inside of `jax.jit` context, False otherwise.
-
-    When a torch model is being compiled with `jax.jit` using torchax,
-    the tensor that goes through the model would be an instance of
-    `torchax.tensor.Tensor`, which is a tensor subclass. This tensor has
-    a `jax` method to return the inner Jax array
-    (https://github.com/google/torchax/blob/13ce870a1d9adb2430333c27bb623469e3aea34e/torchax/tensor.py#L134).
-    Here we use ducktyping to detect if the inner jax array is a jax Tracer
-    then we are in tracing context. (See more at: https://github.com/jax-ml/jax/discussions/9241)
-
-    Args:
-      x: torch.Tensor
-
-    Returns:
-      bool: whether we are inside of jax jit tracing.
-    """
-
-    if not hasattr(x, "jax"):
-        return False
-    try:
-        import jax
-
-        return isinstance(x.jax(), jax.core.Tracer)
-    except Exception:
-        return False
-
-
 def is_jit_tracing() -> bool:
     try:
         import torch
@@ -1372,69 +1306,16 @@ def is_jit_tracing() -> bool:
         return False
 
 
-def is_cuda_stream_capturing() -> bool:
-    try:
-        import torch
-
-        return torch.cuda.is_current_stream_capturing()
-    except Exception:
-        return False
-
-
 def is_tracing(tensor=None) -> bool:
-    """Checks whether we are tracing a graph with dynamo (compile or export), torch.jit, torch.fx, jax.jit (with torchax) or
-    CUDA stream capturing or FakeTensor"""
-
+    """Checks whether we are tracing a graph with dynamo (compile or export), torch.jit, or torch.fx"""
     # Note that `is_torchdynamo_compiling` checks both compiling and exporting (the export check is stricter and
     # only checks export)
-    _is_tracing = is_torchdynamo_compiling() or is_jit_tracing() or is_cuda_stream_capturing()
+    _is_tracing = is_torchdynamo_compiling() or is_jit_tracing()
     if tensor is not None:
         _is_tracing |= is_torch_fx_proxy(tensor)
-        _is_tracing |= is_fake_tensor(tensor)
-        _is_tracing |= is_jax_jitting(tensor)
-
     return _is_tracing
 
 
-def torch_compilable_check(cond: Any, msg: str | Callable[[], str], error_type: type[Exception] = ValueError) -> None:
-    """
-    Combines the functionalities of `torch._check`, `torch._check_with` and `torch._check_tensor_all_with` to provide a
-    unified way to perform checks that are compatible with TorchDynamo (torch.compile & torch.export).
-
-    The advantage of using `torch._check(cond, msg, error_type)` over `if cond: raise error_type(msg)` is that the former
-    works as a truthfulness hint for TorchDynamo, instead of failing with a data-dependent control flow error during compilation.
-
-    All checks using this method can be disabled in production environments by setting `TRANSFORMERS_DISABLE_TORCH_CHECK=1`.
-
-    Args:
-        cond (`bool`, `torch.Tensor` or `Callable[[], bool | torch.Tensor]`): The condition to check.
-        msg (`str` or `Callable[[], str]`): The error message to display if the condition is not met.
-        error_type (`type[Exception]`, *optional*, defaults to `ValueError`): The type of error to raise if the condition is not met.
-
-    Raises:
-        error_type: If the condition is not met.
-    """
-    if os.getenv("TRANSFORMERS_DISABLE_TORCH_CHECK", "0") == "1":
-        return
-
-    import torch
-
-    if not callable(msg):
-        # torch._check requires msg to be a callable but we want to keep the API simple for users
-        def msg_callable():
-            return msg
-    else:
-        msg_callable = msg
-
-    if callable(cond):
-        cond = cond()
-
-    if isinstance(cond, torch.Tensor):
-        torch._check_tensor_all_with(error_type, cond, msg_callable)
-    else:
-        torch._check_with(error_type, cond, msg_callable)
-
-
 @lru_cache
 def is_in_notebook() -> bool:
     try:
@@ -1899,20 +1780,6 @@ BACKENDS_MAPPING = OrderedDict(
 
 
 def requires_backends(obj, backends):
-    """
-    Method that automatically raises in case the specified backends are not available. It is often used during class
-    initialization to ensure the required dependencies are installed:
-
-    ```py
-    requires_backends(self, ["torch"])
-    ```
-
-    The backends should be defined in the `BACKEND_MAPPING` defined in `transformers.utils.import_utils`.
-
-    Args:
-        obj: object to be checked
-        backends: list or tuple of backends to check.
-    """
     if not isinstance(backends, (list, tuple)):
         backends = [backends]
 

transformers/utils/kernel_config.py

@@ -71,36 +71,14 @@ def add_to_mapping(layer_name, device, repo_name, mode, compatible_mapping):
     }
 
 
-def add_to_mapping_local(layer_name, device, repo_name, mode, compatible_mapping):
-    from pathlib import Path
-
-    from kernels import LocalLayerRepository
-
-    if device not in ["cuda", "rocm", "xpu", "npu"]:
-        raise ValueError(f"Only cuda, rocm, xpu and npu devices supported, got: {device}")
-    repo_layer_name = repo_name.split(":")[1]
-    repo_path = repo_name.split(":")[0]
-    repo_package_name = repo_path.split("/")[-1]
-    compatible_mapping[layer_name] = {
-        device: {
-            mode: LocalLayerRepository(
-                repo_path=Path(repo_path),
-                package_name=repo_package_name,
-                layer_name=repo_layer_name,
-            )
-        }
-    }
-
-
 class KernelConfig(PushToHubMixin):
     """
     Kernel configuration class. This class is used to configure the kernel mapping for a model.
     """
 
-    def __init__(self, kernel_mapping={}, use_local_kernel=False):
+    def __init__(self, kernel_mapping={}):
         self.kernel_mapping = kernel_mapping
         self.registered_layer_names = {}
-        self.use_local_kernel = use_local_kernel
 
     def update_kernel(self, repo_id, registered_name, layer_name, device, mode, revision=None):
         from kernels import LayerRepository
@@ -127,7 +105,6 @@ class KernelConfig(PushToHubMixin):
         2. Each kernel value is either a string of the form 'org/repo:layer_name' or a dict mapping device types ("cuda", "rocm", "xpu", "npu") to such strings.
         3. Each device key in a dict is one of "cuda", "rocm", "xpu", or "npu".
         4. Each repo_name is a valid repository and layer name in the format 'org/repo:layer_name' (i.e., a string containing both a slash and a colon).
-        5. If a local path is detected, it should be in the format '/abs/path:layer_name'. The absolute path must include the `package_name`, like "/home/user/layer_norm".
 
         Args:
             model: The model instance whose modules are checked for registered kernel_layer_name attributes.
@@ -137,13 +114,14 @@ class KernelConfig(PushToHubMixin):
                         or if a repo_name is not a valid 'org/repo:layer_name' string.
         """
         MAPPING_FORMAT = """
-        For single device form remote
         {
             "RMSNorm":
                 "kernels-community/layer_norm:LlamaRMSNorm",
             ...
         },
-        For multiple devices form remote
+
+        or
+
         {
             "RMSNorm": {
                 "cuda":
@@ -154,23 +132,6 @@ class KernelConfig(PushToHubMixin):
             },
             ...
         }
-        For single device form local
-        {
-            "RMSNorm":
-                "/abs/path:LlamaRMSNorm",
-            ...
-        },
-        For multiple devices form local
-        {
-            "RMSNorm": {
-                "cuda":
-                    "/abs/path:LlamaRMSNorm",
-                "rocm":
-                    "/abs/path:LlamaRMSNorm",
-                ...
-            },
-            ...
-        }
         """
         self.store_registered_layer_names(model)
         # Validate that the kernel mapping is a dict
@@ -188,7 +149,7 @@ class KernelConfig(PushToHubMixin):
             if isinstance(kernel, str):
                 if "/" not in kernel or ":" not in kernel:
                     raise ValueError(
-                        f"Kernel mapping for '{layer_name}' must be a valid repo name with a layer name (e.g., 'org/repo:layer_name' or '/abs/path:layer_name'), got: {kernel}"
+                        f"Kernel mapping for '{layer_name}' must be a valid repo name with a layer name (e.g., 'org/repo:layer_name'), got: {kernel}"
                     )
 
             elif isinstance(kernel, dict):
@@ -198,8 +159,9 @@ class KernelConfig(PushToHubMixin):
 
                     if not isinstance(repo_name, str) or "/" not in repo_name or ":" not in repo_name:
                         raise ValueError(
-                            f"Kernel mapping for '{layer_name}' must be a valid repo name with a layer name (e.g., 'org/repo:layer_name' or '/abs/path:layer_name'), got: {repo_name}"
+                            f"Kernel mapping for '{layer_name}' must be a valid repo name with a layer name (e.g., 'org/repo:layer_name'), got: {repo_name}"
                         )
+
             else:
                 raise ValueError(f"Kernel mapping must follow the format: {MAPPING_FORMAT}, got: {kernel}")
 
@@ -212,13 +174,18 @@ class KernelConfig(PushToHubMixin):
                 ...
             },
 
-            or for local path:
+            or
 
             {
-                "RMSNorm":
-                    "/home/user/liger_kernels:LigerRMSNorm",
+                "RMSNorm": {
+                    "cuda":
+                        "kernels-community/layer_norm:LlamaRMSNorm",
+                    "rocm":
+                        "kernels-community/layer_norm:LlamaRMSNorm",
+                    ...
+                },
                 ...
-            },
+            }
 
         into a nested mapping:
 
@@ -233,20 +200,6 @@ class KernelConfig(PushToHubMixin):
                 }
             }
 
-            or for local path:
-
-            {
-                "RMSNorm": {
-                    "cuda": {
-                        Mode.INFERENCE: LocalLayerRepository(
-                            repo_path=Path("/home/user/liger_kernels"),
-                            package_name="liger_kernels",
-                            layer_name="LigerRMSNorm",
-                        )
-                    }
-                }
-            }
-
         that's compatible with the kernels library.
 
         The device is inferred from the model's parameters if not provided.
@@ -255,7 +208,6 @@ class KernelConfig(PushToHubMixin):
         from kernels import Mode
 
         compatible_mapping = {}
-        current_device = infer_device(model)
         for layer_name, kernel in self.kernel_mapping.items():
             # Infer Mode: use Mode.TRAINING if model is training, else use Mode.INFERENCE
             mode = Mode.TRAINING if model.training else Mode.INFERENCE
@@ -264,17 +216,10 @@ class KernelConfig(PushToHubMixin):
 
             if isinstance(kernel, str):
                 repo_name = kernel
-                if not self.use_local_kernel:
-                    add_to_mapping(layer_name, current_device, repo_name, mode, compatible_mapping)
-                else:
-                    add_to_mapping_local(layer_name, current_device, repo_name, mode, compatible_mapping)
+                device = infer_device(model)
+                add_to_mapping(layer_name, device, repo_name, mode, compatible_mapping)
             elif isinstance(kernel, dict):
                 for device, repo_name in kernel.items():
-                    if device != current_device:
-                        continue
-                    if not self.use_local_kernel:
-                        add_to_mapping(layer_name, device, repo_name, mode, compatible_mapping)
-                    else:
-                        add_to_mapping_local(layer_name, device, repo_name, mode, compatible_mapping)
+                    add_to_mapping(layer_name, device, repo_name, mode, compatible_mapping)
 
         self.kernel_mapping = compatible_mapping

transformers/utils/loading_report.py

@@ -17,7 +17,7 @@ import shutil
 import sys
 from collections import OrderedDict, defaultdict
 from collections.abc import Iterable
-from typing import Any
+from typing import Any, Optional
 
 
 _DIGIT_RX = re.compile(r"(?<=\.)(\d+)(?=\.|$)")  # numbers between dots or at the end
@@ -140,15 +140,17 @@ def _get_terminal_width(default=80):
 def log_state_dict_report(
     *,
     model,
-    load_config,
-    logger: logging.Logger | None = None,
-    error_msgs: Iterable[str] | None = None,
+    pretrained_model_name_or_path,
+    logger: Optional[logging.Logger] = None,
+    error_msgs: Optional[Iterable[str]] = None,
     unexpected_keys=None,
     missing_keys=None,
     mismatched_keys=None,
     mismatched_shapes=None,
-    conversion_errors=None,
+    ignore_mismatched_sizes=True,
+    misc=None,
     color=True,  # allow disabling for plain logs
+    min_width_full_table=60,  # terminal min width to attempt full table
 ):
     """Log a readable report about state_dict loading issues.
 
@@ -163,15 +165,12 @@ def log_state_dict_report(
     missing_keys = missing_keys or []
     mismatched_keys = mismatched_keys or []
     mismatched_shapes = mismatched_shapes or []
-    conversion_errors = conversion_errors or {}
-    pretrained_model_name_or_path = load_config.pretrained_model_name_or_path
-    ignore_mismatched_sizes = load_config.ignore_mismatched_sizes
+    misc = misc or {}
 
     # Detect whether the current stdout supports ANSI colors; allow callers to pass `color=False` to force no color
     color_enabled = bool(color and sys.stdout.isatty())
     ansi = ANSI(color_enabled)
 
-    # Re-raise errors early if needed
     if error_msgs:
         error_msg = "\n\t".join(error_msgs)
         if "size mismatch" in error_msg:
@@ -205,9 +204,9 @@ def log_state_dict_report(
             )
             rows.append(data)
 
-    if conversion_errors:
-        for k, v in update_key_name(conversion_errors).items():
-            status = "CONVERSION"
+    if misc:
+        for k, v in update_key_name(misc).items():
+            status = "MISC"
             status = _color(status, "purple", ansi)
             _details = v[:term_w]
             rows.append([k, status, _details])
@@ -229,25 +228,16 @@ def log_state_dict_report(
     if unexpected_keys:
         tips += f"\n- {_color('UNEXPECTED', 'orange', ansi) + ansi['italic']}\t:can be ignored when loading from different task/architecture; not ok if you expect identical arch."
     if missing_keys:
-        tips += f"\n- {_color('MISSING', 'red', ansi) + ansi['italic']}\t:those params were newly initialized because missing from the checkpoint. Consider training on your downstream task."
+        tips += f"\n- {_color('MISSING', 'red', ansi) + ansi['italic']}\t:those params were newly initialized because missing form the checkpoint. Consider training on your downstream task."
     if mismatched_keys:
-        tips += f"\n- {_color('MISMATCH', 'yellow', ansi) + ansi['italic']}\t:ckpt weights were loaded, but they did not match the original empty weight shapes."
-    if conversion_errors:
-        tips += f"\n- {_color('CONVERSION', 'purple', ansi) + ansi['italic']}\t:originate from the conversion scheme"
+        tips += f"\n- {_color('MISMATCH', 'yellow', ansi) + ansi['italic']}\t:ckpt weights were loaded, but they did not match the original empty weight."
+    if misc:
+        tips += f"\n- {_color('MISC', 'purple', ansi) + ansi['italic']}\t:originate from the conversion scheme"
     tips += f"{ansi['reset']}"
 
-    # Log the report as warning
     logger.warning(prelude + table + tips)
-
-    # Re-raise in those case, after the report
-    if conversion_errors:
-        raise RuntimeError(
-            "We encountered some issues during automatic conversion of the weights. For details look at the `CONVERSION` entries of "
-            "the above report!"
-        )
     if not ignore_mismatched_sizes and mismatched_keys:
         raise RuntimeError(
             "You set `ignore_mismatched_sizes` to `False`, thus raising an error. For details look at the above report!"
         )
-
     return prelude + table + tips