transformers 5.0.0rc2__py3-none-any.whl → 5.1.0__py3-none-any.whl

transformers/modelcard.py

@@ -13,13 +13,10 @@
 # limitations under the License.
 """Configuration base class and utilities."""
 
-import copy
-import json
 import os
-import warnings
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any
 
 import httpx
 import yaml
@@ -47,8 +44,6 @@ from .models.auto.modeling_auto import (
 )
 from .training_args import ParallelMode
 from .utils import (
-    MODEL_CARD_NAME,
-    cached_file,
     is_datasets_available,
     is_tokenizers_available,
     is_torch_available,
@@ -76,179 +71,6 @@ TASK_MAPPING = {
 logger = logging.get_logger(__name__)
 
 
-class ModelCard:
-    r"""
-    Structured Model Card class. Store model card as well as methods for loading/downloading/saving model cards.
-
-    Please read the following paper for details and explanation on the sections: "Model Cards for Model Reporting" by
-    Margaret Mitchell, Simone Wu, Andrew Zaldivar, Parker Barnes, Lucy Vasserman, Ben Hutchinson, Elena Spitzer,
-    Inioluwa Deborah Raji and Timnit Gebru for the proposal behind model cards. Link: https://huggingface.co/papers/1810.03993
-
-    Note: A model card can be loaded and saved to disk.
-    """
-
-    def __init__(self, **kwargs):
-        warnings.warn(
-            "The class `ModelCard` is deprecated and will be removed in version 5 of Transformers", FutureWarning
-        )
-        # Recommended attributes from https://huggingface.co/papers/1810.03993 (see papers)
-        self.model_details = kwargs.pop("model_details", {})
-        self.intended_use = kwargs.pop("intended_use", {})
-        self.factors = kwargs.pop("factors", {})
-        self.metrics = kwargs.pop("metrics", {})
-        self.evaluation_data = kwargs.pop("evaluation_data", {})
-        self.training_data = kwargs.pop("training_data", {})
-        self.quantitative_analyses = kwargs.pop("quantitative_analyses", {})
-        self.ethical_considerations = kwargs.pop("ethical_considerations", {})
-        self.caveats_and_recommendations = kwargs.pop("caveats_and_recommendations", {})
-
-        # Open additional attributes
-        for key, value in kwargs.items():
-            try:
-                setattr(self, key, value)
-            except AttributeError as err:
-                logger.error(f"Can't set {key} with value {value} for {self}")
-                raise err
-
-    def save_pretrained(self, save_directory_or_file):
-        """Save a model card object to the directory or file `save_directory_or_file`."""
-        if os.path.isdir(save_directory_or_file):
-            # If we save using the predefined names, we can load using `from_pretrained`
-            output_model_card_file = os.path.join(save_directory_or_file, MODEL_CARD_NAME)
-        else:
-            output_model_card_file = save_directory_or_file
-
-        self.to_json_file(output_model_card_file)
-        logger.info(f"Model card saved in {output_model_card_file}")
-
-    @classmethod
-    def from_pretrained(cls, pretrained_model_name_or_path, **kwargs):
-        r"""
-        Instantiate a [`ModelCard`] from a pre-trained model model card.
-
-        Parameters:
-            pretrained_model_name_or_path: either:
-
-                - a string, the *model id* of a pretrained model card hosted inside a model repo on huggingface.co.
-                - a path to a *directory* containing a model card file saved using the [`~ModelCard.save_pretrained`]
-                  method, e.g.: `./my_model_directory/`.
-                - a path or url to a saved model card JSON *file*, e.g.: `./my_model_directory/modelcard.json`.
-
-            cache_dir: (*optional*) string:
-                Path to a directory in which a downloaded pre-trained model card should be cached if the standard cache
-                should not be used.
-
-            kwargs: (*optional*) dict: key/value pairs with which to update the ModelCard object after loading.
-
-                - The values in kwargs of any keys which are model card attributes will be used to override the loaded
-                  values.
-                - Behavior concerning key/value pairs whose keys are *not* model card attributes is controlled by the
-                  *return_unused_kwargs* keyword parameter.
-
-            proxies: (*optional*) dict, default None:
-                A dictionary of proxy servers to use by protocol or endpoint, e.g.: {'http': 'foo.bar:3128',
-                'http://hostname': 'foo.bar:4012'}. The proxies are used on each request.
-
-            return_unused_kwargs: (*optional*) bool:
-
-                - If False, then this function returns just the final model card object.
-                - If True, then this functions returns a tuple *(model card, unused_kwargs)* where *unused_kwargs* is a
-                  dictionary consisting of the key/value pairs whose keys are not model card attributes: ie the part of
-                  kwargs which has not been used to update *ModelCard* and is otherwise ignored.
-
-        Examples:
-
-        ```python
-        # Download model card from huggingface.co and cache.
-        modelcard = ModelCard.from_pretrained("google-bert/bert-base-uncased")
-        # Model card was saved using *save_pretrained('./test/saved_model/')*
-        modelcard = ModelCard.from_pretrained("./test/saved_model/")
-        modelcard = ModelCard.from_pretrained("./test/saved_model/modelcard.json")
-        modelcard = ModelCard.from_pretrained("google-bert/bert-base-uncased", output_attentions=True, foo=False)
-        ```"""
-        cache_dir = kwargs.pop("cache_dir", None)
-        proxies = kwargs.pop("proxies", None)
-        return_unused_kwargs = kwargs.pop("return_unused_kwargs", False)
-        from_pipeline = kwargs.pop("_from_pipeline", None)
-
-        user_agent = {"file_type": "model_card"}
-        if from_pipeline is not None:
-            user_agent["using_pipeline"] = from_pipeline
-
-        is_local = os.path.isdir(pretrained_model_name_or_path)
-        if os.path.isfile(pretrained_model_name_or_path):
-            resolved_model_card_file = pretrained_model_name_or_path
-            is_local = True
-        else:
-            try:
-                # Load from URL or cache if already cached
-                resolved_model_card_file = cached_file(
-                    pretrained_model_name_or_path,
-                    filename=MODEL_CARD_NAME,
-                    cache_dir=cache_dir,
-                    proxies=proxies,
-                    user_agent=user_agent,
-                )
-                if is_local:
-                    logger.info(f"loading model card file {resolved_model_card_file}")
-                else:
-                    logger.info(f"loading model card file {MODEL_CARD_NAME} from cache at {resolved_model_card_file}")
-                # Load model card
-                modelcard = cls.from_json_file(resolved_model_card_file)
-
-            except (OSError, json.JSONDecodeError):
-                # We fall back on creating an empty model card
-                modelcard = cls()
-
-        # Update model card with kwargs if needed
-        to_remove = []
-        for key, value in kwargs.items():
-            if hasattr(modelcard, key):
-                setattr(modelcard, key, value)
-                to_remove.append(key)
-        for key in to_remove:
-            kwargs.pop(key, None)
-
-        logger.info(f"Model card: {modelcard}")
-        if return_unused_kwargs:
-            return modelcard, kwargs
-        else:
-            return modelcard
-
-    @classmethod
-    def from_dict(cls, json_object):
-        """Constructs a `ModelCard` from a Python dictionary of parameters."""
-        return cls(**json_object)
-
-    @classmethod
-    def from_json_file(cls, json_file):
-        """Constructs a `ModelCard` from a json file of parameters."""
-        with open(json_file, encoding="utf-8") as reader:
-            text = reader.read()
-        dict_obj = json.loads(text)
-        return cls(**dict_obj)
-
-    def __eq__(self, other):
-        return self.__dict__ == other.__dict__
-
-    def __repr__(self):
-        return str(self.to_json_string())
-
-    def to_dict(self):
-        """Serializes this instance to a Python dictionary."""
-        output = copy.deepcopy(self.__dict__)
-        return output
-
-    def to_json_string(self):
-        """Serializes this instance to a JSON string."""
-        return json.dumps(self.to_dict(), indent=2, sort_keys=True) + "\n"
-
-    def to_json_file(self, json_file_path):
-        """Save this instance to a json file."""
-        with open(json_file_path, "w", encoding="utf-8") as writer:
-            writer.write(self.to_json_string())
-
-
 AUTOGENERATED_TRAINER_COMMENT = """
 <!-- This model card has been generated automatically according to the information the Trainer had access to. You
 should probably proofread and complete it, then remove this comment. -->
@@ -352,19 +174,19 @@ def _get_mapping_values(mapping):
 @dataclass
 class TrainingSummary:
     model_name: str
-    language: Optional[Union[str, list[str]]] = None
-    license: Optional[str] = None
-    tags: Optional[Union[str, list[str]]] = None
-    finetuned_from: Optional[str] = None
-    tasks: Optional[Union[str, list[str]]] = None
-    dataset: Optional[Union[str, list[str]]] = None
-    dataset_tags: Optional[Union[str, list[str]]] = None
-    dataset_args: Optional[Union[str, list[str]]] = None
-    dataset_metadata: Optional[dict[str, Any]] = None
-    eval_results: Optional[dict[str, float]] = None
-    eval_lines: Optional[list[str]] = None
-    hyperparameters: Optional[dict[str, Any]] = None
-    source: Optional[str] = "trainer"
+    language: str | list[str] | None = None
+    license: str | None = None
+    tags: str | list[str] | None = None
+    finetuned_from: str | None = None
+    tasks: str | list[str] | None = None
+    dataset: str | list[str] | None = None
+    dataset_tags: str | list[str] | None = None
+    dataset_args: str | list[str] | None = None
+    dataset_metadata: dict[str, Any] | None = None
+    eval_results: dict[str, float] | None = None
+    eval_lines: list[str] | None = None
+    hyperparameters: dict[str, Any] | None = None
+    source: str | None = "trainer"
 
     def __post_init__(self):
         # Infer default license from the checkpoint used, if possible.

transformers/modeling_attn_mask_utils.py

@@ -18,7 +18,7 @@ and will be removed in the future.
 """
 
 from dataclasses import dataclass
-from typing import Optional, Union
+from typing import Union
 
 import torch
 
@@ -60,7 +60,7 @@ class AttentionMaskConverter:
     is_causal: bool
     sliding_window: int
 
-    def __init__(self, is_causal: bool, sliding_window: Optional[int] = None):
+    def __init__(self, is_causal: bool, sliding_window: int | None = None):
         self.is_causal = is_causal
         self.sliding_window = sliding_window
 
@@ -76,7 +76,7 @@ class AttentionMaskConverter:
         key_value_length: int,
         dtype: torch.dtype,
         device: Union[torch.device, "str"] = "cpu",
-    ) -> Optional[torch.Tensor]:
+    ) -> torch.Tensor | None:
         """
         Creates a causal 4D mask of (bsz, head_dim=1, query_length, key_value_length) shape and adds large negative
         bias to upper right hand triangular matrix (causal mask).
@@ -107,7 +107,7 @@ class AttentionMaskConverter:
         attention_mask_2d: torch.Tensor,
         query_length: int,
         dtype: torch.dtype,
-        key_value_length: Optional[int] = None,
+        key_value_length: int | None = None,
     ) -> torch.Tensor:
         """
         Converts 2D attention mask to 4D attention mask by expanding mask to (bsz, head_dim=1, query_length,
@@ -155,7 +155,7 @@ class AttentionMaskConverter:
         dtype: torch.dtype,
         device: torch.device,
         past_key_values_length: int = 0,
-        sliding_window: Optional[int] = None,
+        sliding_window: int | None = None,
     ):
         """
         Make causal mask used for bi-directional self-attention.
@@ -184,7 +184,7 @@ class AttentionMaskConverter:
         return mask[None, None, :, :].expand(bsz, 1, tgt_len, tgt_len + past_key_values_length)
 
     @staticmethod
-    def _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):
+    def _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: int | None = None):
         """
         Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.
         """
@@ -248,10 +248,10 @@ class AttentionMaskConverter:
 
     @staticmethod
     def _ignore_causal_mask_sdpa(
-        attention_mask: Optional[torch.Tensor],
+        attention_mask: torch.Tensor | None,
         inputs_embeds: torch.Tensor,
         past_key_values_length: int,
-        sliding_window: Optional[int] = None,
+        sliding_window: int | None = None,
         is_training: bool = False,
     ) -> bool:
         """
