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

transformers/__init__.py

@@ -18,11 +18,8 @@
 # to defer the actual importing for when the objects are requested. This way `import transformers` provides the names
 # in the namespace without actually importing anything (and especially none of the backends).
 
-__version__ = "5.0.0"
+__version__ = "5.0.0rc0"
 
-import importlib
-import sys
-import types
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -36,7 +33,6 @@ from .utils import (
     is_librosa_available,
     is_mistral_common_available,
     is_mlx_available,
-    is_numba_available,
     is_pretty_midi_available,
 )
 
@@ -133,6 +129,7 @@ _import_structure = {
         "is_wandb_available",
     ],
     "loss": [],
+    "modelcard": ["ModelCard"],
     "pipelines": [
         "AnyToAnyPipeline",
         "AudioClassificationPipeline",
@@ -147,6 +144,7 @@ _import_structure = {
         "ImageSegmentationPipeline",
         "ImageTextToTextPipeline",
         "ImageToImagePipeline",
+        "ImageToTextPipeline",
         "JsonPipelineDataFormat",
         "KeypointMatchingPipeline",
         "MaskGenerationPipeline",
@@ -156,11 +154,14 @@ _import_structure = {
         "Pipeline",
         "PipelineDataFormat",
         "QuestionAnsweringPipeline",
+        "SummarizationPipeline",
         "TableQuestionAnsweringPipeline",
+        "Text2TextGenerationPipeline",
         "TextClassificationPipeline",
         "TextGenerationPipeline",
         "TextToAudioPipeline",
         "TokenClassificationPipeline",
+        "TranslationPipeline",
         "VideoClassificationPipeline",
         "VisualQuestionAnsweringPipeline",
         "ZeroShotAudioClassificationPipeline",
@@ -173,7 +174,7 @@ _import_structure = {
     "quantizers": [],
     "testing_utils": [],
     "tokenization_python": ["PreTrainedTokenizer", "PythonBackend"],
-    "tokenization_utils": [],
+    "tokenization_utils_sentencepiece": ["SentencePieceBackend"],
     "tokenization_utils_base": [
         "AddedToken",
         "BatchEncoding",
@@ -181,8 +182,6 @@ _import_structure = {
         "PreTrainedTokenizerBase",
         "TokenSpan",
     ],
-    "tokenization_utils_fast": [],
-    "tokenization_utils_sentencepiece": ["SentencePieceBackend"],
     "trainer_callback": [
         "DefaultFlowCallback",
         "EarlyStoppingCallback",
@@ -239,8 +238,6 @@ _import_structure = {
         "is_vision_available",
         "logging",
     ],
-    "utils.import_utils": ["requires_backends"],
-    "utils.kernel_config": ["KernelConfig"],
     "utils.quantization_config": [
         "AqlmConfig",
         "AutoRoundConfig",
@@ -251,18 +248,19 @@ _import_structure = {
         "EetqConfig",
         "FbgemmFp8Config",
         "FineGrainedFP8Config",
-        "FPQuantConfig",
         "GPTQConfig",
         "HiggsConfig",
         "HqqConfig",
         "Mxfp4Config",
         "QuantoConfig",
         "QuarkConfig",
+        "FPQuantConfig",
         "SpQRConfig",
         "TorchAoConfig",
         "VptqConfig",
     ],
     "video_utils": [],
+    "utils.kernel_config": ["KernelConfig"],
 }
 
 # tokenizers-backed objects
@@ -278,8 +276,8 @@ except OptionalDependencyNotAvailable:
 else:
     # Fast tokenizers structure
     _import_structure["tokenization_utils_tokenizers"] = [
-        "PreTrainedTokenizerFast",
         "TokenizersBackend",
+        "PreTrainedTokenizerFast",
     ]
 
 
@@ -358,6 +356,15 @@ else:
         "StaticSlidingWindowLayer",
         "QuantoQuantizedLayer",
         "HQQQuantizedLayer",
+        "SlidingWindowLayer",
+        "ChunkedSlidingLayer",
+        "HQQQuantizedCache",
+        "HybridCache",
+        "HybridChunkedCache",
+        "OffloadedCache",
+        "OffloadedStaticCache",
+        "QuantoQuantizedCache",
+        "SlidingWindowCache",
         "Cache",
         "DynamicCache",
         "EncoderDecoderCache",
@@ -376,13 +383,10 @@ else:
             "BayesianDetectorConfig",
             "BayesianDetectorModel",
             "ClassifierFreeGuidanceLogitsProcessor",
-            "ContinuousBatchingManager",
-            "ContinuousMixin",
             "EncoderNoRepeatNGramLogitsProcessor",
             "EncoderRepetitionPenaltyLogitsProcessor",
             "EosTokenCriteria",
             "EpsilonLogitsWarper",
-            "MinPLogitsWarper",
             "EtaLogitsWarper",
             "ExponentialDecayLengthPenalty",
             "ForcedBOSTokenLogitsProcessor",
@@ -396,6 +400,7 @@ else:
             "MaxTimeCriteria",
             "MinLengthLogitsProcessor",
             "MinNewTokensLengthLogitsProcessor",
+            "MinPLogitsWarper",
             "NoBadWordsLogitsProcessor",
             "NoRepeatNGramLogitsProcessor",
             "PrefixConstrainedLogitsProcessor",
@@ -427,15 +432,6 @@ else:
         "convert_and_export_with_cache",
     ]
 
-    _import_structure["core_model_loading"] = [
-        "Chunk",
-        "Concatenate",
-        "ConversionOps",
-        "MergeModulelist",
-        "PermuteForRope",
-        "SplitModulelist",
-        "WeightConverter",
-    ]
     _import_structure["modeling_flash_attention_utils"] = []
     _import_structure["modeling_layers"] = ["GradientCheckpointingLayer"]
     _import_structure["modeling_outputs"] = []
@@ -468,12 +464,20 @@ else:
 if TYPE_CHECKING:
     # All modeling imports
     from .cache_utils import Cache as Cache
+    from .cache_utils import ChunkedSlidingLayer as ChunkedSlidingLayer
     from .cache_utils import DynamicCache as DynamicCache
     from .cache_utils import DynamicLayer as DynamicLayer
     from .cache_utils import EncoderDecoderCache as EncoderDecoderCache
+    from .cache_utils import HQQQuantizedCache as HQQQuantizedCache
     from .cache_utils import HQQQuantizedLayer as HQQQuantizedLayer
+    from .cache_utils import HybridCache as HybridCache
+    from .cache_utils import OffloadedCache as OffloadedCache
+    from .cache_utils import OffloadedStaticCache as OffloadedStaticCache
     from .cache_utils import QuantizedCache as QuantizedCache
+    from .cache_utils import QuantoQuantizedCache as QuantoQuantizedCache
     from .cache_utils import QuantoQuantizedLayer as QuantoQuantizedLayer
+    from .cache_utils import SlidingWindowCache as SlidingWindowCache
+    from .cache_utils import SlidingWindowLayer as SlidingWindowLayer
     from .cache_utils import StaticCache as StaticCache
     from .cache_utils import StaticLayer as StaticLayer
     from .cache_utils import StaticSlidingWindowLayer as StaticSlidingWindowLayer
@@ -481,13 +485,6 @@ if TYPE_CHECKING:
     from .configuration_utils import PretrainedConfig as PretrainedConfig
     from .convert_slow_tokenizer import SLOW_TO_FAST_CONVERTERS as SLOW_TO_FAST_CONVERTERS
     from .convert_slow_tokenizer import convert_slow_tokenizer as convert_slow_tokenizer
-    from .core_model_loading import Chunk as Chunk
-    from .core_model_loading import Concatenate as Concatenate
-    from .core_model_loading import ConversionOps as ConversionOps
-    from .core_model_loading import MergeModulelist as MergeModulelist
-    from .core_model_loading import PermuteForRope as PermuteForRope
-    from .core_model_loading import SplitModulelist as SplitModulelist
-    from .core_model_loading import WeightConverter as WeightConverter
 
     # Data
     from .data import DataProcessor as DataProcessor
@@ -539,8 +536,6 @@ if TYPE_CHECKING:
     from .generation import BayesianDetectorModel as BayesianDetectorModel
     from .generation import ClassifierFreeGuidanceLogitsProcessor as ClassifierFreeGuidanceLogitsProcessor
     from .generation import CompileConfig as CompileConfig
-    from .generation import ContinuousBatchingManager as ContinuousBatchingManager
-    from .generation import ContinuousMixin as ContinuousMixin
     from .generation import EncoderNoRepeatNGramLogitsProcessor as EncoderNoRepeatNGramLogitsProcessor
     from .generation import EncoderRepetitionPenaltyLogitsProcessor as EncoderRepetitionPenaltyLogitsProcessor
     from .generation import EosTokenCriteria as EosTokenCriteria
@@ -610,7 +605,8 @@ if TYPE_CHECKING:
     from .masking_utils import AttentionMaskInterface as AttentionMaskInterface
     from .model_debugging_utils import model_addition_debugger_context as model_addition_debugger_context
 
-    # Models
+    # Model Cards
+    from .modelcard import ModelCard as ModelCard
     from .modeling_layers import GradientCheckpointingLayer as GradientCheckpointingLayer
     from .modeling_rope_utils import ROPE_INIT_FUNCTIONS as ROPE_INIT_FUNCTIONS
     from .modeling_rope_utils import RopeParameters as RopeParameters
@@ -655,6 +651,7 @@ if TYPE_CHECKING:
     from .pipelines import ImageSegmentationPipeline as ImageSegmentationPipeline
     from .pipelines import ImageTextToTextPipeline as ImageTextToTextPipeline
     from .pipelines import ImageToImagePipeline as ImageToImagePipeline
+    from .pipelines import ImageToTextPipeline as ImageToTextPipeline
     from .pipelines import JsonPipelineDataFormat as JsonPipelineDataFormat
     from .pipelines import KeypointMatchingPipeline as KeypointMatchingPipeline
     from .pipelines import MaskGenerationPipeline as MaskGenerationPipeline
@@ -664,11 +661,14 @@ if TYPE_CHECKING:
     from .pipelines import Pipeline as Pipeline
     from .pipelines import PipelineDataFormat as PipelineDataFormat
     from .pipelines import QuestionAnsweringPipeline as QuestionAnsweringPipeline
+    from .pipelines import SummarizationPipeline as SummarizationPipeline
     from .pipelines import TableQuestionAnsweringPipeline as TableQuestionAnsweringPipeline
+    from .pipelines import Text2TextGenerationPipeline as Text2TextGenerationPipeline
     from .pipelines import TextClassificationPipeline as TextClassificationPipeline
     from .pipelines import TextGenerationPipeline as TextGenerationPipeline
     from .pipelines import TextToAudioPipeline as TextToAudioPipeline
     from .pipelines import TokenClassificationPipeline as TokenClassificationPipeline
+    from .pipelines import TranslationPipeline as TranslationPipeline
     from .pipelines import VideoClassificationPipeline as VideoClassificationPipeline
     from .pipelines import VisualQuestionAnsweringPipeline as VisualQuestionAnsweringPipeline
     from .pipelines import ZeroShotAudioClassificationPipeline as ZeroShotAudioClassificationPipeline
@@ -741,7 +741,6 @@ if TYPE_CHECKING:
     from .utils import is_torch_npu_available as is_torch_npu_available
     from .utils import is_torch_xla_available as is_torch_xla_available
     from .utils import is_torch_xpu_available as is_torch_xpu_available
-    from .utils.import_utils import requires_backends
     from .utils.kernel_config import KernelConfig as KernelConfig
 
     # Quantization config
@@ -765,6 +764,8 @@ if TYPE_CHECKING:
     from .utils.quantization_config import VptqConfig as VptqConfig
     from .video_processing_utils import BaseVideoProcessor as BaseVideoProcessor
 else:
+    import sys
+
     _import_structure = {k: set(v) for k, v in _import_structure.items()}
 
     import_structure = define_import_structure(Path(__file__).parent / "models", prefix="models")
@@ -778,26 +779,6 @@ else:
         extra_objects={"__version__": __version__},
     )
 
-    def _create_tokenization_alias(alias: str, target: str) -> None:
-        """
-        Lazily redirect legacy tokenization module paths to their replacements without importing heavy deps.
-        """
-
-        module = types.ModuleType(alias)
-        module.__doc__ = f"Alias module for backward compatibility with `{target}`."
-
-        def _get_target():
-            return importlib.import_module(target, __name__)
-
-        module.__getattr__ = lambda name: getattr(_get_target(), name)
-        module.__dir__ = lambda: dir(_get_target())
-
-        sys.modules[alias] = module
-        setattr(sys.modules[__name__], alias.rsplit(".", 1)[-1], module)
-
-    _create_tokenization_alias(f"{__name__}.tokenization_utils_fast", ".tokenization_utils_tokenizers")
-    _create_tokenization_alias(f"{__name__}.tokenization_utils", ".tokenization_utils_sentencepiece")
-
 
 if not is_torch_available():
     logger.warning_advice(

transformers/activations.py

@@ -205,7 +205,7 @@ class LaplaceActivation(nn.Module):
 
 class ReLUSquaredActivation(nn.Module):
     """
-    Applies the relu^2 activation introduced in https://huggingface.co/papers/2109.08668
+    Applies the relu^2 activation introduced in https://huggingface.co/papers/2109.08668v2
     """
 
     def forward(self, input):

transformers/audio_utils.py

@@ -23,7 +23,7 @@ import os
 import warnings
 from collections.abc import Sequence
 from io import BytesIO
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import httpx
 import numpy as np
@@ -57,7 +57,7 @@ if is_torchcodec_available():
 AudioInput = Union[np.ndarray, "torch.Tensor", Sequence[np.ndarray], Sequence["torch.Tensor"]]
 
 
-def load_audio(audio: str | np.ndarray, sampling_rate=16000, timeout=None) -> np.ndarray:
+def load_audio(audio: Union[str, np.ndarray], sampling_rate=16000, timeout=None) -> np.ndarray:
     """
     Loads `audio` to an np.ndarray object.
 
@@ -77,7 +77,7 @@ def load_audio(audio: str | np.ndarray, sampling_rate=16000, timeout=None) -> np
         # Try to load with `torchcodec` but do not enforce users to install it. If not found
         # fallback to `librosa`. If using an audio-only model, most probably `torchcodec` won't be
         # needed. Do not raise any errors if not installed or versions do not match
-        if is_torchcodec_available() and version.parse("0.3.0") <= TORCHCODEC_VERSION:
+        if is_torchcodec_available() and TORCHCODEC_VERSION >= version.parse("0.3.0"):
             audio = load_audio_torchcodec(audio, sampling_rate=sampling_rate)
         else:
             audio = load_audio_librosa(audio, sampling_rate=sampling_rate, timeout=timeout)
@@ -88,7 +88,7 @@ def load_audio(audio: str | np.ndarray, sampling_rate=16000, timeout=None) -> np
     return audio
 
 
-def load_audio_torchcodec(audio: str | np.ndarray, sampling_rate=16000) -> np.ndarray:
+def load_audio_torchcodec(audio: Union[str, np.ndarray], sampling_rate=16000) -> np.ndarray:
     """
     Loads `audio` to an np.ndarray object using `torchcodec`.
 
@@ -112,7 +112,7 @@ def load_audio_torchcodec(audio: str | np.ndarray, sampling_rate=16000) -> np.nd
     return audio
 
 
-def load_audio_librosa(audio: str | np.ndarray, sampling_rate=16000, timeout=None) -> np.ndarray:
+def load_audio_librosa(audio: Union[str, np.ndarray], sampling_rate=16000, timeout=None) -> np.ndarray:
     """
     Loads `audio` to an np.ndarray object using `librosa`.
 
@@ -143,10 +143,10 @@ def load_audio_librosa(audio: str | np.ndarray, sampling_rate=16000, timeout=Non
 def load_audio_as(
     audio: str,
     return_format: str,
-    timeout: int | None = None,
+    timeout: Optional[int] = None,
     force_mono: bool = False,
-    sampling_rate: int | None = None,
-) -> str | dict[str, Any] | io.BytesIO | None:
+    sampling_rate: Optional[int] = None,
+) -> Union[str, dict[str, Any], io.BytesIO, None]:
     """
     Load audio from either a local file path or URL and return in specified format.
 
@@ -166,6 +166,7 @@ def load_audio_as(
             - `dict`: Dictionary with 'data' (base64 encoded audio data) and 'format' keys (if return_format="dict")
             - `io.BytesIO`: BytesIO object containing audio data (if return_format="buffer")
     """
+    # TODO: @eustlb, we actually don't need librosa but soxr is installed with librosa
     requires_backends(load_audio_as, ["librosa"])
 
     if return_format not in ["base64", "dict", "buffer"]:
@@ -239,7 +240,7 @@ def is_valid_list_of_audio(audio):
 
 
 def make_list_of_audio(
-    audio: list[AudioInput] | AudioInput,
+    audio: Union[list[AudioInput], AudioInput],
 ) -> AudioInput:
     """
     Ensure that the output is a list of audio.
@@ -260,7 +261,7 @@ def make_list_of_audio(
     raise ValueError("Invalid input type. Must be a single audio or a list of audio")
 
 
-def hertz_to_mel(freq: float | np.ndarray, mel_scale: str = "htk") -> float | np.ndarray:
+def hertz_to_mel(freq: Union[float, np.ndarray], mel_scale: str = "htk") -> Union[float, np.ndarray]:
     """
     Convert frequency from hertz to mels.
 
@@ -296,7 +297,7 @@ def hertz_to_mel(freq: float | np.ndarray, mel_scale: str = "htk") -> float | np
     return mels
 
 
-def mel_to_hertz(mels: float | np.ndarray, mel_scale: str = "htk") -> float | np.ndarray:
+def mel_to_hertz(mels: Union[float, np.ndarray], mel_scale: str = "htk") -> Union[float, np.ndarray]:
     """
     Convert frequency from mels to hertz.
 
@@ -332,7 +333,7 @@ def mel_to_hertz(mels: float | np.ndarray, mel_scale: str = "htk") -> float | np
     return freq
 
 
-def hertz_to_octave(freq: float | np.ndarray, tuning: float = 0.0, bins_per_octave: int = 12):
+def hertz_to_octave(freq: Union[float, np.ndarray], tuning: float = 0.0, bins_per_octave: int = 12):
     """
     Convert frequency from hertz to fractional octave numbers.
     Adapted from *librosa*.
@@ -380,8 +381,8 @@ def chroma_filter_bank(
     num_chroma: int,
     sampling_rate: int,
     tuning: float = 0.0,
-    power: float | None = 2.0,
-    weighting_parameters: tuple[float, float] | None = (5.0, 2.0),
+    power: Optional[float] = 2.0,
+    weighting_parameters: Optional[tuple[float, float]] = (5.0, 2.0),
     start_at_c_chroma: bool = True,
 ):
     """
@@ -456,7 +457,7 @@ def mel_filter_bank(
     min_frequency: float,
     max_frequency: float,
     sampling_rate: int,
-    norm: str | None = None,
+    norm: Optional[str] = None,
     mel_scale: str = "htk",
     triangularize_in_mel_space: bool = False,
 ) -> np.ndarray:
@@ -561,7 +562,7 @@ def window_function(
     window_length: int,
     name: str = "hann",
     periodic: bool = True,
-    frame_length: int | None = None,
+    frame_length: Optional[int] = None,
     center: bool = True,
 ) -> np.ndarray:
     """
@@ -626,19 +627,19 @@ def spectrogram(
     window: np.ndarray,
     frame_length: int,
     hop_length: int,
-    fft_length: int | None = None,
-    power: float | None = 1.0,
+    fft_length: Optional[int] = None,
+    power: Optional[float] = 1.0,
     center: bool = True,
     pad_mode: str = "reflect",
     onesided: bool = True,
     dither: float = 0.0,
-    preemphasis: float | None = None,
-    mel_filters: np.ndarray | None = None,
+    preemphasis: Optional[float] = None,
+    mel_filters: Optional[np.ndarray] = None,
     mel_floor: float = 1e-10,
-    log_mel: str | None = None,
+    log_mel: Optional[str] = None,
     reference: float = 1.0,
     min_value: float = 1e-10,
-    db_range: float | None = None,
+    db_range: Optional[float] = None,
     remove_dc_offset: bool = False,
     dtype: np.dtype = np.float32,
 ) -> np.ndarray:
@@ -837,19 +838,19 @@ def spectrogram_batch(
     window: np.ndarray,
     frame_length: int,
     hop_length: int,
-    fft_length: int | None = None,
-    power: float | None = 1.0,
+    fft_length: Optional[int] = None,
+    power: Optional[float] = 1.0,
     center: bool = True,
     pad_mode: str = "reflect",
     onesided: bool = True,
     dither: float = 0.0,
-    preemphasis: float | None = None,
-    mel_filters: np.ndarray | None = None,
+    preemphasis: Optional[float] = None,
+    mel_filters: Optional[np.ndarray] = None,
     mel_floor: float = 1e-10,
-    log_mel: str | None = None,
+    log_mel: Optional[str] = None,
     reference: float = 1.0,
     min_value: float = 1e-10,
-    db_range: float | None = None,
+    db_range: Optional[float] = None,
     remove_dc_offset: bool = False,
     dtype: np.dtype = np.float32,
 ) -> list[np.ndarray]:
@@ -1047,7 +1048,7 @@ def power_to_db(
     spectrogram: np.ndarray,
     reference: float = 1.0,
     min_value: float = 1e-10,
-    db_range: float | None = None,
+    db_range: Optional[float] = None,
 ) -> np.ndarray:
     """
     Converts a power spectrogram to the decibel scale. This computes `10 * log10(spectrogram / reference)`, using basic
@@ -1098,7 +1099,7 @@ def power_to_db_batch(
     spectrogram: np.ndarray,
     reference: float = 1.0,
     min_value: float = 1e-10,
-    db_range: float | None = None,
+    db_range: Optional[float] = None,
 ) -> np.ndarray:
     """
     Converts a batch of power spectrograms to the decibel scale. This computes `10 * log10(spectrogram / reference)`,
@@ -1147,7 +1148,7 @@ def amplitude_to_db(
     spectrogram: np.ndarray,
     reference: float = 1.0,
     min_value: float = 1e-5,
-    db_range: float | None = None,
+    db_range: Optional[float] = None,
 ) -> np.ndarray:
     """
     Converts an amplitude spectrogram to the decibel scale. This computes `20 * log10(spectrogram / reference)`, using
@@ -1193,7 +1194,7 @@ def amplitude_to_db(
 
 
 def amplitude_to_db_batch(
-    spectrogram: np.ndarray, reference: float = 1.0, min_value: float = 1e-5, db_range: float | None = None
+    spectrogram: np.ndarray, reference: float = 1.0, min_value: float = 1e-5, db_range: Optional[float] = None
 ) -> np.ndarray:
     """
     Converts a batch of amplitude spectrograms to the decibel scale. This computes `20 * log10(spectrogram / reference)`,