# VITS

[VITS (Variational Inference with adversarial learning for end-to-end Text-to-Speech)](https://huggingface.co/papers/2106.06103) es un modelo de síntesis de voz de extremo a extremo que simplifica los sistemas tradicionales de texto a voz (TTS) de dos etapas. Su particularidad radica en que sintetiza la voz directamente a partir del texto mediante inferencia variacional, aprendizaje adversarial y flujos normalizadores, generando un habla natural y expresiva con ritmos e inflexiones diversas.

Puedes encontrar todos los puntos de control originales de VITS en la organización [AI at Meta](https://huggingface.co/facebook?search_models=mms-tts).

> [!TIP]
> Haz clic en los modelos de VITS en la barra lateral derecha para ver más ejemplos sobre cómo aplicar VITS.

El siguiente ejemplo demuestra cómo generar texto a partir de una imagen con [Pipeline](/docs/transformers/main/es/main_classes/pipelines#transformers.Pipeline) o la clase [AutoModel](/docs/transformers/main/es/model_doc/auto#transformers.AutoModel).

```python
from scipy.io.wavfile import write

from transformers import pipeline, set_seed

set_seed(555)

pipe = pipeline(
    task="text-to-speech",
    model="facebook/mms-tts-eng",
    device=0
)

speech = pipe("Hello, my dog is cute")

# Extract audio data and sampling rate
audio_data = speech["audio"]
sampling_rate = speech["sampling_rate"]

# Save as WAV file
write("hello.wav", sampling_rate, audio_data.squeeze())
```

```python
import scipy
import torch
from IPython.display import Audio

from transformers import AutoTokenizer, VitsModel, set_seed

tokenizer = AutoTokenizer.from_pretrained("facebook/mms-tts-eng")
model = VitsModel.from_pretrained("facebook/mms-tts-eng", device_map="auto")
inputs = tokenizer("Hello, my dog is cute", return_tensors="pt").to(model.device)

set_seed(555)

with torch.no_grad():
    outputs = model(**inputs)

waveform = outputs.waveform[0]
scipy.io.wavfile.write("hello.wav", rate=model.config.sampling_rate, data=waveform)

# display in Colab notebook
Audio(waveform, rate=model.config.sampling_rate)
```

## Notas

- Establezca una semilla para la reproducibilidad, ya que VITS sintetiza el habla de forma no determinista.
- Para idiomas con alfabetos no romanos (coreano, árabe, etc.), instale el paquete [uroman](https://github.com/isi-nlp/uroman) para preprocesar las entradas de texto al alfabeto romano. Puede verificar si el tokenizador requiere uroman, como se muestra a continuación.

   ```py
   # pip install -U uroman
   from transformers import VitsTokenizer

   tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
   print(tokenizer.is_uroman)
   ```

   Si su idioma requiere uroman, el tokenizador lo aplica automáticamente a las entradas de texto.

## VitsConfig[[transformers.VitsConfig]]

#### transformers.VitsConfig[[transformers.VitsConfig]]

```python
transformers.VitsConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 38, hidden_size: int = 192, num_hidden_layers: int = 6, num_attention_heads: int = 2, window_size: int = 4, use_bias: bool = True, ffn_dim: int = 768, layerdrop: float | int = 0.1, ffn_kernel_size: int = 3, flow_size: int = 192, spectrogram_bins: int = 513, hidden_act: str = 'relu', hidden_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, use_stochastic_duration_prediction: bool = True, num_speakers: int = 1, speaker_embedding_size: int = 0, upsample_initial_channel: int = 512, upsample_rates: list[int] | tuple[int, ...] = (8, 8, 2, 2), upsample_kernel_sizes: list[int] | tuple[int, ...] = (16, 16, 4, 4), resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11), resblock_dilation_sizes: list | tuple = ((1, 3, 5), (1, 3, 5), (1, 3, 5)), leaky_relu_slope: float = 0.1, depth_separable_channels: int = 2, depth_separable_num_layers: int = 3, duration_predictor_flow_bins: int = 10, duration_predictor_tail_bound: float = 5.0, duration_predictor_kernel_size: int = 3, duration_predictor_dropout: float | int = 0.5, duration_predictor_num_flows: int = 4, duration_predictor_filter_channels: int = 256, prior_encoder_num_flows: int = 4, prior_encoder_num_wavenet_layers: int = 4, posterior_encoder_num_wavenet_layers: int = 16, wavenet_kernel_size: int = 5, wavenet_dilation_rate: int = 1, wavenet_dropout: float | int = 0.0, speaking_rate: float | int = 1.0, noise_scale: float = 0.667, noise_scale_duration: float = 0.8, sampling_rate: int = 16000, pad_token_id: int | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vits/configuration_vits.py#L24)

**Parámetros:**

vocab_size (`int`, *opcional*, valor predeterminado `38`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

hidden_size (`int`, *opcional*, valor predeterminado `192`) : Dimensión de las representaciones ocultas.

num_hidden_layers (`int`, *opcional*, valor predeterminado `6`) : Número de capas ocultas en el decodificador del Transformer.

num_attention_heads (`int`, *opcional*, valor predeterminado `2`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer.

window_size (`int`, *opcional*, valor predeterminado: 4) : Tamaño de la ventana para los embeddings posicionales relativos en las capas de atención del codificador Transformer.

use_bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe usar sesgo en las capas de proyección de clave, consulta y valor del codificador Transformer.

ffn_dim (`int`, *opcional*, valor predeterminado `768`) : Dimensión de las representaciones MLP.

layerdrop (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La probabilidad de LayerDrop. Consulte el [artículo de LayerDrop](see https://huggingface.co/papers/1909.11556) para obtener más detalles.

ffn_kernel_size (`int`, *opcional*, valor predeterminado 3) : Tamaño del kernel de las capas de convolución 1D utilizadas por la red feed-forward en el codificador Transformer.

flow_size (`int`, *opcional*, valor predeterminado 192) : Dimensionalidad de las capas de flujo.

spectrogram_bins (`int`, *opcional*, valor predeterminado 513) : Número de bandas de frecuencia en el espectrograma objetivo.

hidden_act (`str`, *opcional*, valor predeterminado `relu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La probabilidad de dropout para todas las capas totalmente conectadas en los embeddings, el codificador y el pooler.

attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción de dropout para las probabilidades de atención.

activation_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción de dropout para las activaciones dentro de la capa totalmente conectada.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización de capas.

use_stochastic_duration_prediction (`bool`, *opcional*, valor predeterminado `True`) : Si se debe usar el módulo de predicción de duración estocástico o el predictor de duración regular.

num_speakers (`int`, *opcional*, valor predeterminado: 1) : Número de hablantes si se trata de un modelo de varios hablantes.

speaker_embedding_size (`int`, *opcional*, valor predeterminado 0) : Número de canales utilizados por las incrustaciones de hablante. Es cero para modelos de un solo hablante.

upsample_initial_channel (`int`, *opcional*, valor predeterminado: 512) : El número de canales de entrada en la red de remuestreo ascendente de HiFi-GAN.

upsample_rates (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `[8, 8, 2, 2]`) : Una tupla de enteros que define el paso de cada capa convolucional 1D en la red de muestreo ascendente de HiFi-GAN. La longitud de `upsample_rates` define el número de capas convolucionales y debe coincidir con la longitud de `upsample_kernel_sizes`.

upsample_kernel_sizes (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `[16, 16, 4, 4]`) : Una tupla de enteros que define el tamaño del kernel de cada capa convolucional 1D en la red de muestreo ascendente de HiFi-GAN. La longitud de `upsample_kernel_sizes` define el número de capas convolucionales y debe coincidir con la longitud de `upsample_rates`.

resblock_kernel_sizes (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `[3, 7, 11]`) : Una tupla de enteros que define los tamaños de los núcleos de las capas convolucionales 1D en el módulo de fusión de múltiples campos receptivos (MRF) de HiFi-GAN.

resblock_dilation_sizes (`tuple[tuple[int]]` o `list[list[int]]`, *opcional*, valor predeterminado `[[1, 3, 5], [1, 3, 5], [1, 3, 5]]`) : Una tupla anidada de enteros que define las tasas de dilatación de las capas de convolución 1D dilatada en el módulo de fusión de múltiples campos receptivos (MRF) de HiFi-GAN.

leaky_relu_slope (`float`, *opcional*, valor predeterminado 0.1) : El ángulo de la pendiente negativa utilizado por la activación leaky ReLU.

depth_separable_channels (`int`, *opcional*, valor predeterminado 2) : Número de canales a utilizar en cada bloque separable en profundidad.

depth_separable_num_layers (`int`, *opcional*, valor predeterminado 3) : Número de capas convolucionales a utilizar en cada bloque separable por profundidad.

duration_predictor_flow_bins (`int`, *opcional*, valor predeterminado 10) : Número de canales que se mapean mediante la spline racional no restringida en el modelo predictor de duración.

duration_predictor_tail_bound (`float`, *opcional*, valor predeterminado 5.0) : Valor del límite del bin de cola al calcular la spline racional no restringida en el modelo del predictor de duración.

duration_predictor_kernel_size (`int`, *opcional*, valor predeterminado 3) : Tamaño del kernel de las capas de convolución 1D utilizadas en el modelo predictor de duración.

duration_predictor_dropout (`float`, *opcional*, valor predeterminado 0.5) : La proporción de dropout para el modelo predictor de duración.

duration_predictor_num_flows (`int`, *opcional*, valor predeterminado 4) : Número de etapas de flujo utilizadas por el modelo predictor de duración.

duration_predictor_filter_channels (`int`, *opcional*, valor predeterminado 256) : Número de canales para las capas de convolución utilizadas en el modelo predictor de duración.

prior_encoder_num_flows (`int`, *opcional*, valor predeterminado: 4) : Número de etapas de flujo utilizadas por el modelo de flujo del codificador previo.

prior_encoder_num_wavenet_layers (`int`, *opcional*, valor predeterminado: 4) : Número de capas de WaveNet utilizadas por el modelo de flujo del codificador a priori.

posterior_encoder_num_wavenet_layers (`int`, *opcional*, valor predeterminado 16) : Número de capas de WaveNet utilizadas por el modelo de codificador posterior.

wavenet_kernel_size (`int`, *opcional*, valor predeterminado 5) : Tamaño del kernel de las capas de convolución 1D utilizadas en el modelo WaveNet.

wavenet_dilation_rate (`int`, *opcional*, valor predeterminado 1) : Tasas de dilatación de las capas convolucionales 1D dilatadas utilizadas en el modelo WaveNet.

wavenet_dropout (`float`, *opcional*, valor predeterminado 0.0) : La proporción de dropout para las capas WaveNet.

speaking_rate (`float`, *opcional*, valor predeterminado 1.0) : Velocidad de habla. Los valores más altos producen un habla sintetizada más rápida.

noise_scale (`float`, *opcional*, valor predeterminado 0.667) : Indica el nivel de aleatoriedad de la predicción del habla. Los valores más altos generan mayor variación en el habla predicha.

noise_scale_duration (`float`, *opcional*, valor predeterminado 0.8) : Qué tan aleatoria es la predicción de la duración. Los valores más grandes crean más variación en las duraciones predichas.

sampling_rate (`int`, *opcional*, valor predeterminado `16000`) : La frecuencia de muestreo a la que deben digitalizarse los archivos de audio, expresada en hercios (Hz).

pad_token_id (`int`, *opcional*) : Id de token utilizado para el relleno en el vocabulario.

Esta es la clase de configuración para almacenar la configuración de un VitsModel. Se utiliza para instanciar un modelo Vits según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/mms-tts-eng](https://huggingface.co/facebook/mms-tts-eng)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

```python
>>> from transformers import VitsModel, VitsConfig

>>> # Initializing a "facebook/mms-tts-eng" style configuration
>>> configuration = VitsConfig()

>>> # Initializing a model (with random weights) from the "facebook/mms-tts-eng" style configuration
>>> model = VitsModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## VitsTokenizer[[transformers.VitsTokenizer]]

#### transformers.VitsTokenizer[[transformers.VitsTokenizer]]

```python
transformers.VitsTokenizer(vocab_file, pad_token = '<pad>', unk_token = '<unk>', language = None, add_blank = True, normalize = True, phonemize = True, is_uroman = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vits/tokenization_vits.py#L46)

**Parámetros:**

vocab_file (`str`) : Ruta al archivo de vocabulario.

language (`str`, *opcional*) : Identificador de idioma.

add_blank (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe insertar el id de token 0 entre los demás tokens.

normalize (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe normalizar el texto de entrada eliminando todas las mayúsculas y la puntuación.

phonemize (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe convertir el texto de entrada en fonemas.

is_uroman (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe aplicar el romanizador `uroman` al texto de entrada antes de tokenizarlo.

Construye un tokenizador de VITS. También admite MMS-TTS.

Este tokenizador hereda de [PreTrainedTokenizer](/docs/transformers/main/es/main_classes/tokenizer#transformers.PythonBackend), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

#### __llamada__[[transformers.VitsTokenizer.__call__]]

```python
__call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2449)

**Parámetros:**

text (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadenas pretokenizadas). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias).

text_pair (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadenas pretokenizadas). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias).

text_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o lote de secuencias que se codificarán como textos objetivo. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias).

text_pair_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o lote de secuencias que se codificarán como textos objetivo. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias).

tokenizer_kwargs (`dict[str, Any]`, *opcional*) : Kwargs adicionales para pasar al tokenizer. Se fusionarán con los parámetros explícitos y otros kwargs, dando prioridad a los parámetros explícitos.

add_special_tokens (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben o no añadir tokens especiales al codificar las secuencias. Esto utilizará la función subyacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define qué tokens se añaden automáticamente a los ids de entrada. Esto es útil si desea añadir automáticamente tokens `bos` o `eos`.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : Activa y controla el relleno. Acepta los siguientes valores:  - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de longitudes diferentes).

truncation (`bool`, `str` o [TruncationStrategy](/docs/transformers/main/es/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, valor predeterminado `False`) : Activa y controla la truncación. Acepta los siguientes valores:  - `True` o `'longest_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token por token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_second'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `False` o `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible del modelo).

max_length (`int`, *opcional*) : Controla la longitud máxima que debe usar uno de los parámetros de truncamiento/relleno. Si se deja sin establecer o se establece en `None`, se usará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno requiere una longitud máxima. Si el modelo no tiene una longitud de entrada máxima específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará.

stride (`int`, *opcional*, valor predeterminado 0) : Si se establece en un número junto con `max_length`, los tokens en exceso devueltos cuando `return_overflowing_tokens=True` contendrán algunos tokens del final de la secuencia truncada devuelta para proporcionar cierta superposición entre las secuencias truncadas y las de exceso. El valor de este argumento define el número de tokens superpuestos.

is_split_into_words (`bool`, *opcional*, valor predeterminado `False`) : Indica si la entrada ya está pretokenizada (por ejemplo, dividida en palabras). Si se establece en `True`, el tokenizador asume que la entrada ya está dividida en palabras (por ejemplo, dividiéndola por espacios en blanco) y procederá a tokenizarla. Esto es útil para NER o clasificación de tokens.

pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Requiere que `padding` esté activado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo `>= 7.5` (Volta).

padding_side (`str`, *opcional*) : El lado en el que el modelo debe aplicar el relleno. Debe seleccionarse entre ['right', 'left']. El valor predeterminado se toma del atributo de la clase con el mismo nombre.

return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy.

return_token_type_ids (`bool`, *opcional*) : Indica si se deben devolver los IDs de tipo de token. Si se deja en el valor predeterminado, se devolverán los IDs de tipo de token según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`.  [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids)

return_attention_mask (`bool`, *opcional*) : Indica si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver o no las secuencias de tokens que desbordan. Si se proporciona un par de secuencias de ids de entrada (o un lote de pares) con `truncation_strategy = longest_first` o `True`, se genera un error en lugar de devolver los tokens que desbordan.

return_special_tokens_mask (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe o no devolver información de la máscara de tokens especiales.

return_offsets_mapping (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver `(char_start, char_end)` para cada token. Esto solo está disponible en tokenizadores rápidos que heredan de [PreTrainedTokenizerFast](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend); si se utiliza el tokenizador de Python, este método lanzará `NotImplementedError`.

return_length  (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver las longitudes de las entradas codificadas.

verbose (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe imprimir más información y advertencias.

- ****kwargs** : se pasan al método `self.tokenize()`

**Devuelve:** [BatchEncoding](/docs/transformers/main/es/main_classes/tokenizer#transformers.BatchEncoding)

Un [BatchEncoding](/docs/transformers/main/es/main_classes/tokenizer#transformers.BatchEncoding) con los siguientes campos:

- **input_ids** -- Lista de ids de tokens que se enviarán a un modelo.

  [¿Qué son los IDs de entrada?](../glossary#input-ids)

- **token_type_ids** -- Lista de ids de tipo de token que se enviarán a un modelo (cuando `return_token_type_ids=True` o si *"token_type_ids"* está en `self.model_input_names`).

  [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids)

- **attention_mask** -- Lista de índices que especifica qué tokens debe atender el modelo (cuando `return_attention_mask=True` o si *"attention_mask"* está en `self.model_input_names`).

  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

- **overflowing_tokens** -- Lista de secuencias de tokens que exceden el límite (cuando se especifica `max_length` y `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Número de tokens truncados (cuando se especifica un `max_length` y `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Lista de 0 y 1, donde 1 indica tokens especiales añadidos y 0 indica tokens regulares de la secuencia (cuando `add_special_tokens=True` y `return_special_tokens_mask=True`).
- **length** -- La longitud de las entradas (cuando `return_length=True`)

Método principal para tokenizar y preparar una o varias secuencias o uno o varios pares de secuencias para el modelo.

#### save_vocabulary[[transformers.VitsTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vits/tokenization_vits.py#L232)

## VitsModel[[transformers.VitsModel]]

#### transformers.VitsModel[[transformers.VitsModel]]

```python
transformers.VitsModel(config: VitsConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vits/modeling_vits.py#L1228)

**Parámetros:**

config ([VitsConfig](/docs/transformers/main/es/model_doc/vits#transformers.VitsConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo VITS completo, para la síntesis de voz a partir de texto.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.VitsModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, speaker_id: int | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, labels: typing.Optional[torch.Tensor] = None, speaking_rate: float | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vits/modeling_vits.py#L1255)

**Parámetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

speaker_id (`int`, *opcional*) : Qué embedding de orador utilizar. Solo se usa en modelos de varios oradores.

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

labels (`torch.Tensor` de forma `(batch_size, config.spectrogram_bins, sequence_length)`, *opcional*) : Valores flotantes del espectrograma objetivo. Los pasos de tiempo fijados en `-100.0` se ignoran (se enmascaran) para el cálculo de la pérdida.

speaking_rate (`float`, *opcional*) : Velocidad de habla.

**Devuelve:** `VitsModelOutput` o `tuple(torch.Tensor)`

Un `VitsModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([VitsConfig](/docs/transformers/main/es/model_doc/vits#transformers.VitsConfig)) y las entradas.

El método forward de [VitsModel](/docs/transformers/main/es/model_doc/vits#transformers.VitsModel) reemplaza el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **waveform** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- La forma de onda de audio final predicha por el modelo.
- **sequence_lengths** (`torch.Tensor` de forma `(batch_size,)`) -- La longitud en muestras de cada elemento del lote `waveform`.
- **spectrogram** (`torch.Tensor` de forma `(batch_size, sequence_length, num_bins)`) -- El espectrograma log-mel predicho en la salida del modelo de flujo. Este espectrograma se pasa al modelo decodificador Hi-Fi GAN para obtener la forma de onda de audio final.
- **hidden_states** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

```python
>>> from transformers import VitsTokenizer, VitsModel, set_seed
>>> import torch

>>> tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
>>> model = VitsModel.from_pretrained("facebook/mms-tts-eng")

>>> inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt")

>>> set_seed(555)  # make deterministic

>>> with torch.no_grad():
...     outputs = model(inputs["input_ids"])
>>> outputs.waveform.shape
torch.Size([1, 45824])
```