@@ -306,11 +306,11 @@ class AttentionMaskConverter:
 
 
 def _prepare_4d_causal_attention_mask(
-    attention_mask: Optional[torch.Tensor],
-    input_shape: Union[torch.Size, tuple, list],
+    attention_mask: torch.Tensor | None,
+    input_shape: torch.Size | tuple | list,
     inputs_embeds: torch.Tensor,
     past_key_values_length: int,
-    sliding_window: Optional[int] = None,
+    sliding_window: int | None = None,
 ):
     """
     Creates a causal 4D mask of shape `(batch_size, 1, query_length, key_value_length)` from a 2D mask of shape
@@ -359,11 +359,11 @@ def _prepare_4d_causal_attention_mask(
 
 # Adapted from _prepare_4d_causal_attention_mask
 def _prepare_4d_causal_attention_mask_for_sdpa(
-    attention_mask: Optional[torch.Tensor],
-    input_shape: Union[torch.Size, tuple, list],
+    attention_mask: torch.Tensor | None,
+    input_shape: torch.Size | tuple | list,
     inputs_embeds: torch.Tensor,
     past_key_values_length: int,
-    sliding_window: Optional[int] = None,
+    sliding_window: int | None = None,
 ):
     """
     Prepares the correct `attn_mask` argument to be used by `torch.nn.functional.scaled_dot_product_attention`.
