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

transformers/integrations/flex_attention.py

@@ -102,7 +102,7 @@ def compile_friendly_flex_attention(
     )
 
 
-Offset = torch.Tensor | int
+Offset = Union[torch.Tensor, int]
 
 
 # TODO: deprecate / rename to make_flex_block_mask for clarity as it's not only causal anymore

transformers/integrations/fp_quant.py

@@ -13,8 +13,6 @@
 # limitations under the License.
 "FP-Quant integration file"
 
-import torch
-
 from ..utils import (
     is_fp_quant_available,
 )
@@ -26,94 +24,6 @@ if is_fp_quant_available():
 
 from transformers.utils.quantization_config import FPQuantConfig
 
-from ..core_model_loading import ConversionOps
-from ..quantizers.quantizers_utils import get_module_from_name
-
-
-class FpQuantQuantize(ConversionOps):
-    def __init__(self, hf_quantizer):
-        self.hf_quantizer = hf_quantizer
-
-    def convert(
-        self,
-        input_dict: torch.Tensor,
-        model: torch.nn.Module | None = None,
-        missing_keys: list[str] | None = None,
-        **kwargs,
-    ) -> dict[str, torch.Tensor]:
-        target_key, value = tuple(input_dict.items())[0]
-        value = value[0]
-        # Loading master weights or an unquantized checkpoint
-        weight = torch.nn.Parameter(value)
-        module, _ = get_module_from_name(model, target_key)
-        module.weight = weight
-
-        # Let pre-forward handle the quantization and set None where necessary
-        # This operation will quantize the weights internally
-        with torch.cuda.device(value.device):
-            module.pre_forward()
-
-        prefix_target_key = target_key.rsplit(".", 1)[0]
-
-        # keys are set inside the module.pre_forward() method, we don't need remove them from the missing keys list
-        missing_keys.discard(target_key)
-        missing_keys.discard(f"{prefix_target_key}.backward_hadamard_matrix")
-        missing_keys.discard(f"{prefix_target_key}.forward_hadamard_matrix")
-        missing_keys.discard(f"{prefix_target_key}.act_global_scale")
-        missing_keys.discard(f"{prefix_target_key}.weight_global_scale")
-        missing_keys.discard(f"{prefix_target_key}.qweight")
-        missing_keys.discard(f"{prefix_target_key}.scales")
-        missing_keys.discard(f"{prefix_target_key}.dqweight")
-        return {}
-
-
-class FpQuantDeserialize(ConversionOps):
-    def __init__(self, hf_quantizer):
-        self.hf_quantizer = hf_quantizer
-
-    def convert(
-        self,
-        input_dict: torch.Tensor,
-        model: torch.nn.Module | None = None,
-        full_layer_name: str | None = None,
-        missing_keys: list[str] | None = None,
-        **kwargs,
-    ) -> dict[str, torch.Tensor]:
-        target_key, value = tuple(input_dict.items())[0]
-        value = value[0] if isinstance(value, list) else value
-        module, _ = get_module_from_name(model, target_key)
-        # The module holds either:
-        #  * `weight` when `store_master_weights=True`
-        #  * `qweight` and `scales` when `store_master_weights=False` and `pseudoquantization=False`
-        #  * `dqweight` when `store_master_weights=False` and `pseudoquantization=True`
-        if target_key == ".qweight":
-            # Loading a real quantized checkpoint without master weights
-            qweight = torch.nn.Parameter(
-                value,
-                requires_grad=False,
-            )
-
-            return {
-                ".qweight": qweight,
-                # the way the FPQuantLinear module is designed, these parameters are expected in the model
-                # even though they are not used so we need to set them to zeros
-                ".weight": torch.nn.Parameter(torch.zeros(0)),
-                ".dqweight": torch.nn.Parameter(torch.zeros(0)),
-            }
-
-        if target_key == ".dqweight":
-            # Loading a pseudo-quantized checkpoint without master weights
-            dqweight = torch.nn.Parameter(value)
-
-            return {
-                ".dqweight": dqweight,
-                # the way the FPQuantLinear module ips designed, these parameters are expected in the model
-                # even though they are not used so we need to set them to zeros
-                ".weight": torch.nn.Parameter(torch.zeros(0)),
-                ".qweight": torch.nn.Parameter(torch.zeros(0)),
-                ".scales": torch.nn.Parameter(torch.zeros(0)),
-            }
-
 
 def adapt_fp_quant_config(config: FPQuantConfig):
     if config.forward_dtype == "mxfp4":

