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

transformers/models/vitpose/configuration_vitpose.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2024 The HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +14,8 @@
 # limitations under the License.
 """VitPose model configuration"""
 
+from typing import Optional
+
 from ...configuration_utils import PreTrainedConfig
 from ...utils import logging
 from ...utils.backbone_utils import verify_backbone_config_arguments
@@ -33,7 +36,7 @@ class VitPoseConfig(PreTrainedConfig):
     documentation from [`PreTrainedConfig`] for more information.
 
     Args:
-        backbone_config (`Union[dict, "PreTrainedConfig"]`, *optional*, defaults to `VitPoseBackboneConfig()`):
+        backbone_config (`PreTrainedConfig` or `dict`, *optional*, defaults to `VitPoseBackboneConfig()`):
             The configuration of the backbone model. Currently, only `backbone_config` with `vitpose_backbone` as `model_type` is supported.
         backbone (`str`, *optional*):
             Name of backbone to use when `backbone_config` is `None`. If `use_pretrained_backbone` is `True`, this
@@ -75,11 +78,11 @@ class VitPoseConfig(PreTrainedConfig):
 
     def __init__(
         self,
-        backbone_config: PreTrainedConfig | None = None,
-        backbone: str | None = None,
+        backbone_config: Optional[PreTrainedConfig] = None,
+        backbone: Optional[str] = None,
         use_pretrained_backbone: bool = False,
         use_timm_backbone: bool = False,
-        backbone_kwargs: dict | None = None,
+        backbone_kwargs: Optional[dict] = None,
         initializer_range: float = 0.02,
         scale_factor: int = 4,
         use_simple_decoder: bool = True,

transformers/models/vitpose/image_processing_vitpose.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2024 The HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,7 +16,7 @@
 
 import itertools
 import math
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional, Union
 
 import numpy as np
 
@@ -60,13 +61,13 @@ class VitPoseImageProcessorKwargs(ImagesKwargs, total=False):
         Width and height scale factor used for normalization when computing center and scale from bounding boxes.
     """
 
-    do_affine_transform: bool | None
-    normalize_factor: float | None
+    do_affine_transform: Optional[bool]
+    normalize_factor: Optional[float]
 
 
 # inspired by https://github.com/ViTAE-Transformer/ViTPose/blob/d5216452796c90c6bc29f5c5ec0bdba94366768a/mmpose/datasets/datasets/base/kpt_2d_sview_rgb_img_top_down_dataset.py#L132
 def box_to_center_and_scale(
-    box: tuple | list | np.ndarray,
+    box: Union[tuple, list, np.ndarray],
     image_width: int,
     image_height: int,
     normalize_factor: float = 200.0,
@@ -366,12 +367,12 @@ class VitPoseImageProcessor(BaseImageProcessor):
     def __init__(
         self,
         do_affine_transform: bool = True,
-        size: dict[str, int] | None = None,
+        size: Optional[dict[str, int]] = None,
         do_rescale: bool = True,
-        rescale_factor: int | float = 1 / 255,
+        rescale_factor: Union[int, float] = 1 / 255,
         do_normalize: bool = True,
-        image_mean: float | list[float] | None = None,
-        image_std: float | list[float] | None = None,
+        image_mean: Optional[Union[float, list[float]]] = None,
+        image_std: Optional[Union[float, list[float]]] = None,
         **kwargs,
     ):
         super().__init__(**kwargs)
@@ -391,8 +392,8 @@ class VitPoseImageProcessor(BaseImageProcessor):
         scale: tuple[float],
         rotation: float,
         size: dict[str, int],
-        data_format: ChannelDimension | None = None,
-        input_data_format: str | ChannelDimension | None = None,
+        data_format: Optional[ChannelDimension] = None,
+        input_data_format: Optional[Union[str, ChannelDimension]] = None,
     ) -> np.ndarray:
         """
         Apply an affine transformation to an image.
@@ -436,17 +437,17 @@ class VitPoseImageProcessor(BaseImageProcessor):
     def preprocess(
         self,
         images: ImageInput,
-        boxes: list[list[float]] | np.ndarray,
-        do_affine_transform: bool | None = None,
-        size: dict[str, int] | None = None,
-        do_rescale: bool | None = None,
-        rescale_factor: float | None = None,
-        do_normalize: bool | None = None,
-        image_mean: float | list[float] | None = None,
-        image_std: float | list[float] | None = None,
-        return_tensors: str | TensorType | None = None,
-        data_format: str | ChannelDimension = ChannelDimension.FIRST,
-        input_data_format: str | ChannelDimension | None = None,
+        boxes: Union[list[list[float]], np.ndarray],
+        do_affine_transform: Optional[bool] = None,
+        size: Optional[dict[str, int]] = None,
+        do_rescale: Optional[bool] = None,
+        rescale_factor: Optional[float] = None,
+        do_normalize: Optional[bool] = None,
+        image_mean: Optional[Union[float, list[float]]] = None,
+        image_std: Optional[Union[float, list[float]]] = None,
+        return_tensors: Optional[Union[str, TensorType]] = None,
+        data_format: Union[str, ChannelDimension] = ChannelDimension.FIRST,
+        input_data_format: Optional[Union[str, ChannelDimension]] = None,
     ) -> PIL.Image.Image:
         """
         Preprocess an image or batch of images.
@@ -605,10 +606,10 @@ class VitPoseImageProcessor(BaseImageProcessor):
     def post_process_pose_estimation(
         self,
         outputs: "VitPoseEstimatorOutput",
-        boxes: list[list[list[float]]] | np.ndarray,
+        boxes: Union[list[list[list[float]]], np.ndarray],
         kernel_size: int = 11,
-        threshold: float | None = None,
-        target_sizes: TensorType | list[tuple] | None = None,
+        threshold: Optional[float] = None,
+        target_sizes: Optional[Union[TensorType, list[tuple]]] = None,
     ):
         """
         Transform the heatmaps into keypoint predictions and transform them back to the image.

transformers/models/vitpose/image_processing_vitpose_fast.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2025 The HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,7 +15,7 @@
 """Fast Image processor class for VitPose."""
 
 import itertools
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional, Union
 
 import numpy as np
 import torch
@@ -95,7 +96,7 @@ class VitPoseImageProcessorFast(BaseImageProcessorFast):
     def preprocess(
         self,
         images: ImageInput,
-        boxes: list[list[float]] | np.ndarray,
+        boxes: Union[list[list[float]], np.ndarray],
         **kwargs: Unpack[VitPoseImageProcessorKwargs],
     ) -> BatchFeature:
         r"""
@@ -108,16 +109,16 @@ class VitPoseImageProcessorFast(BaseImageProcessorFast):
     def _preprocess(
         self,
         images: list[torch.Tensor],
-        boxes: list | np.ndarray,
+        boxes: Union[list, np.ndarray],
         do_affine_transform: bool,
         size: SizeDict,
         do_rescale: bool,
         rescale_factor: float,
         do_normalize: bool,
-        image_mean: float | tuple[float],
-        image_std: float | tuple[float],
+        image_mean: Union[float, tuple[float]],
+        image_std: Union[float, tuple[float]],
         disable_grouping: bool,
-        return_tensors: str | TensorType | None,
+        return_tensors: Optional[Union[str, TensorType]],
         **kwargs,
     ) -> BatchFeature:
         """
@@ -155,6 +156,7 @@ class VitPoseImageProcessorFast(BaseImageProcessorFast):
         processed_images = reorder_images(processed_images_grouped, grouped_images_index)
 
         # Stack into batch tensor
+        processed_images = torch.stack(processed_images, dim=0) if return_tensors else processed_images
 
         return BatchFeature(data={"pixel_values": processed_images}, tensor_type=return_tensors)
 
@@ -203,10 +205,10 @@ class VitPoseImageProcessorFast(BaseImageProcessorFast):
     def post_process_pose_estimation(
         self,
         outputs: "VitPoseEstimatorOutput",
-        boxes: list[list[list[float]]] | np.ndarray,
+        boxes: Union[list[list[list[float]]], np.ndarray],
         kernel_size: int = 11,
-        threshold: float | None = None,
-        target_sizes: TensorType | list[tuple] | None = None,
+        threshold: Optional[float] = None,
+        target_sizes: Optional[Union[TensorType, list[tuple]]] = None,
     ):
         """
         Transform the heatmaps into keypoint predictions and transform them back to the image.

transformers/models/vitpose/modeling_vitpose.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2024 University of Sydney and The HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,6 +15,7 @@
 """PyTorch VitPose model."""
 
 from dataclasses import dataclass
+from typing import Optional, Union
 
 import torch
 from torch import nn
@@ -51,10 +53,10 @@ class VitPoseEstimatorOutput(ModelOutput):
         (also called feature maps) of the model at the output of each stage.
     """
 
-    loss: torch.FloatTensor | None = None
-    heatmaps: torch.FloatTensor | None = None
-    hidden_states: tuple[torch.FloatTensor, ...] | None = None
-    attentions: tuple[torch.FloatTensor, ...] | None = None
+    loss: Optional[torch.FloatTensor] = None
+    heatmaps: Optional[torch.FloatTensor] = None
+    hidden_states: Optional[tuple[torch.FloatTensor, ...]] = None
+    attentions: Optional[tuple[torch.FloatTensor, ...]] = None
 
 
 @auto_docstring
@@ -66,7 +68,7 @@ class VitPosePreTrainedModel(PreTrainedModel):
     supports_gradient_checkpointing = True
 
     @torch.no_grad()
-    def _init_weights(self, module: nn.Linear | nn.Conv2d | nn.LayerNorm):
+    def _init_weights(self, module: Union[nn.Linear, nn.Conv2d, nn.LayerNorm]):
         """Initialize the weights"""
         if isinstance(module, (nn.Linear, nn.Conv2d)):
             init.trunc_normal_(module.weight, mean=0.0, std=self.config.initializer_range)
@@ -132,7 +134,7 @@ class VitPoseSimpleDecoder(nn.Module):
             config.backbone_config.hidden_size, config.num_labels, kernel_size=3, stride=1, padding=1
         )
 