@@ -416,7 +416,7 @@ def _prepare_4d_causal_attention_mask_for_sdpa(
     return expanded_4d_mask
 
 
-def _prepare_4d_attention_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):
+def _prepare_4d_attention_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: int | None = None):
     """
     Creates a non-causal 4D mask of shape `(batch_size, 1, query_length, key_value_length)` from a 2D mask of shape
     `(batch_size, key_value_length)`
@@ -432,7 +432,7 @@ def _prepare_4d_attention_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len:
     return AttentionMaskConverter._expand_mask(mask=mask, dtype=dtype, tgt_len=tgt_len)
 
 
-def _prepare_4d_attention_mask_for_sdpa(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):
+def _prepare_4d_attention_mask_for_sdpa(mask: torch.Tensor, dtype: torch.dtype, tgt_len: int | None = None):
     """
     Creates a non-causal 4D mask of shape `(batch_size, 1, query_length, key_value_length)` from a 2D mask of shape
     `(batch_size, key_value_length)`
@@ -456,12 +456,12 @@ def _prepare_4d_attention_mask_for_sdpa(mask: torch.Tensor, dtype: torch.dtype,
 
 
 def _create_4d_causal_attention_mask(
-    input_shape: Union[torch.Size, tuple, list],
+    input_shape: torch.Size | tuple | list,
     dtype: torch.dtype,
     device: torch.device,
     past_key_values_length: int = 0,
-    sliding_window: Optional[int] = None,
-) -> Optional[torch.Tensor]:
+    sliding_window: int | None = None,
+) -> torch.Tensor | None:
     """
     Creates a causal 4D mask of shape `(batch_size, 1, query_length, key_value_length)`
 

transformers/modeling_flash_attention_utils.py

@@ -15,7 +15,7 @@ import inspect
 import os
 from collections.abc import Callable
 from functools import partial
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 import torch
 import torch.nn.functional as F
@@ -71,7 +71,7 @@ _hf_api_to_flash_mapping = {
 }
 
 
-def _lazy_imports(implementation: Optional[str], attention_wrapper: Optional[Callable] = None):
+def _lazy_imports(implementation: str | None, attention_wrapper: Callable | None = None):
     """
     Lazy loads the respective flash attention implementations.
 