transformers/integrations/ggml.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2024 The ggml.ai team and The HuggingFace Inc. team. and pygguf author (github.com/99991)
 # https://github.com/99991/pygguf
 #
@@ -75,7 +76,7 @@ GGUF_CONFIG_MAPPING = {
         "attention.layer_norm_rms_epsilon": "rms_norm_eps",
         "vocab_size": "vocab_size",
     },
-    "qwen2_moe": {
+    "qwen2moe": {
         "context_length": "max_position_embeddings",
         "block_count": "num_hidden_layers",
         "feed_forward_length": "intermediate_size",
@@ -312,16 +313,6 @@ GGUF_TOKENIZER_MAPPING = {
     },
 }
 
-# We only need to set here the parameters that default to different values between transformers and llamacpp.
-GGUF_CONFIG_DEFAULTS_MAPPING = {
-    "qwen3_moe": {
-        # NOTE: Qwen3MoeConfig defaults to false but llama.cpp needs this to be true.
-        # See: https://github.com/ggml-org/llama.cpp/blob/17f7f4baad8b3a716ee139da7bb56ae984e8c0fa/src/models/qwen3moe.cpp#L85-L96
-        #      (the parameter right after LLM_FFN_SILU corresponds to norm_topk_prob)
-        "norm_topk_prob": True,
-    },
-}
-
 
 def _gguf_parse_value(_value, data_type):
     if not isinstance(data_type, list):

transformers/integrations/higgs.py

@@ -15,13 +15,17 @@
 
 from math import sqrt
 
-from ..quantizers.quantizers_utils import should_convert_module
-from ..utils import is_flute_available, is_hadamard_available, is_torch_available, logging
+from ..utils import (
+    is_flute_available,
+    is_hadamard_available,
+    is_torch_available,
+)
 
 
 if is_torch_available():
     import torch
-    import torch.nn as nn
+    from torch import nn
+
 
 if is_flute_available():
     from flute.integrations.higgs import prepare_data_transposed
@@ -30,8 +34,6 @@ if is_flute_available():
 if is_hadamard_available():
     from fast_hadamard_transform import hadamard_transform
 
-logger = logging.get_logger(__name__)
-
 
 def pad_to_block(tensor, dims, had_block_size, value=0):
     pad_dims = [0 for _ in range(2 * len(tensor.shape))]
@@ -547,47 +549,70 @@ class HiggsLinear(torch.nn.Module):
         )
 
 
-def replace_with_higgs_linear(model, modules_to_not_convert: list[str] | None = None, quantization_config=None):
+def replace_with_higgs_linear(
+    model,
+    quantization_config=None,
+    current_key_name=None,
+    has_been_replaced=False,
+    modules_to_not_convert=None,
+):
     """
-    Public method that replaces the Linear layers of the given model with HIGGS quantized layers.
+    Public method that recursively replaces the Linear layers of the given model with HIGGS quantized layers.
+    `accelerate` is needed to use this method. Returns the converted model and a boolean that indicates if the
+    conversion has been successful or not.
 
     Args:
         model (`torch.nn.Module`):
             The model to convert, can be any `torch.nn.Module` instance.
-        modules_to_not_convert (`list[str]`, *optional*, defaults to `None`):
-            A list of nn.Linear weights to not convert. If a parameter path is in the list (e.g. `lm_head.weight`), the corresponding module will not be
-            converted.
         quantization_config (`HiggsConfig`):
             The quantization config object that contains the quantization parameters.
+        current_key_name (`list`, *optional*):
+            A list that contains the current key name. This is used for recursion and should not be passed by the user.
+        has_been_replaced (`bool`, *optional*):
+            A boolean that indicates if the conversion has been successful or not. This is used for recursion and
+            should not be passed by the user.
     """
 
