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

transformers/utils/doc.py

@@ -677,6 +677,27 @@ AUDIO_FRAME_CLASSIFICATION_SAMPLE = PT_SPEECH_FRAME_CLASS_SAMPLE
 AUDIO_XVECTOR_SAMPLE = PT_SPEECH_XVECTOR_SAMPLE
 
 
+IMAGE_TO_TEXT_SAMPLE = r"""
+    Example:
+
+    ```python
+    >>> from PIL import Image
+    >>> import requests
+    >>> from transformers import AutoProcessor, {model_class}
+
+    >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
+    >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+    >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+    >>> image = Image.open(requests.get(url, stream=True).raw)
+
+    >>> inputs = processor(images=image, return_tensors="pt")
+
+    >>> outputs = model(**inputs)
+    ```
+"""
+
+
 DEPTH_ESTIMATION_SAMPLE = r"""
     Example:
 
@@ -684,12 +705,10 @@ DEPTH_ESTIMATION_SAMPLE = r"""
     >>> from transformers import AutoImageProcessor, {model_class}
     >>> import torch
     >>> from PIL import Image
-    >>> import httpx
-        >>> from io import BytesIO
+    >>> import requests
 
     >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    >>> with httpx.stream("GET", url) as response:
-    ...     image = Image.open(BytesIO(response.read())).convert("RGB")
+    >>> image = Image.open(requests.get(url, stream=True).raw)
 
     >>> processor = AutoImageProcessor.from_pretrained("{checkpoint}")
     >>> model = {model_class}.from_pretrained("{checkpoint}")