-    def forward(self, hidden_state: torch.Tensor, flip_pairs: torch.Tensor | None = None) -> torch.Tensor:
+    def forward(self, hidden_state: torch.Tensor, flip_pairs: Optional[torch.Tensor] = None) -> torch.Tensor:
         # Transform input: ReLU + upsample
         hidden_state = self.activation(hidden_state)
         hidden_state = self.upsampling(hidden_state)
@@ -165,7 +167,7 @@ class VitPoseClassicDecoder(nn.Module):
 
         self.conv = nn.Conv2d(256, config.num_labels, kernel_size=1, stride=1, padding=0)
 
-    def forward(self, hidden_state: torch.Tensor, flip_pairs: torch.Tensor | None = None):
+    def forward(self, hidden_state: torch.Tensor, flip_pairs: Optional[torch.Tensor] = None):
         hidden_state = self.deconv1(hidden_state)
         hidden_state = self.batchnorm1(hidden_state)
         hidden_state = self.relu1(hidden_state)
@@ -211,9 +213,9 @@ class VitPoseForPoseEstimation(VitPosePreTrainedModel):
     def forward(
         self,
         pixel_values: torch.Tensor,
-        dataset_index: torch.Tensor | None = None,
-        flip_pairs: torch.Tensor | None = None,
-        labels: torch.Tensor | None = None,
+        dataset_index: Optional[torch.Tensor] = None,
+        flip_pairs: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
         **kwargs: Unpack[TransformersKwargs],
     ) -> VitPoseEstimatorOutput:
         r"""
@@ -230,15 +232,13 @@ class VitPoseForPoseEstimation(VitPosePreTrainedModel):
         >>> from transformers import AutoImageProcessor, VitPoseForPoseEstimation
         >>> import torch
         >>> from PIL import Image
-        >>> import httpx
-        >>> from io import BytesIO
+        >>> import requests
 
         >>> processor = AutoImageProcessor.from_pretrained("usyd-community/vitpose-base-simple")
         >>> model = VitPoseForPoseEstimation.from_pretrained("usyd-community/vitpose-base-simple")
 
         >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-        >>> with httpx.stream("GET", url) as response:
-        ...     image = Image.open(BytesIO(response.read()))
+        >>> image = Image.open(requests.get(url, stream=True).raw)
         >>> boxes = [[[412.8, 157.61, 53.05, 138.01], [384.43, 172.21, 15.12, 35.74]]]
         >>> inputs = processor(image, boxes=boxes, return_tensors="pt")
 

transformers/models/vitpose_backbone/configuration_vitpose_backbone.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2024 The HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

transformers/models/vitpose_backbone/modeling_vitpose_backbone.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2024 University of Sydney and The HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,6 +21,7 @@ This code is the same as the original Vision Transformer (ViT) with 2 modificati
 
 import collections.abc
 from collections.abc import Callable
+from typing import Optional, Union
 
 import torch
 from torch import nn
@@ -101,8 +103,8 @@ def eager_attention_forward(
     query: torch.Tensor,
     key: torch.Tensor,
     value: torch.Tensor,
-    attention_mask: torch.Tensor | None,
-    scaling: float | None = None,
+    attention_mask: Optional[torch.Tensor],
+    scaling: Optional[float] = None,
     dropout: float = 0.0,
     **kwargs: Unpack[TransformersKwargs],
 ):
@@ -287,7 +289,7 @@ class VitPoseBackboneLayer(GradientCheckpointingLayer):
     def forward(
         self,
         hidden_states: torch.Tensor,
-        dataset_index: torch.Tensor | None = None,
+        dataset_index: Optional[torch.Tensor] = None,
     ) -> torch.Tensor:
         # Validate dataset_index when using multiple experts
         if self.num_experts > 1 and dataset_index is None:
@@ -327,8 +329,8 @@ class VitPoseBackboneEncoder(nn.Module):
     def forward(
         self,
         hidden_states: torch.Tensor,
-        dataset_index: torch.Tensor | None = None,
-        output_hidden_states: bool | None = None,
+        dataset_index: Optional[torch.Tensor] = None,
+        output_hidden_states: Optional[bool] = None,
     ) -> BaseModelOutput:
         all_hidden_states = [hidden_states] if output_hidden_states else None
         for i, layer_module in enumerate(self.layer):
@@ -357,7 +359,7 @@ class VitPoseBackbonePreTrainedModel(PreTrainedModel):
     }
 
     @torch.no_grad()
-    def _init_weights(self, module: nn.Linear | nn.Conv2d | nn.LayerNorm | VitPoseBackboneEmbeddings):
+    def _init_weights(self, module: Union[nn.Linear, nn.Conv2d, nn.LayerNorm, VitPoseBackboneEmbeddings]):
         """Initialize the weights"""
         if isinstance(module, (nn.Linear, nn.Conv2d)):
             init.trunc_normal_(module.weight, mean=0.0, std=self.config.initializer_range)
@@ -394,8 +396,8 @@ class VitPoseBackbone(VitPoseBackbonePreTrainedModel, BackboneMixin):
     def forward(
         self,
         pixel_values: torch.Tensor,
-        dataset_index: torch.Tensor | None = None,
-        output_hidden_states: bool | None = None,
+        dataset_index: Optional[torch.Tensor] = None,
+        output_hidden_states: Optional[bool] = None,
         **kwargs,
     ):
         r"""