-    has_been_replaced = False
-    # we need this to correctly materialize the weights during quantization
-    for module_name, module in model.named_modules():
-        if not should_convert_module(module_name, modules_to_not_convert):
-            continue
-        with torch.device("meta"):
-            if isinstance(module, nn.Linear):
-                new_module = HiggsLinear(
-                    module.in_features,
-                    module.out_features,
-                    bias=module.bias is not None,
-                    num_bits=quantization_config.bits,
-                    hadamard_size=quantization_config.hadamard_size,
-                    group_size=quantization_config.group_size,
-                )
-                new_module.source_cls = type(module)
-                new_module.requires_grad_(False)
-                model.set_submodule(module_name, new_module)
-                has_been_replaced = True
-
-    if not has_been_replaced:
-        logger.warning(
-            "You are loading your model using eetq but no linear modules were found in your model."
-            " Please double check your model architecture, or submit an issue on github if you think this is"
-            " a bug."
-        )
-    return model
+    from accelerate import init_empty_weights
+
+    for name, module in model.named_children():
+        if current_key_name is None:
+            current_key_name = []
+        current_key_name.append(name)
+
+        if isinstance(module, nn.Linear):
+            # Check if the current key is not in the `quantization_config.modules_to_not_convert`
+            current_key_name_str = ".".join(current_key_name)
+            if not any(current_key_name_str.endswith(key) for key in modules_to_not_convert):
+                with init_empty_weights():
+                    in_features = module.in_features
+                    out_features = module.out_features
+
+                    model._modules[name] = HiggsLinear(
+                        in_features,
+                        out_features,
+                        bias=module.bias is not None,
+                        num_bits=quantization_config.bits,
+                        hadamard_size=quantization_config.hadamard_size,
+                        group_size=quantization_config.group_size,
+                    )
+                    has_been_replaced = True
+
+                    # Store the module class in case we need to transpose the weight later
+                    model._modules[name].source_cls = type(module)
+                    # Force requires grad to False to avoid unexpected errors
+                    model._modules[name].requires_grad_(False)
+        if len(list(module.children())) > 0:
+            _, has_been_replaced = replace_with_higgs_linear(
+                module,
+                quantization_config=quantization_config,
+                current_key_name=current_key_name,
+                has_been_replaced=has_been_replaced,
+                modules_to_not_convert=modules_to_not_convert,
+            )
+        # Remove the last key for recursion
+        current_key_name.pop(-1)
+    return model, has_been_replaced
 
 
 def dequantize_higgs(model, current_key_name=None):

transformers/integrations/hub_kernels.py

@@ -11,14 +11,11 @@
 # 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 importlib.metadata
 import os
 import re
 from collections.abc import Callable
 from types import ModuleType
 
-from packaging import version as pkg_version
-
 from ..utils import ENV_VARS_TRUE_VALUES, logging
 from ..utils.import_utils import is_kernels_available
 from .flash_attention import flash_attention_forward
@@ -31,12 +28,10 @@ try:
         Device,
         LayerRepository,
         Mode,
+        get_kernel,
         register_kernel_mapping,
         replace_kernel_forward_from_hub,
     )
-    from kernels import (
-        get_kernel as get_kernel_hub,
-    )
     from kernels import (
         use_kernel_forward_from_hub as _kernels_use_kernel_forward_from_hub,
     )
@@ -83,7 +78,7 @@ try:
                 )
             return lambda func: func
 