@@ -147,7 +147,7 @@ def _lazy_define_process_function(flash_function):
     return partial(_process_flash_attention_kwargs, supports_mapping=supports_mapping)
 
 
-def lazy_import_flash_attention(implementation: Optional[str], attention_wrapper: Optional[Callable] = None):
+def lazy_import_flash_attention(implementation: str | None, attention_wrapper: Callable | None = None):
     """
     Lazily import flash attention and return the respective functions + flags.
 
@@ -168,7 +168,7 @@ def lazy_import_flash_attention(implementation: Optional[str], attention_wrapper
     return (_flash_fn, _flash_varlen_fn, _pad_fn, _unpad_fn), _process_flash_kwargs_fn
 
 
-def lazy_import_paged_flash_attention(implementation: Optional[str]):
+def lazy_import_paged_flash_attention(implementation: str | None):
     """
     Same as `lazy_import_flash_attention` but explicitly wrapping it with the paged implementation.
     """
@@ -453,7 +453,7 @@ def fa_peft_integration_check(
     q: torch.Tensor,
     k: torch.Tensor,
     v: torch.Tensor,
-    target_dtype: Optional[torch.dtype] = None,
+    target_dtype: torch.dtype | None = None,
 ):
     """
     PEFT usually casts the layer norms in float32 for training stability reasons