transformers/models/vits/configuration_vits.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2023 The Kakao Enterprise Authors and the HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -129,8 +130,6 @@ class VitsConfig(PreTrainedConfig):
             How random the duration prediction is. Larger values create more variation in the predicted durations.
         sampling_rate (`int`, *optional*, defaults to 16000):
             The sampling rate at which the output audio waveform is digitalized expressed in hertz (Hz).
-        pad_token_id (`int`, *optional*):
-            Padding token id.
 
     Example:
 
@@ -195,7 +194,6 @@ class VitsConfig(PreTrainedConfig):
         noise_scale=0.667,
         noise_scale_duration=0.8,
         sampling_rate=16_000,
-        pad_token_id=None,
         **kwargs,
     ):
         self.vocab_size = vocab_size
@@ -242,7 +240,6 @@ class VitsConfig(PreTrainedConfig):
         self.noise_scale = noise_scale
         self.noise_scale_duration = noise_scale_duration
         self.sampling_rate = sampling_rate
-        self.pad_token_id = pad_token_id
 
         if len(upsample_kernel_sizes) != len(upsample_rates):
             raise ValueError(

transformers/models/vits/modeling_vits.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2023 The Kakao Enterprise Authors and the HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,7 +16,7 @@
 
 import math
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Optional, Union
 
 import numpy as np
 import torch
@@ -29,7 +30,7 @@ from ...modeling_attn_mask_utils import _prepare_4d_attention_mask
 from ...modeling_layers import GradientCheckpointingLayer
 from ...modeling_outputs import BaseModelOutput, ModelOutput
 from ...modeling_utils import PreTrainedModel
-from ...utils import auto_docstring, logging, torch_compilable_check
+from ...utils import auto_docstring, logging
 from .configuration_vits import VitsConfig
 
 
@@ -53,11 +54,11 @@ class VitsModelOutput(ModelOutput):
         GAN decoder model to obtain the final audio waveform.
     """
 
-    waveform: torch.FloatTensor | None = None
-    sequence_lengths: torch.FloatTensor | None = None
-    spectrogram: tuple[torch.FloatTensor] | None = None
-    hidden_states: tuple[torch.FloatTensor] | None = None
-    attentions: tuple[torch.FloatTensor] | None = None
+    waveform: Optional[torch.FloatTensor] = None
+    sequence_lengths: Optional[torch.FloatTensor] = None
+    spectrogram: Optional[tuple[torch.FloatTensor]] = None
+    hidden_states: Optional[tuple[torch.FloatTensor]] = None
+    attentions: Optional[tuple[torch.FloatTensor]] = None
 
 
 @dataclass
@@ -74,11 +75,11 @@ class VitsTextEncoderOutput(ModelOutput):
         The predicted log-variance values of the prior distribution for the latent text variables.
     """
 
-    last_hidden_state: torch.FloatTensor | None = None
-    prior_means: torch.FloatTensor | None = None
-    prior_log_variances: torch.FloatTensor | None = None
-    hidden_states: tuple[torch.FloatTensor] | None = None
-    attentions: tuple[torch.FloatTensor] | None = None
+    last_hidden_state: Optional[torch.FloatTensor] = None
+    prior_means: Optional[torch.FloatTensor] = None
+    prior_log_variances: Optional[torch.FloatTensor] = None
+    hidden_states: Optional[tuple[torch.FloatTensor]] = None
+    attentions: Optional[tuple[torch.FloatTensor]] = None
 
 
 @torch.jit.script
@@ -210,10 +211,10 @@ def _rational_quadratic_spline(
     """
     upper_bound = tail_bound
     lower_bound = -tail_bound
-    torch_compilable_check(
-        (inputs.min() >= lower_bound) & (inputs.max() <= upper_bound),
-        f"Inputs are outside the range [{lower_bound}, {upper_bound}]",
-    )
+
+    if torch.min(inputs) < lower_bound or torch.max(inputs) > upper_bound:
+        raise ValueError("Input to a transform is not within its domain")
+
     num_bins = unnormalized_widths.shape[-1]
 
     if min_bin_width * num_bins > 1.0:
@@ -283,10 +284,8 @@ def _rational_quadratic_spline(
         c = -input_delta * intermediate2
 
         discriminant = b.pow(2) - 4 * a * c
-        torch_compilable_check(
-            torch.all(discriminant >= 0),
-            f"Discriminant has negative values {discriminant}",
-        )
+        if not (discriminant >= 0).all():
+            raise RuntimeError(f"invalid discriminant {discriminant}")
 
         root = (2 * c) / (-b - torch.sqrt(discriminant))
         outputs = root * input_bin_widths + input_cumwidths
@@ -517,7 +516,7 @@ class VitsHifiGan(nn.Module):
             layer.remove_weight_norm()
 
     def forward(
-        self, spectrogram: torch.FloatTensor, global_conditioning: torch.FloatTensor | None = None
+        self, spectrogram: torch.FloatTensor, global_conditioning: Optional[torch.FloatTensor] = None
     ) -> torch.FloatTensor:
         r"""
         Converts a spectrogram into a speech waveform.
@@ -875,10 +874,10 @@ class VitsAttention(nn.Module):
     def forward(
         self,
         hidden_states: torch.Tensor,
-        key_value_states: torch.Tensor | None = None,
-        attention_mask: torch.Tensor | None = None,
+        key_value_states: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
         output_attentions: bool = False,
-    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+    ) -> tuple[torch.Tensor, Optional[torch.Tensor]]:
         """Input shape: Batch x Time x Channel"""
 
         # if key_value_states are provided this layer is used as a cross-attention layer
@@ -1052,7 +1051,7 @@ class VitsEncoderLayer(GradientCheckpointingLayer):
         self,
         hidden_states: torch.Tensor,
         padding_mask: torch.FloatTensor,
-        attention_mask: torch.Tensor | None = None,
+        attention_mask: Optional[torch.Tensor] = None,
         output_attentions: bool = False,
     ):
         residual = hidden_states
@@ -1090,11 +1089,11 @@ class VitsEncoder(nn.Module):
         self,
         hidden_states: torch.FloatTensor,
         padding_mask: torch.FloatTensor,
-        attention_mask: torch.Tensor | None = None,
-        output_attentions: bool | None = None,
-        output_hidden_states: bool | None = None,
-        return_dict: bool | None = None,
-    ) -> tuple | BaseModelOutput:
+        attention_mask: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[tuple, BaseModelOutput]:
         all_hidden_states = () if output_hidden_states else None
         all_self_attentions = () if output_attentions else None
 