-    _KERNEL_MAPPING: dict[str, dict[Device | str, LayerRepository | dict[Mode, LayerRepository]]] = {
+    _KERNEL_MAPPING: dict[str, dict[Device | str, LayerRepository]] = {
         "MultiScaleDeformableAttention": {
             "cuda": LayerRepository(
                 repo_id="kernels-community/deformable-detr",
@@ -116,12 +111,6 @@ try:
                     layer_name="RMSNorm",
                 )
             },
-            "mps": {
-                Mode.INFERENCE: LayerRepository(
-                    repo_id="kernels-community/mlx_rmsnorm",
-                    layer_name="RMSNorm",
-                )
-            },
             "npu": {
                 Mode.INFERENCE: LayerRepository(
                     repo_id="kernels-community/liger_kernels",
@@ -264,8 +253,6 @@ except ImportError:
 
 _HUB_KERNEL_MAPPING: dict[str, dict[str, str]] = {
     "causal-conv1d": {"repo_id": "kernels-community/causal-conv1d"},
-    "mamba-ssm": {"repo_id": "kernels-community/mamba-ssm", "revision": "v0.0.4"},
-    "falcon_mamba-ssm": {"repo_id": "kernels-community/mamba-ssm", "revision": "v0.0.4"},
 }
 
 _KERNEL_MODULE_MAPPING: dict[str, ModuleType | None] = {}
@@ -341,21 +328,19 @@ def lazy_load_kernel(kernel_name: str, mapping: dict[str, ModuleType | None] = _
     if kernel_name in mapping and isinstance(mapping[kernel_name], ModuleType):
         return mapping[kernel_name]
     if kernel_name not in _HUB_KERNEL_MAPPING:
-        logger.warning_once(f"Kernel {kernel_name} not found in _HUB_KERNEL_MAPPING")
+        logger.warning(f"Kernel {kernel_name} not found in _HUB_KERNEL_MAPPING")
         mapping[kernel_name] = None
         return None
     if _kernels_available:
+        from kernels import get_kernel
+
         try:
             repo_id = _HUB_KERNEL_MAPPING[kernel_name]["repo_id"]
-            revision = _HUB_KERNEL_MAPPING[kernel_name].get("revision", None)
             version = _HUB_KERNEL_MAPPING[kernel_name].get("version", None)
-            kernel = get_kernel(repo_id, revision=revision, version=version)
+            kernel = get_kernel(repo_id, version=version)
             mapping[kernel_name] = kernel
         except FileNotFoundError:
             mapping[kernel_name] = None
-        except AssertionError:
-            # Happens when torch is built without an accelerator backend; fall back to slow path.
-            mapping[kernel_name] = None
 
     else:
         # Try to import is_{kernel_name}_available from ..utils
@@ -373,7 +358,7 @@ def lazy_load_kernel(kernel_name: str, mapping: dict[str, ModuleType | None] = _
         if callable(is_kernel_available) and is_kernel_available():
             # Try to import the module "{kernel_name}" from parent package level
             try:
-                module = importlib.import_module(f"{new_kernel_name}")
+                module = importlib.import_module(f"{kernel_name}")
                 mapping[kernel_name] = module
                 return module
             except Exception:
@@ -384,46 +369,6 @@ def lazy_load_kernel(kernel_name: str, mapping: dict[str, ModuleType | None] = _
     return mapping[kernel_name]
 
 
-def get_kernel(kernel_name: str, revision: str | None = None, version: str | None = None) -> ModuleType:
-    from .. import __version__
-
-    user_agent = {"framework": "transformers", "version": __version__, "repo_id": kernel_name}
-    if _kernels_available:
-        kernels_version = importlib.metadata.version("kernels")
-        if pkg_version.parse(kernels_version) >= pkg_version.parse("0.10.4"):
-            return get_kernel_hub(kernel_name, revision=revision, version=version, user_agent=user_agent)
-        else:
-            return get_kernel_hub(kernel_name, revision=revision)
-    else:
-        raise ImportError("kernels is not installed, please install it with `pip install kernels`")
-
-
-def use_kernelized_func(module_names: list[Callable] | Callable):
-    """
-    This decorator attaches the target function as an attribute of the module.
-    The function must already be decorated with @use_kernel_func_from_hub
-    this decorator then wraps it as an nn.Module internally.
-    When kernelize is later applied to the full model, the function can be accessed as a regular module attribute and kernelized just like any other layer.
-    The kernelization is performed in place, modifying the module directly.
-    """
-    if isinstance(module_names, Callable):
-        module_names = [module_names]
-
-    def decorator(cls):
-        orig_init = cls.__init__
-
-        def new_init(self, *args, **kwargs):
-            orig_init(self, *args, **kwargs)
-            for fn in module_names:
-                # we hardcode the name of the function to "rotary_fn" for now
-                setattr(self, "rotary_fn", fn)
-
-        cls.__init__ = new_init
-        return cls
-
-    return decorator
-
-
 __all__ = [
     "LayerRepository",
     "use_kernel_forward_from_hub",
@@ -432,6 +377,4 @@ __all__ = [
     "register_kernel_mapping_transformers",
     "replace_kernel_forward_from_hub",
     "lazy_load_kernel",
-    "get_kernel",
-    "use_kernelized_func",
-]  # type: ignore
+]

transformers/integrations/integration_utils.py

@@ -26,7 +26,6 @@ import re
 import shutil
 import sys
 import tempfile
-import warnings
 from dataclasses import fields
 from enum import Enum
 from pathlib import Path
@@ -302,6 +301,7 @@ def run_hp_search_ray(trainer, n_trials: int, direction: str, **kwargs) -> BestR
             other options are also available. See the Ray documentation (https://docs.ray.io/en/latest/tune/api_docs/analysis.html#ray.tune.ExperimentAnalysis.get_best_trial)
             for more options
     """
+    import ray
     import ray.tune
 
     def _objective(trial: dict, local_trainer):
@@ -939,8 +939,6 @@ class TrackioCallback(TrainerCallback):
     ```
     """
 
-    SPACE_URL = "https://huggingface.co/spaces/{space_id}"
-
     def __init__(self):
         has_trackio = is_trackio_available()
         if not has_trackio:
@@ -1059,39 +1057,6 @@ class TrackioCallback(TrainerCallback):
             metrics = rewrite_logs(metrics)
             self._trackio.log(metrics)
 
-    def on_push_begin(self, args, state, control, model, **kwargs):
-        if not state.is_world_process_zero or self._trackio is None:
-            return
-        if (current_project := self._trackio.context_vars.current_project.get()) is None:
-            return
-        trackio_version = packaging.version.parse(self._trackio.__version__)
-        if trackio_version < packaging.version.parse("0.13.0"):
-            warnings.warn(
-                "The version of `trackio` that is installed is <=0.13.0, so "
-                "the local Trackio project will not be pushed to Hugging Face. Run "
-                "`pip install --upgrade trackio` to fix this."
-            )
-            return
-
-        space_id = self._trackio.context_vars.current_space_id.get()
-        if space_id is None:
-            space_id = self._trackio.sync(current_project, force=True)
-        space_url = self.SPACE_URL.format(space_id=space_id)
-
-        badge_markdown = (
-            f'<a href="{space_url}" target="_blank"><img src="https://raw.githubusercontent.com/gradio-app/trackio/refs/heads/main/trackio/assets/badge.png" alt="Visualize in Trackio"'
-            ' title="Visualize in Trackio" style="height: 40px;"/></a>'
-        )
-        if badge_markdown not in modelcard.AUTOGENERATED_TRAINER_COMMENT:
-            modelcard.AUTOGENERATED_TRAINER_COMMENT += f"\n{badge_markdown}"
-
-        trackio_tags = ["trackio", f"trackio:{space_url}"]
-        if getattr(model, "model_tags", None) is not None:
-            if "trackio" not in model.model_tags:
-                model.model_tags.extend(trackio_tags)
-        else:
-            model.model_tags = trackio_tags
-
 
 class CometCallback(TrainerCallback):
     """
@@ -1490,10 +1455,6 @@ class NeptuneMissingConfiguration(Exception):
 class NeptuneCallback(TrainerCallback):
     """TrainerCallback that sends the logs to [Neptune](https://app.neptune.ai).
 
-    > [!WARNING]
-    > Neptune integration is deprecated and will be removed in a future version of Transformers. We recommend using
-    > other supported experiment tracking integrations.
-
     Args:
         api_token (`str`, *optional*): Neptune API token obtained upon registration.
             You can leave this argument out if you have saved your token to the `NEPTUNE_API_TOKEN` environment
@@ -1539,11 +1500,6 @@ class NeptuneCallback(TrainerCallback):
         log_checkpoints: str | None = None,
         **neptune_run_kwargs,
     ):
-        warnings.warn(
-            "The NeptuneCallback is deprecated and will be removed in a future version of Transformers. We recommend "
-            "using other supported experiment tracking integrations.",
-            FutureWarning,
-        )
         if not is_neptune_available():
             raise ValueError(
                 "NeptuneCallback requires the Neptune client library to be installed. "
@@ -2402,9 +2358,9 @@ def get_reporting_integration_callbacks(report_to):
         return []
 
     if isinstance(report_to, str):
-        if report_to == "none":
+        if "none" == report_to:
             return []
-        elif report_to == "all":
+        elif "all" == report_to:
             report_to = get_available_reporting_integrations()
         else:
             report_to = [report_to]

transformers/integrations/mistral.py

@@ -77,7 +77,6 @@ def convert_tekken_tokenizer(tokenizer_file: str):
     """Convert a "tekken" tokenizer to a fast Tokenizer."""
     # Tekken format -- need to use the Converter
 
-    from mistral_common.tokens.tokenizers.base import SpecialTokens
     from mistral_common.tokens.tokenizers.mistral import MistralTokenizer
 
     # Load directly using their lib
@@ -107,15 +106,4 @@ def convert_tekken_tokenizer(tokenizer_file: str):
     # Post-process
     tokenizer.add_special_tokens({"additional_special_tokens": all_special})
 
-    MAP_SPECAL = {
-        "bos_token": SpecialTokens.bos.value,
-        "eos_token": SpecialTokens.eos.value,
-        "pad_token": SpecialTokens.pad.value,
-        "unk_token": SpecialTokens.unk.value,
-    }
-
-    for special_key, special_token in MAP_SPECAL.items():
-        if special_token in all_special:
-            tokenizer.add_special_tokens({special_key: special_token})
-
     return tokenizer