@@ -482,10 +482,10 @@ class FlashAttentionKwargs(TypedDict, total=False):
             Maximum sequence length for key state.
     """
 
-    cu_seq_lens_q: Optional[torch.LongTensor]
-    cu_seq_lens_k: Optional[torch.LongTensor]
-    max_length_q: Optional[int]
-    max_length_k: Optional[int]
+    cu_seq_lens_q: torch.LongTensor | None
+    cu_seq_lens_k: torch.LongTensor | None
+    max_length_q: int | None
+    max_length_k: int | None
 
 
 def _process_flash_attention_kwargs(
@@ -493,13 +493,13 @@ def _process_flash_attention_kwargs(
     key_length: int,
     is_causal: bool,
     dropout: float = 0.0,
-    softmax_scale: Optional[float] = None,
-    sliding_window: Optional[int] = None,
+    softmax_scale: float | None = None,
+    sliding_window: int | None = None,
     use_top_left_mask: bool = False,
-    softcap: Optional[float] = None,
-    deterministic: Optional[bool] = None,
-    s_aux: Optional[torch.Tensor] = None,
-    supports_mapping: Optional[dict[str, bool]] = None,
+    softcap: float | None = None,
+    deterministic: bool | None = None,
+    s_aux: torch.Tensor | None = None,
+    supports_mapping: dict[str, bool] | None = None,
     **kwargs,
 ):
     """