@@ -1162,11 +1161,11 @@ class VitsTextEncoder(nn.Module):
         self,
         input_ids: torch.Tensor,
         padding_mask: torch.FloatTensor,
-        attention_mask: torch.Tensor | None = None,
-        output_attentions: bool | None = None,
-        output_hidden_states: bool | None = None,
-        return_dict: bool | None = True,
-    ) -> tuple[torch.Tensor] | VitsTextEncoderOutput:
+        attention_mask: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = True,
+    ) -> Union[tuple[torch.Tensor], VitsTextEncoderOutput]:
         hidden_states = self.embed_tokens(input_ids) * math.sqrt(self.config.hidden_size)
 
         encoder_outputs = self.encoder(
@@ -1269,15 +1268,14 @@ class VitsModel(VitsPreTrainedModel):
     @auto_docstring
     def forward(
         self,
-        input_ids: torch.Tensor | None = None,
-        attention_mask: torch.Tensor | None = None,
-        speaker_id: int | None = None,
-        output_attentions: bool | None = None,
-        output_hidden_states: bool | None = None,
-        return_dict: bool | None = None,
-        labels: torch.FloatTensor | None = None,
-        **kwargs,
-    ) -> tuple[Any] | VitsModelOutput:
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        speaker_id: Optional[int] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        labels: Optional[torch.FloatTensor] = None,
+    ) -> Union[tuple[Any], VitsModelOutput]:
         r"""
         speaker_id (`int`, *optional*):
             Which speaker embedding to use. Only used for multispeaker models.

transformers/models/vits/tokenization_vits.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2023 The Kakao Enterprise Authors, the MMS-TTS Authors and the HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +17,7 @@
 import json
 import os
 import re
-from typing import Any
+from typing import Any, Optional, Union
 
 from ...tokenization_python import PreTrainedTokenizer
 from ...utils import is_phonemizer_available, is_uroman_available, logging
@@ -140,7 +141,7 @@ class VitsTokenizer(PreTrainedTokenizer):
         return text
 
     def prepare_for_tokenization(
-        self, text: str, is_split_into_words: bool = False, normalize: bool | None = None, **kwargs
+        self, text: str, is_split_into_words: bool = False, normalize: Optional[bool] = None, **kwargs
     ) -> tuple[str, dict[str, Any]]:
         """
         Performs any necessary transformations before tokenization.
@@ -230,7 +231,7 @@ class VitsTokenizer(PreTrainedTokenizer):
         """Converts an index (integer) in a token (str) using the vocab."""
         return self.decoder.get(index)
 
-    def save_vocabulary(self, save_directory: str, filename_prefix: str | None = None) -> tuple[str] | None:
+    def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Union[tuple[str], None]:
         if not os.path.isdir(save_directory):
             logger.error(f"Vocabulary path ({save_directory}) should be a directory")
             return

transformers/models/vivit/configuration_vivit.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2023 The HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");