@@ -823,6 +842,14 @@ OBJECT_DETECTION_SAMPLE = r"""
 QUESTION_ANSWERING_SAMPLE = PT_QUESTION_ANSWERING_SAMPLE
 
 
+TEXT2TEXT_GENERATION_SAMPLE = r"""
+    Example:
+
+    ```python
+    ```
+"""
+
+
 TEXT_CLASSIFICATION_SAMPLE = PT_SEQUENCE_CLASSIFICATION_SAMPLE
 
 
@@ -856,6 +883,7 @@ IMAGE_TEXT_TO_TEXT_GENERATION_SAMPLE = r"""
 
     ```python
     >>> from PIL import Image
+    >>> import requests
     >>> from transformers import AutoProcessor, {model_class}
 
     >>> model = {model_class}.from_pretrained("{checkpoint}")
@@ -893,6 +921,7 @@ PIPELINE_TASKS_TO_SAMPLE_DOCSTRINGS = OrderedDict(
         ("audio-classification", AUDIO_CLASSIFICATION_SAMPLE),
         ("audio-xvector", AUDIO_XVECTOR_SAMPLE),
         ("image-text-to-text", IMAGE_TEXT_TO_TEXT_GENERATION_SAMPLE),
+        ("image-to-text", IMAGE_TO_TEXT_SAMPLE),
         ("visual-question-answering", VISUAL_QUESTION_ANSWERING_SAMPLE),
         ("depth-estimation", DEPTH_ESTIMATION_SAMPLE),
         ("video-classification", VIDEO_CLASSIFICATION_SAMPLE),
@@ -907,6 +936,7 @@ PIPELINE_TASKS_TO_SAMPLE_DOCSTRINGS = OrderedDict(
         ("table-question-answering", TABLE_QUESTION_ANSWERING_SAMPLE),
         ("document-question-answering", DOCUMENT_QUESTION_ANSWERING_SAMPLE),
         ("question-answering", QUESTION_ANSWERING_SAMPLE),
+        ("text2text-generation", TEXT2TEXT_GENERATION_SAMPLE),
         ("next-sentence-prediction", NEXT_SENTENCE_PREDICTION_SAMPLE),
         ("multiple-choice", MULTIPLE_CHOICE_SAMPLE),
         ("text-classification", TEXT_CLASSIFICATION_SAMPLE),
@@ -931,6 +961,7 @@ MODELS_TO_PIPELINE = OrderedDict(
         ("MODEL_FOR_AUDIO_XVECTOR_MAPPING_NAMES", "audio-xvector"),
         # Vision
         ("MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES", "image-text-to-text"),
+        ("MODEL_FOR_VISION_2_SEQ_MAPPING_NAMES", "image-to-text"),
         ("MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING_NAMES", "visual-question-answering"),
         ("MODEL_FOR_DEPTH_ESTIMATION_MAPPING_NAMES", "depth-estimation"),
         ("MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING_NAMES", "video-classification"),
@@ -946,6 +977,7 @@ MODELS_TO_PIPELINE = OrderedDict(
         ("MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING_NAMES", "table-question-answering"),
         ("MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING_NAMES", "document-question-answering"),
         ("MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES", "question-answering"),
+        ("MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES", "text2text-generation"),
         ("MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES", "next-sentence-prediction"),
         ("MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES", "multiple-choice"),
         ("MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES", "text-classification"),

transformers/utils/dummy_pt_objects.py

@@ -23,6 +23,34 @@ class EncoderDecoderCache(metaclass=DummyObject):
         requires_backends(self, ["torch"])
 
 
+class HQQQuantizedCache(metaclass=DummyObject):
+    _backends = ["torch"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch"])
+
+
+class HybridCache(metaclass=DummyObject):
+    _backends = ["torch"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch"])
+
+
+class OffloadedCache(metaclass=DummyObject):
+    _backends = ["torch"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch"])
+
+
+class OffloadedStaticCache(metaclass=DummyObject):
+    _backends = ["torch"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch"])
+
+
 class QuantizedCache(metaclass=DummyObject):
     _backends = ["torch"]
 
@@ -30,6 +58,20 @@ class QuantizedCache(metaclass=DummyObject):
         requires_backends(self, ["torch"])
 
 
+class QuantoQuantizedCache(metaclass=DummyObject):
+    _backends = ["torch"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch"])
+
+
+class SlidingWindowCache(metaclass=DummyObject):
+    _backends = ["torch"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch"])
+
+
 class StaticCache(metaclass=DummyObject):
     _backends = ["torch"]
 

transformers/utils/generic.py

@@ -21,7 +21,7 @@ import os
 import warnings
 from collections import OrderedDict, UserDict, defaultdict
 from collections.abc import Callable, Iterable, MutableMapping
-from contextlib import AbstractContextManager, ExitStack, nullcontext
+from contextlib import AbstractContextManager, ExitStack
 from dataclasses import dataclass, fields, is_dataclass
 from enum import Enum
 from functools import partial, wraps
@@ -42,7 +42,6 @@ _is_torch_available = False
 if is_torch_available():
     # required for @can_return_tuple decorator to work with torchdynamo
     import torch
-    from torch.types import _dtype
 
     from ..model_debugging_utils import model_addition_debugger_context
 
@@ -155,48 +154,6 @@ def is_torch_dtype(x):
     return isinstance(x, torch.dtype)
 
 
-def _is_tensor_or_array_like(value):
-    """
-    Check if a value is array-like (includes ragged arrays)
-    """
-    if is_numpy_array(value):
-        return True
-    if is_torch_tensor(value):
-        return True
-    if isinstance(value, (int, float, bool, np.number)):
-        return True
-
-    if isinstance(value, (list, tuple)):
-        if len(value) == 0:
-            # consider empty list or nested list as array-like
-            return True
-        return _is_tensor_or_array_like(value[0])
-
-    return False
-
-
-def maybe_autocast(
-    device_type: str,
-    dtype: Optional["_dtype"] = None,
-    enabled: bool = True,
-    cache_enabled: bool | None = None,
-):
-    """
-    Context manager that only autocasts if:
-
-    - `autocast` is already enabled in this context
-    - Or this call to `maybe_autocast` has `enabled=True`
-
-    This prevents `autocast` being added to the graph when it is effectively a no-op.
-    Which makes graph splitting in `torch.compile` more flexible as it removes the
-    requirement that partition IDs be monotonically increasing.
-    """
-    if torch.is_autocast_enabled(device_type) or enabled:
-        return torch.autocast(device_type, dtype=dtype, enabled=enabled, cache_enabled=cache_enabled)
-    else:
-        return nullcontext()
-
-
 def _is_mlx(x):
     import mlx.core as mx
 
@@ -210,31 +167,6 @@ def is_mlx_array(x):
     return False if not _is_mlx_available else _is_mlx(x)
 
 
-def is_flash_attention_requested(config=None, requested_attention_implementation: str | None = None):
-    """
-    Checks whether some flavor of flash attention is requested or not.
-
-    This is checked against one of the two arguments, i.e. either the `config` or the directly passed value
-    `requested_attention_implementation`. Otherwise, an error will be raised (ambiguity).
-
-    The different versions of flash attention are usually
-    - Implementations based on the original flash attention repo: https://github.com/Dao-AILab/flash-attention
-    - Kernels implementations such as: https://huggingface.co/kernels-community/vllm-flash-attn3
-    """
-    if config is not None and requested_attention_implementation is not None:
-        raise ValueError(
-            "Requested attention implementation is ambiguous: "
-            "Please pass either the config or the name of the attention implementation, not both."
-        )
-
-    if config is not None:
-        checked_attention_implementation = config._attn_implementation
-    else:
-        checked_attention_implementation = requested_attention_implementation
-
-    return "flash" in checked_attention_implementation
-
-
 def to_py_obj(obj):
     """
     Convert a PyTorch tensor, Numpy array or python list to a python list.
@@ -748,8 +680,6 @@ class TransformersKwargs(TypedDict, total=False):
             Maximum sequence length for query state.
         max_length_k (`int`, *optional*):
             Maximum sequence length for key state.
-        position_ids (`torch.LongTensor`, *optional*)
-            Indices of positions of each input sequence tokens.
     """
 
     num_items_in_batch: Optional["torch.Tensor"]
@@ -760,7 +690,6 @@ class TransformersKwargs(TypedDict, total=False):
     cu_seq_lens_k: Optional["torch.LongTensor"]
     max_length_q: int | None
     max_length_k: int | None
-    position_ids: Optional["torch.LongTensor"]
 
 
 def is_timm_config_dict(config_dict: dict[str, Any]) -> bool:
@@ -875,46 +804,34 @@ def check_model_inputs(func=None, *, tie_last_hidden_states=True):
     def wrapped_fn(func):
         @wraps(func)
         def wrapper(self, *args, **kwargs):
-            args_with_config_defaults = [
-                "use_cache",
-                "vision_feature_layer",
-                "vision_feature_select_strategy",
-                "vision_aspect_ratio",
-            ]
-            for arg_name in args_with_config_defaults:
-                arg_index = None
-                if arg_name in func.__code__.co_varnames:
-                    arg_index = func.__code__.co_varnames.index(arg_name) - 1  # -1 for self
-
-                if arg_index is not None and len(args) > arg_index and args[arg_index] is not None:
-                    arg_value = args[arg_index]
-                elif kwargs.get(arg_name) is not None:
-                    arg_value = kwargs[arg_name]
+            use_cache_arg_index = None
+            if "use_cache" in func.__code__.co_varnames:
+                use_cache_arg_index = func.__code__.co_varnames.index("use_cache") - 1  # -1 for self
+
+            if (
+                use_cache_arg_index is not None
+                and len(args) > use_cache_arg_index
+                and args[use_cache_arg_index] is not None
+            ):
+                use_cache = args[use_cache_arg_index]
+            elif kwargs.get("use_cache") is not None:
+                use_cache = kwargs["use_cache"]
+            else:
+                use_cache = getattr(self.config, "use_cache", None)
+
+            if use_cache is not None:
+                if getattr(self, "gradient_checkpointing", False) and self.training and use_cache:
+                    logger.warning_once(
+                        "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`."
+                    )
+                    use_cache = False
+
+                if use_cache_arg_index is not None and len(args) > use_cache_arg_index:
+                    args = list(args)
+                    args[use_cache_arg_index] = use_cache
+                    args = tuple(args)
                 else:
-                    arg_value = getattr(self.config, arg_name, None)
-
-                if arg_value is not None:
-                    # Arg-specific handling
-                    if arg_name == "use_cache":
-                        if getattr(self, "gradient_checkpointing", False) and self.training and arg_value:
-                            logger.warning_once(
-                                "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`."
-                            )
-                            arg_value = False
-                    elif arg_name == "vision_feature_select_strategy":
-                        valid_strategies = ["default", "full"]
-                        if arg_value not in valid_strategies:
-                            raise ValueError(
-                                f"`Unexpected select feature strategy: {arg_value}. "
-                                f"Please select from {valid_strategies}."
-                            )
-
-                    if arg_index is not None and len(args) > arg_index:
-                        args = list(args)
-                        args[arg_index] = arg_value
-                        args = tuple(args)
-                    else:
-                        kwargs[arg_name] = arg_value
+                    kwargs["use_cache"] = use_cache
 
             return_dict = kwargs.pop("return_dict", None)
             if return_dict is None:

transformers/utils/hub.py

@@ -37,7 +37,6 @@ from huggingface_hub import (
     create_repo,
     hf_hub_download,
     hf_hub_url,
-    is_offline_mode,
     list_repo_tree,
     snapshot_download,
     try_to_load_from_cache,
@@ -84,6 +83,13 @@ class DownloadKwargs(TypedDict, total=False):
     commit_hash: str | None
 
 
+def is_offline_mode():
+    # Import inside the function so test patches on `huggingface_hub.constants` are picked up.
+    from huggingface_hub import constants as hf_hub_constants
+
+    return hf_hub_constants.HF_HUB_OFFLINE
+
+
 # Determine default cache directory.
 # The best way to set the cache path is with the environment variable HF_HOME. For more details, check out this
 # documentation page: https://huggingface.co/docs/huggingface_hub/package_reference/environment_variables.
@@ -721,7 +727,8 @@ class PushToHubMixin:
         revision: str | None = None,
         create_pr: bool = False,
         # Serialization details
-        max_shard_size: int | str | None = "50GB",
+        max_shard_size: int | str | None = "5GB",
+        safe_serialization: bool = True,
         tags: list[str] | None = None,
     ) -> str:
         """
@@ -744,10 +751,13 @@ class PushToHubMixin:
                 Branch to push the uploaded files to.
             create_pr (`bool`, *optional*, defaults to `False`):
                 Whether or not to create a PR with the uploaded files or directly commit.
-            max_shard_size (`int` or `str`, *optional*, defaults to `"50GB"`):
+            max_shard_size (`int` or `str`, *optional*, defaults to `"5GB"`):
                 Only applicable for models. The maximum size for a checkpoint before being sharded. Checkpoints shard
                 will then be each of size lower than this size. If expressed as a string, needs to be digits followed
-                by a unit (like `"5MB"`).
+                by a unit (like `"5MB"`). We default it to `"5GB"` so that users can easily load models on free-tier
+                Google Colab instances without any CPU OOM issues.
+            safe_serialization (`bool`, *optional*, defaults to `True`):
+                Whether or not to convert the model weights in safetensors format for safer serialization.
             tags (`list[str]`, *optional*):
                 List of tags to push on the Hub.
 
@@ -773,7 +783,7 @@ class PushToHubMixin:
 
         with tempfile.TemporaryDirectory() as tmp_dir:
             # Save all files.
-            self.save_pretrained(tmp_dir, max_shard_size=max_shard_size)
+            self.save_pretrained(tmp_dir, max_shard_size=max_shard_size, safe_serialization=safe_serialization)
 
             # Update model card
             model_card.save(os.path.join(tmp_dir, "README.md"))