@@ -545,8 +545,7 @@ def _process_flash_attention_kwargs(
         # The flash attention API sets inclusive boundaries, i.e. (4, 0) would take 4 tokens to the left
         # and the current token for a total size of 5. However, we usually define our window sizes by
         # their total window size (when causal). Encoder models as of now seldom use SWA and when they
-        # do, they have a custom workaround (e.g. ModernBERT) which would align with this symmetric logic, i.e.
-        # for a total of `2*sliding_window + 1`.
+        # do, they must align with this symmetric logic, i.e. for a total of `2*sliding_window + 1`.
         flash_kwargs["window_size"] = (sliding_window - 1, sliding_window - 1)
 
     if supports_mapping["deterministic"]:
@@ -568,22 +567,22 @@ def _flash_attention_forward(
     query_states: torch.Tensor,
     key_states: torch.Tensor,
     value_states: torch.Tensor,
-    attention_mask: Optional[torch.Tensor],
+    attention_mask: torch.Tensor | None,
     query_length: int,
     is_causal: bool,
     dropout: float = 0.0,
-    position_ids: Optional[torch.Tensor] = None,
-    softmax_scale: Optional[float] = None,
-    sliding_window: Optional[int] = None,
+    position_ids: torch.Tensor | None = None,
+    softmax_scale: float | None = None,
+    sliding_window: int | None = None,
     use_top_left_mask: bool = False,
-    softcap: Optional[float] = None,
-    deterministic: Optional[bool] = None,
-    cu_seq_lens_q: Optional[torch.LongTensor] = None,
-    cu_seq_lens_k: Optional[torch.LongTensor] = None,
-    max_length_q: Optional[int] = None,
-    max_length_k: Optional[int] = None,
-    target_dtype: Optional[torch.dtype] = None,
-    attn_implementation: Optional[str] = None,
+    softcap: float | None = None,
+    deterministic: bool | None = None,
+    cu_seq_lens_q: torch.LongTensor | None = None,
+    cu_seq_lens_k: torch.LongTensor | None = None,
+    max_length_q: int | None = None,
+    max_length_k: int | None = None,
+    target_dtype: torch.dtype | None = None,
+    attn_implementation: str | None = None,
     **kwargs,
 ):
     """

transformers/modeling_gguf_pytorch_utils.py

@@ -14,7 +14,7 @@
 # limitations under the License.
 
 import re
-from typing import NamedTuple, Optional
+from typing import NamedTuple
 
 import numpy as np
 from tqdm.auto import tqdm
@@ -103,7 +103,7 @@ class LlamaTensorProcessor(TensorProcessor):
         return GGUFTensor(weights, name, {})
 
     def _reverse_permute_weights(
-        self, weights: np.ndarray, n_head: int, num_kv_heads: Optional[int] = None
+        self, weights: np.ndarray, n_head: int, num_kv_heads: int | None = None
     ) -> np.ndarray:
         # Original permutation implementation
         # https://github.com/ggerganov/llama.cpp/blob/a38b884c6c4b0c256583acfaaabdf556c62fabea/convert_hf_to_gguf.py#L1402-L1408
@@ -326,8 +326,8 @@ def read_field(reader, field):
 def get_gguf_hf_weights_map(
     hf_model,
     processor: TensorProcessor,
-    model_type: Optional[str] = None,
-    num_layers: Optional[int] = None,
+    model_type: str | None = None,
+    num_layers: int | None = None,
     qual_name: str = "",
 ):
     """
@@ -481,7 +481,7 @@ def load_gguf_checkpoint(gguf_checkpoint_path, return_tensors=False, model_to_lo
     # tie_word_embeddings is true otherwise false
     exceptions = ["falcon", "bloom"]
     parsed_parameters["config"]["tie_word_embeddings"] = (
-        all("output.weight" != tensor.name for tensor in reader.tensors) or architecture in exceptions
+        all(tensor.name != "output.weight" for tensor in reader.tensors) or architecture in exceptions
     )
 
     # Set GGUF-specific default values

transformers/modeling_layers.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from functools import partial
-from typing import Optional
 
 import torch
 import torch.nn as nn
@@ -112,13 +111,13 @@ class GenericForSequenceClassification:
     @auto_docstring
     def forward(
         self,
-        input_ids: Optional[torch.LongTensor] = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        past_key_values: Optional[Cache] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        labels: Optional[torch.LongTensor] = None,
-        use_cache: Optional[bool] = None,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        past_key_values: Cache | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        labels: torch.LongTensor | None = None,
+        use_cache: bool | None = None,
         **kwargs: Unpack[TransformersKwargs],
     ) -> SequenceClassifierOutputWithPast:
         transformer_outputs: BaseModelOutputWithPast = getattr(self, self.base_model_prefix)(
@@ -192,13 +191,13 @@ class GenericForQuestionAnswering:
     @auto_docstring
     def forward(
         self,
-        input_ids: Optional[torch.LongTensor] = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        past_key_values: Optional[Cache] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        start_positions: Optional[torch.LongTensor] = None,
-        end_positions: Optional[torch.LongTensor] = None,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        past_key_values: Cache | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        start_positions: torch.LongTensor | None = None,
+        end_positions: torch.LongTensor | None = None,
         **kwargs: Unpack[TransformersKwargs],
     ) -> QuestionAnsweringModelOutput:
         outputs: BaseModelOutputWithPast = getattr(self, self.base_model_prefix)(
@@ -255,13 +254,13 @@ class GenericForTokenClassification:
     @auto_docstring
     def forward(
         self,
-        input_ids: Optional[torch.LongTensor] = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        past_key_values: Optional[Cache] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        labels: Optional[torch.LongTensor] = None,
-        use_cache: Optional[bool] = None,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        past_key_values: Cache | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        labels: torch.LongTensor | None = None,
+        use_cache: bool | None = None,
         **kwargs: Unpack[TransformersKwargs],
     ) -> TokenClassifierOutput:
         outputs: BaseModelOutputWithPast = getattr(self, self.base_model_prefix)(