Hugging Face's logo

Transformers documentation

Wav2Vec2

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo se publicó en HF papers el 2020-06-20 y se contribuyó a Hugging Face Transformers el 2021-02-02.

Wav2Vec2

FlashAttention SDPA

Resumen

El modelo Wav2Vec2 fue propuesto en wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations por Alexei Baevski, Henry Zhou, Abdelrahman Mohamed y Michael Auli.

El resumen del artículo es el siguiente:

Mostramos por primera vez que aprender representaciones potentes a partir únicamente de audio de voz y, a continuación, realizar un ajuste fino con voz transcrita puede superar a los mejores métodos semisupervisados, siendo además conceptualmente más simple. wav2vec 2.0 enmascara la entrada de voz en el espacio latente y resuelve una tarea contrastiva definida sobre una cuantización de las representaciones latentes, que se aprenden de forma conjunta. Los experimentos que utilizan todos los datos etiquetados de Librispeech logran un WER de 1.8/3.3 en los conjuntos de prueba clean/other. Al reducir la cantidad de datos etiquetados a una hora, wav2vec 2.0 supera al estado del arte anterior en el subconjunto de 100 horas, utilizando 100 veces menos datos etiquetados. Utilizando solo diez minutos de datos etiquetados y preentrenando con 53k horas de datos sin etiquetar, se logra un WER de 4.8/8.2. Esto demuestra la viabilidad del reconocimiento de voz con cantidades limitadas de datos etiquetados.

Este modelo fue aportado por patrickvonplaten.

Nota: Meta (FAIR) ha publicado una nueva versión de Wav2Vec2-BERT 2.0, preentrenada con 4,5 millones de horas de audio. Recomendamos especialmente su uso en tareas de fine-tuning, por ejemplo, siguiendo esta guía.

Establezca use_kernels=True en from_pretrained() para reemplazar las capas compatibles con kernels optimizados del Hub. Consulte Carga de kernels para obtener más información.

Consejos de uso

  • Wav2Vec2 es un modelo de voz que acepta un array de flotantes correspondiente a la forma de onda cruda de la señal de voz.
  • El modelo Wav2Vec2 se entrenó usando clasificación temporal conexionista (CTC), por lo que la salida del modelo debe decodificarse usando Wav2Vec2CTCTokenizer.

Uso de Flash Attention 2

Flash Attention 2 es una versión más rápida y optimizada del modelo.

Instalación

Primero, comprueba si tu hardware es compatible con Flash Attention 2. La lista más reciente de hardware compatible se encuentra en la documentación oficial.

A continuación, instale la última versión de Flash Attention 2:

pip install -U flash-attn --no-build-isolation

Uso

Para cargar un modelo usando Flash Attention 2, podemos pasar el argumento attn_implementation="flash_attention_2" a from_pretrained(). También cargaremos el modelo en media precisión (p. ej. torch.float16), ya que esto produce una degradación casi nula en la calidad del audio, pero un uso de memoria significativamente menor y una inferencia más rápida:

from transformers import Wav2Vec2Model


model = Wav2Vec2Model.from_pretrained("facebook/wav2vec2-large-960h-lv60-self", attn_implementation="flash_attention_2", device_map="auto")
...

Aceleraciones esperadas

A continuación se muestra un diagrama de la aceleración esperada que compara el tiempo de inferencia puro entre la implementación nativa en transformers del modelo facebook/wav2vec2-large-960h-lv60-self y las versiones flash-attention-2 y sdpa (scale-dot-product-attention). Mostramos la aceleración media obtenida en la división de validación librispeech_asr clean:

Recursos

Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados con 🌎) para ayudarte a empezar con Wav2Vec2. Si te interesa enviar un recurso para que se incluya aquí, no dudes en abrir un Pull Request y lo revisaremos. Lo ideal es que el recurso demuestre algo nuevo en lugar de duplicar un recurso existente.

Audio Classification
Automatic Speech Recognition

🚀 Despliegue

Wav2Vec2Config

clase transformers.Wav2Vec2Config

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int | None = 32hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout: float | int = 0.1activation_dropout: float | int = 0.1attention_dropout: float | int = 0.1feat_proj_dropout: float | int = 0.0feat_quantizer_dropout: float | int = 0.0final_dropout: float | int = 0.1layerdrop: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-05feat_extract_norm: str = 'group'feat_extract_activation: str = 'gelu'conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512)conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2)conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2)conv_bias: bool = Falsenum_conv_pos_embeddings: int = 128num_conv_pos_embedding_groups: int = 16do_stable_layer_norm: bool = Falseapply_spec_augment: bool = Truemask_time_prob: float | int = 0.05mask_time_length: int = 10mask_time_min_masks: int = 2mask_feature_prob: float | int = 0.0mask_feature_length: int = 10mask_feature_min_masks: int = 0num_codevectors_per_group: int = 320num_codevector_groups: int = 2contrastive_logits_temperature: float = 0.1num_negatives: int = 100codevector_dim: int = 256proj_codevector_dim: int = 256diversity_loss_weight: float = 0.1ctc_loss_reduction: str = 'sum'ctc_zero_infinity: bool = Falseuse_weighted_layer_sum: bool = Falseclassifier_proj_size: int = 256tdnn_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 1500)tdnn_kernel: list[int] | tuple[int, ...] = (5, 3, 3, 1, 1)tdnn_dilation: list[int] | tuple[int, ...] = (1, 2, 3, 1, 1)xvector_output_dim: int = 512pad_token_id: int | None = 0bos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2add_adapter: bool = Falseadapter_kernel_size: int = 3adapter_stride: int = 2num_adapter_layers: int = 3output_hidden_size: int | None = Noneadapter_attn_dim: int | None = None )

Parámetros

  • vocab_size (int, opcional, valor predeterminado 32) — 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 768) — Dimensión de las representaciones ocultas.
  • num_hidden_layers (int, opcional, valor predeterminado 12) — Número de capas ocultas en el decodificador del Transformer.
  • num_attention_heads (int, opcional, valor predeterminado 12) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • intermediate_size (int, opcional, valor predeterminado 3072) — Dimensión de las representaciones del MLP.
  • hidden_act (str, opcional, valor predeterminado gelu) — 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 las incrustaciones, el codificador y el pooler.
  • activation_dropout (Union[float, int], opcional, valor predeterminado 0.1) — La proporción de dropout para las activaciones dentro de la capa totalmente conectada.
  • attention_dropout (Union[float, int], opcional, valor predeterminado 0.1) — La proporción de dropout para las probabilidades de atención.
  • feat_proj_dropout (float, opcional, valor predeterminado 0.0) — La probabilidad de dropout para la salida del codificador de características.
  • feat_quantizer_dropout (float, opcional, valor predeterminado 0.0) — La probabilidad de dropout para la salida del codificador de características que utiliza el cuantizador.
  • final_dropout (float, opcional, valor predeterminado 0.1) — La probabilidad de dropout para la capa de proyección final de Wav2Vec2ForCTC.
  • layerdrop (Union[float, int], opcional, valor predeterminado 0.1) — La probabilidad de LayerDrop. Consulte el [artículo de LayerDrop](ver https://huggingface.co/papers/1909.11556) para más detalles.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del 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 capa.
  • feat_extract_norm (str, opcional, valor predeterminado "group") — La normalización que se aplicará a las capas convolucionales 1D del codificador de características. Puede ser "group" para la normalización por grupos de solo la primera capa convolucional 1D o "layer" para la normalización por capas de todas las capas convolucionales 1D.
  • feat_extract_activation (str, optional, defaults to “gelu”) -- The non-linear activation function (function or string) in the 1D convolutional layers of the feature extractor. If string, “gelu”, “relu”, “selu”and“gelu_new”` are supported.
  • conv_dim (tuple[int] o list[int], opcional, valor predeterminado (512, 512, 512, 512, 512, 512, 512)) — Una tupla de enteros que define el número de canales de entrada y salida de cada capa convolucional 1D en el codificador de características. La longitud de conv_dim define el número de capas convolucionales 1D.
  • conv_stride (tuple[int] o list[int], opcional, valor predeterminado (5, 2, 2, 2, 2, 2, 2)) — Una tupla de enteros que define el paso (stride) de cada capa convolucional 1D en el codificador de características. La longitud de conv_stride define el número de capas convolucionales y debe coincidir con la longitud de conv_dim.
  • conv_kernel (tuple[int] o list[int], opcional, valor predeterminado (10, 3, 3, 3, 3, 3, 3)) — Una tupla de enteros que define el tamaño del kernel de cada capa convolucional 1D en el codificador de características. La longitud de conv_kernel define el número de capas convolucionales y debe coincidir con la longitud de conv_dim.
  • conv_bias (bool, opcional, valor predeterminado False) — Si las capas de convolución 1D tienen un sesgo.
  • num_conv_pos_embeddings (int, opcional, valor predeterminado 128) — Número de incrustaciones posicionales convolucionales. Define el tamaño del núcleo de la capa de incrustaciones posicionales convolucionales 1D.
  • num_conv_pos_embedding_groups (int, opcional, valor predeterminado 16) — Número de grupos de la capa de incrustaciones posicionales convolucionales 1D.
  • do_stable_layer_norm (bool, opcional, valor predeterminado False) — Si se aplica la arquitectura de layer norm estable del codificador Transformer. do_stable_layer_norm is True corresponde a aplicar layer norm antes de la capa de atención, mientras que do_stable_layer_norm is False corresponde a aplicar layer norm después de la capa de atención.
  • apply_spec_augment (bool, opcional, valor predeterminado True) — Si se aplica la ampliación de datos SpecAugment a las salidas del codificador de características. Para más información, consulte SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition.
  • mask_time_prob (float, optional, defaults to 0.05) — Percentage (between 0 and 1) of all feature vectors along the time axis which will be masked. The masking procedure generates ”mask_time_problen(time_axis)/mask_time_length” independent masks over the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector span to be masked, mask_time_prob should be `prob_vector_startmask_time_length. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant if apply_spec_augment is True`.
  • mask_time_length (int, opcional, valor predeterminado 10) — Longitud del tramo del vector a lo largo del eje temporal.
  • mask_time_min_masks (int, opcional, valor predeterminado 2), — El número mínimo de máscaras de longitud mask_feature_length generadas a lo largo del eje temporal, en cada paso de tiempo, independientemente de mask_feature_prob. Solo es relevante si ”mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks”
  • mask_feature_prob (float, optional, defaults to 0.0) — Percentage (between 0 and 1) of all feature vectors along the feature axis which will be masked. The masking procedure generates ”mask_feature_problen(feature_axis)/mask_time_length” independent masks over the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector span to be masked, mask_feature_prob should be `prob_vector_startmask_feature_length. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant if apply_spec_augment is True`.
  • mask_feature_prob (Union[float, int], opcional, valor predeterminado 0.0) — Porcentaje (entre 0 y 1) de todos los vectores de características a lo largo del eje de características que se enmascararán. El procedimiento de enmascarado genera mask_feature_prob*len(feature_axis)/mask_time_length máscaras independientes sobre el eje. Si se razona a partir de la probabilidad de que cada vector de características sea elegido como el inicio del tramo de vectores a enmascarar, mask_feature_prob debería ser prob_vector_start*mask_feature_length. Tenga en cuenta que la superposición puede disminuir el porcentaje real de vectores enmascarados. Esto solo es relevante si apply_spec_augment es True.
  • mask_feature_length (int, opcional, valor predeterminado 10) — Longitud del tramo del vector a lo largo del eje de características.
  • mask_feature_min_masks (int, opcional, valor predeterminado 0), — El número mínimo de máscaras de longitud mask_feature_length generadas a lo largo del eje de características, en cada paso de tiempo, independientemente de mask_feature_prob. Solo es relevante si ”mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks”
  • num_codevectors_per_group (int, opcional, valor predeterminado 320) — Número de entradas en cada libro de cuantización (grupo).
  • num_codevectors_per_group (int, opcional, valor predeterminado 320) — Número de entradas en cada libro de cuantización (grupo).
  • num_codevector_groups (int, opcional, valor predeterminado 2) — Número de grupos de codevector para la cuantización de codevector por producto.
  • contrastive_logits_temperature (float, opcional, valor predeterminado 0.1) — La temperatura kappa en la pérdida contrastiva.
  • num_negatives (int, opcional, valor predeterminado 100) — Número de muestras negativas para la pérdida contrastiva.
  • codevector_dim (int, opcional, valor predeterminado 256) — Dimensionalidad de los vectores de características cuantizados.
  • proj_codevector_dim (int, opcional, valor predeterminado 256) — Dimensionalidad de la proyección final de las características cuantizadas y de las características del transformador.
  • diversity_loss_weight (int, opcional, valor predeterminado 0.1) — El peso del componente de pérdida de diversidad del libro de códigos.
  • ctc_loss_reduction (str, opcional, valor predeterminado "sum") — Especifica la reducción que se debe aplicar a la salida de torch.nn.CTCLoss. Solo es relevante al entrenar una instancia de Wav2Vec2ForCTC.
  • ctc_zero_infinity (bool, opcional, valor predeterminado False) — Indica si se deben poner a cero las pérdidas infinitas y los gradientes asociados de torch.nn.CTCLoss. Las pérdidas infinitas ocurren principalmente cuando las entradas son demasiado cortas para alinearse con las dianas. Solo es relevante al entrenar una instancia de Wav2Vec2ForCTC.
  • use_weighted_layer_sum (bool, opcional, valor predeterminado False) — Si se debe usar un promedio ponderado de las salidas de las capas con pesos aprendidos. Solo es relevante al usar una instancia de Wav2Vec2ForSequenceClassification.
  • classifier_proj_size (int, opcional, valor predeterminado 256) — Dimensionalidad de la proyección antes del pooling medio de tokens para clasificación.
  • tdnn_dim (tuple[int] o list[int], opcional, valor predeterminado (512, 512, 512, 512, 1500)) — Una tupla de enteros que define el número de canales de salida de cada capa convolucional 1D en el módulo TDNN del modelo XVector. La longitud de tdnn_dim define el número de capas TDNN.
  • tdnn_kernel (tuple[int] o list[int], opcional, valor predeterminado (5, 3, 3, 1, 1)) — Una tupla de enteros que define el tamaño del kernel de cada capa convolucional 1D en el módulo TDNN del modelo XVector. La longitud de tdnn_kernel debe coincidir con la longitud de tdnn_dim.
  • tdnn_dilation (tuple[int] o list[int], opcional, valor predeterminado (1, 2, 3, 1, 1)) — Una tupla de enteros que define el factor de dilatación de cada capa convolucional 1D en el módulo TDNN del modelo XVector. La longitud de tdnn_dilation debe coincidir con la longitud de tdnn_dim.
  • xvector_output_dim (int, opcional, valor predeterminado 512) — Dimensionalidad de los vectores de incrustación XVector.
  • pad_token_id (int, opcional, valor predeterminado 0) — Id del token utilizado para el relleno en el vocabulario.
  • bos_token_id (int, opcional, valor predeterminado 1) — Id del token utilizado para el inicio de la secuencia en el vocabulario.
  • eos_token_id (Union[int, list[int]], opcional, valor predeterminado 2) — Identificador de token utilizado para el fin de secuencia en el vocabulario.
  • add_adapter (bool, opcional, valor predeterminado False) — Indica si se debe apilar una red convolucional sobre el codificador de Wav2Vec2. Puede ser muy útil para iniciar el entrenamiento de Wav2Vec2 para modelos SpeechEncoderDecoder.
  • adapter_kernel_size (int, opcional, valor predeterminado 3) — Tamaño del kernel de las capas convolucionales en la red del adaptador. Solo es relevante si add_adapter is True.
  • adapter_stride (int, opcional, valor predeterminado 2) — Paso de las capas convolucionales en la red adaptadora. Solo es relevante si add_adapter is True.
  • num_adapter_layers (int, opcional, valor predeterminado 3) — Número de capas convolucionales que deben usarse en la red del adaptador. Solo es relevante si add_adapter is True.
  • output_hidden_size (int, opcional) — Dimensionalidad de la capa de salida del codificador. Si no se define, el valor predeterminado es hidden-size. Solo es relevante si add_adapter is True.
  • adapter_attn_dim (int, opcional) — Dimensión de los pesos del adaptador de atención que se utilizará en cada bloque de atención. Un ejemplo de un modelo que utiliza adaptadores de atención es facebook/mms-1b-all.

Esta es la clase de configuración para almacenar la configuración de un Wav2Vec2Model. Se utiliza para instanciar un modelo Wav2Vec2 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/wav2vec2-base-960h

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

>>> from transformers import Wav2Vec2Config, Wav2Vec2Model

>>> # Initializing a Wav2Vec2 facebook/wav2vec2-base-960h style configuration
>>> configuration = Wav2Vec2Config()

>>> # Initializing a model (with random weights) from the facebook/wav2vec2-base-960h style configuration
>>> model = Wav2Vec2Model(configuration)

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

Wav2Vec2CTCTokenizer

clase transformers.Wav2Vec2CTCTokenizer

< >

( vocab_filebos_token = '<s>'eos_token = '</s>'unk_token = '<unk>'pad_token = '<pad>'word_delimiter_token = '|'replace_word_delimiter_char = ' 'do_lower_case = Falsetarget_lang = None**kwargs )

Parámetros

  • vocab_file (str) — Archivo que contiene el vocabulario.
  • bos_token (str, opcional, valor predeterminado "<s>") — El token de inicio de oración.
  • eos_token (str, opcional, por defecto "</s>") — El token de fin de oración.
  • unk_token (str, opcional, valor predeterminado "<unk>") — El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar.
  • pad_token (str, opcional, valor predeterminado "<pad>") — El token utilizado para el relleno, por ejemplo, al agrupar secuencias de diferentes longitudes.
  • word_delimiter_token (str, opcional, valor predeterminado "|") — El token utilizado para definir el final de una palabra.
  • do_lower_case (bool, opcional, valor predeterminado False) — Indica si se acepta la entrada en minúsculas y se convierte la salida a minúsculas durante la decodificación.
  • target_lang (str, opcional) — Un idioma objetivo que el tokenizador debe establecer de forma predeterminada. target_lang debe estar definido para vocabularios multinacionales anidados, como facebook/mms-1b-all.
  • **kwargs — Argumentos de palabra clave adicionales que se pasan a PreTrainedTokenizer

Construye un tokenizador Wav2Vec2CTC.

Este tokenizador hereda de PreTrainedTokenizer, que contiene algunos de los métodos principales. Los usuarios deben consultar la superclase para obtener más información sobre dichos métodos.

__call__

< >

( text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | PaddingStrategy = Falsetruncation: bool | str | TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0is_split_into_words: bool = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = Truetokenizer_kwargs: dict[str, Any] | None = None**kwargs ) → BatchEncoding

Parámetros

  • text (str, list[str], list[list[str]], opcional) — La secuencia o lote de secuencias que se codificarán. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadenas pre-tokenizadas). Si las secuencias se proporcionan como lista de cadenas de caracteres (pre-tokenizadas), 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 lote de secuencias que se codificarán. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadena pre-tokenizada). Si las secuencias se proporcionan como lista de cadenas de caracteres (pre-tokenizadas), 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 de caracteres (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas de caracteres (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 de caracteres (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas de caracteres (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 deseas añadir tokens bos o eos automáticamente.
  • padding (bool, str o PaddingStrategy, opcional, el valor predeterminado es 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 diferentes longitudes).
  • truncation (bool, str o TruncationStrategy, opcional, por defecto 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 a 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 a una longitud máxima especificada con el argumento max_length o a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de un par si se proporciona un par de secuencias (o un lote de pares).
    • 'only_second': Trunca a una longitud máxima especificada con el argumento max_length o a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de un par si se proporciona un par de secuencias (o un lote de pares).
    • False o 'do_not_truncate' (predeterminado): sin truncamiento (es decir, se puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible por el modelo).
  • max_length (int, opcional) — Controla la longitud máxima que se utilizará mediante uno de los parámetros de truncamiento/relleno.

    Si se deja sin definir o se establece en None, se utilizará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno lo requiere. Si el modelo no tiene una longitud máxima de entrada 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 de desbordamiento 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 desbordamiento. 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 las tokenizará. Esto es útil para NER o clasificación de tokens.
  • pad_to_multiple_of (int, opcional) — Si se establece, se 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 elige a partir del atributo de clase con el mismo nombre.
  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores en lugar de una lista de enteros de Python. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos Numpy np.ndarray.
  • return_token_type_ids (bool, opcional) — 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 return_outputs atributo.

    ¿Qué son los IDs de tipo de token?

  • return_attention_mask (bool, opcional) — 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 return_outputs atributo.

    ¿Qué son las máscaras de atención?

  • return_overflowing_tokens (bool, opcional, valor predeterminado False) — Indica si se deben devolver las secuencias de tokens que exceden el límite. 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 exceden el límite.
  • 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, por defecto False) — Si se devuelve o no (char_start, char_end) para cada token.

    Esto solo está disponible en los tokenizadores rápidos que heredan de PreTrainedTokenizerFast; 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) — Si se imprime más información y advertencias.
  • **kwargs — se pasan al método self.tokenize()

Devuelve

BatchEncoding

Un 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?

  • 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?

  • attention_mask — Lista de índices que especifica qué tokens deben ser atendidos por 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?

  • overflowing_tokens — Lista de secuencias de tokens que exceden el límite (cuando se especifica un 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 especifica los tokens especiales añadidos y 0 especifica los 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 para el modelo una o varias secuencias o uno o varios pares de secuencias.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None )

decode

< >

( token_ids: typing.Union[int, list[int], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = Noneoutput_char_offsets: bool = Falseoutput_word_offsets: bool = False**kwargs ) → str or Wav2Vec2CTCTokenizerOutput

Parámetros

  • token_ids (Union[int, list[int], np.ndarray, torch.Tensor]) — Lista de ids de entrada tokenizados. Se puede obtener mediante el método __call__.
  • skip_special_tokens (bool, opcional, valor predeterminado False) — Indica si se deben eliminar los tokens especiales durante la decodificación.
  • clean_up_tokenization_spaces (bool, opcional) — Indica si se deben limpiar los espacios de tokenización.
  • output_char_offsets (bool, opcional, por defecto False) — Indica si se deben o no generar desplazamientos de caracteres. Los desplazamientos de caracteres pueden combinarse con la tasa de muestreo y la tasa de submuestreo del modelo para calcular las marcas de tiempo de los caracteres transcritos.

    Puede consultar el siguiente ejemplo para comprender mejor cómo utilizar output_char_offsets.

  • output_word_offsets (bool, opcional, por defecto False) — Indica si se deben o no generar los desplazamientos de las palabras. Los desplazamientos de las palabras pueden combinarse con la tasa de muestreo y la tasa de submuestreo del modelo para calcular las marcas de tiempo de las palabras transcritas.

    Eche un vistazo al siguiente ejemplo para comprender mejor cómo aprovechar output_word_offsets.

  • kwargs (argumentos de palabra clave adicionales, opcional) — Se pasará al método de decodificación específico del modelo subyacente.

Devuelve

str o Wav2Vec2CTCTokenizerOutput

La lista de frases decodificadas. Será un Wav2Vec2CTCTokenizerOutput cuando output_char_offsets == True o output_word_offsets == True.

Convierte una secuencia de ids en una cadena de texto, utilizando el tokenizador y el vocabulario, con opciones para eliminar tokens especiales y limpiar los espacios de tokenización.

Similar a hacer self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids)).

Ejemplo:

>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoFeatureExtractor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch

>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")

>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)

>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = feature_extractor(sample["audio"]["array"], return_tensors="pt").input_values
>>> logits = model(input_values).logits[0]
>>> pred_ids = torch.argmax(logits, axis=-1)

>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = tokenizer.decode(pred_ids, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / feature_extractor.sampling_rate

>>> word_offsets = [
...     {
...         "word": d["word"],
...         "start_time": round(d["start_offset"] * time_offset, 2),
...         "end_time": round(d["end_offset"] * time_offset, 2),
...     }
...     for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:3]
[{'word': 'THE', 'start_time': 0.7, 'end_time': 0.78}, {'word': 'TRICK', 'start_time': 0.88, 'end_time': 1.08}, {'word': 'APPEARS', 'start_time': 1.2, 'end_time': 1.64}]

batch_decode

< >

( sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = Noneoutput_char_offsets: bool = Falseoutput_word_offsets: bool = False**kwargs ) → list[str] or Wav2Vec2CTCTokenizerOutput

Parámetros

  • sequences (Union[list[int], list[list[int]], np.ndarray, torch.Tensor]) — Lista de ids de entrada tokenizados. Se puede obtener usando el método __call__.
  • skip_special_tokens (bool, opcional, valor predeterminado False) — Indica si se deben eliminar los tokens especiales durante la decodificación.
  • clean_up_tokenization_spaces (bool, opcional) — Indica si se deben limpiar los espacios de tokenización.
  • output_char_offsets (bool, opcional, por defecto False) — Indica si se deben o no generar desplazamientos de caracteres. Los desplazamientos de caracteres pueden usarse en combinación con la tasa de muestreo y la tasa de submuestreo del modelo para calcular las marcas de tiempo de los caracteres transcritos.

    Echa un vistazo al Ejemplo de decode() para comprender mejor cómo hacer uso de output_char_offsets. batch_decode() funciona de la misma manera con salidas por lotes.

  • output_word_offsets (bool, opcional, por defecto False) — Indica si se deben o no generar desplazamientos de palabras. Los desplazamientos de palabras pueden usarse en combinación con la tasa de muestreo y la tasa de submuestreo del modelo para calcular las marcas de tiempo de las palabras transcritas.

    Echa un vistazo al Ejemplo de decode() para comprender mejor cómo aprovechar output_word_offsets. batch_decode() funciona de la misma manera con salidas por lotes.

  • kwargs (argumentos de palabra clave adicionales, opcional) — Se pasará al método de decodificación específico del modelo subyacente.

Devuelve

list[str] o Wav2Vec2CTCTokenizerOutput

La lista de frases decodificadas. Será un Wav2Vec2CTCTokenizerOutput cuando output_char_offsets == True o output_word_offsets == True.

Convierta una lista de listas de ids de tokens en una lista de cadenas de texto llamando a decode.

set_target_lang

< >

( target_lang: str )

Establecer el idioma objetivo de un diccionario multinivel multilingüe

Wav2Vec2FeatureExtractor

clase transformers.Wav2Vec2FeatureExtractor

< >

( feature_size = 1sampling_rate = 16000padding_value = 0.0return_attention_mask = Falsedo_normalize = True**kwargs )

Parámetros

  • feature_size (int, opcional, valor predeterminado 1) — La dimensión de las características de las características extraídas.
  • sampling_rate (int, opcional, valor predeterminado 16000) — La tasa de muestreo a la que deben digitalizarse los archivos de audio, expresada en hercios (Hz).
  • padding_value (float, opcional, valor predeterminado 0.0) — El valor que se utiliza para rellenar los valores de relleno.
  • do_normalize (bool, opcional, valor predeterminado True) — Indica si se debe normalizar la entrada a media cero y varianza unitaria. La normalización puede ayudar a mejorar significativamente el rendimiento en algunos modelos, por ejemplo, wav2vec2-lv60.
  • return_attention_mask (bool, opcional, por defecto False) — Si llamar() debe devolver attention_mask.

    Los modelos Wav2Vec2 que tienen config.feat_extract_norm == "group", como wav2vec2-base, no se han entrenado utilizando attention_mask. Para dichos modelos, input_values simplemente debe rellenarse con 0 y no se debe pasar attention_mask.

    Para los modelos Wav2Vec2 que tienen config.feat_extract_norm == "layer", como wav2vec2-lv60, se debe pasar attention_mask para la inferencia por lotes.

Construye un extractor de características Wav2Vec2.

Este extractor de características hereda de SequenceFeatureExtractor, 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.

__call__

< >

( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]padding: bool | str | transformers.utils.generic.PaddingStrategy = Falsemax_length: int | None = Nonetruncation: bool = Falsepad_to_multiple_of: int | None = Nonereturn_attention_mask: bool | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonesampling_rate: int | None = None**kwargs )

Parámetros

  • raw_speech (np.ndarray, list[float], list[np.ndarray], list[list[float]]) — La secuencia o lote de secuencias que se van a rellenar. Cada secuencia puede ser un array de numpy, una lista de valores float, una lista de arrays de numpy o una lista de listas de valores float. Debe ser audio de canal mono, no estéreo, es decir, un solo float por paso de tiempo.
  • padding (bool, str o PaddingStrategy, opcional, por defecto False) — Seleccione una estrategia para rellenar las secuencias devueltas (según el lado de relleno y el índice de relleno del modelo) entre:
    • 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 diferentes longitudes).
  • max_length (int, opcional) — Longitud máxima de la lista devuelta y, opcionalmente, longitud de relleno (véase arriba).
  • truncation (bool) — Activa la truncación para recortar las secuencias de entrada más largas que max_length a max_length.
  • pad_to_multiple_of (int, opcional) — Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado.

    Esto resulta especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo >= 7.5 (Volta), o en TPUs, que se benefician de que las longitudes de secuencia sean un múltiplo de 128.

  • 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 feature_extractor específico.

    ¿Qué son las máscaras de atención?

    Los modelos Wav2Vec2 que tienen config.feat_extract_norm == "group", como wav2vec2-base, no se han entrenado utilizando attention_mask. Para estos modelos, input_values simplemente debe rellenarse con 0 y no se debe pasar attention_mask.

    Para los modelos Wav2Vec2 que tienen config.feat_extract_norm == "layer", como wav2vec2-lv60, se debe pasar attention_mask para la inferencia por lotes.

  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores en lugar de una lista de enteros de Python. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos Numpy np.ndarray.
  • sampling_rate (int, opcional) — La tasa de muestreo a la que se muestreó la entrada raw_speech. Se recomienda encarecidamente pasar sampling_rate en la llamada forward para evitar errores silenciosos.
  • padding_value (float, opcional, valor predeterminado 0.0) —

Método principal para extraer características y preparar una o varias secuencias para el modelo.

Wav2Vec2Processor

clase transformers.Wav2Vec2Processor

< >

( feature_extractortokenizer )

Parámetros

  • feature_extractor (Wav2Vec2FeatureExtractor) — El extractor de características es una entrada obligatoria.
  • tokenizer (Wav2Vec2CTCTokenizer) — El tokenizador es una entrada obligatoria.

Crea un Wav2Vec2Processor que envuelve un extractor de características y un tokenizador en un único procesador.

Wav2Vec2Processor ofrece todas las funcionalidades de Wav2Vec2FeatureExtractor y Wav2Vec2CTCTokenizer. Consulte ~Wav2Vec2FeatureExtractor y ~Wav2Vec2CTCTokenizer para obtener más información.

__call__

< >

( audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | None = None**kwargs: *<class 'transformers.models.wav2vec2.processing_wav2vec2.Wav2Vec2ProcessorKwargs'> )

Parámetros

  • audio (Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor]], opcional) — El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de la muestra del audio.
  • text (Union[str, list[str]], opcional) — La secuencia o lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadenas pretokenizadas). Si se pasa una entrada pretokenizada, establezca is_split_into_words=True para evitar ambigüedad con las entradas por lotes.
  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos np.ndarray de NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, videos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

pad

< >

( *args**kwargs )

Parámetros

  • input_features — Cuando el primer argumento es un diccionario que contiene un lote de tensores, o está presente el argumento input_features, se pasa a Wav2Vec2FeatureExtractor.pad().
  • labels — Cuando está presente el argumento label, se pasa a PreTrainedTokenizer.pad().

Este método opera sobre lotes de características extraídas y/o texto tokenizado. Transmite todos los argumentos a Wav2Vec2FeatureExtractor.pad() y/o PreTrainedTokenizer.pad() según la modalidad de entrada y devuelve sus salidas. Si se pasan ambas modalidades, se invocan Wav2Vec2FeatureExtractor.pad() y PreTrainedTokenizer.pad().

from_pretrained

< >

( pretrained_model_name_or_path: str | os.PathLikecache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'**kwargs )

Parámetros

  • pretrained_model_name_or_path (str o os.PathLike) — Puede ser:
    • una cadena, el model id de un feature_extractor preentrenado alojado en un repositorio de modelos en huggingface.co.
    • una ruta a un directorio que contenga un archivo de extractor de características guardado usando el método save_pretrained(), por ejemplo, ./my_model_directory/.
    • una ruta a un archivo JSON de extractor de características guardado, archivo, p. ej., ./my_model_directory/preprocessor_config.json.
  • **kwargs — Argumentos de palabra clave adicionales que se pasan tanto a from_pretrained() como a ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained.

Instanciar un procesador asociado con un modelo preentrenado.

Este método de clase simplemente llama a los métodos from_pretrained() del extractor de características, ImageProcessingMixin del procesador de imágenes y ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained del tokenizador. Consulte las docstrings de los métodos anteriores para obtener más información.

save_pretrained

< >

( save_directorypush_to_hub: bool = False**kwargs )

Parámetros

  • save_directory (str o os.PathLike) — Directorio donde se guardará el archivo JSON del extractor de características y los archivos del tokenizador (el directorio se creará si no existe).
  • push_to_hub (bool, opcional, valor predeterminado False) — Indica si se debe subir el modelo al hub de modelos de Hugging Face después de guardarlo. Puedes especificar el repositorio al que deseas subirlo con repo_id (por defecto, usará el nombre de save_directory en tu espacio de nombres).
  • kwargs (dict[str, Any], opcional) — Argumentos de palabra clave adicionales que se pasan al método push_to_hub().

Guarda los atributos de este procesador (extractor de características, tokenizador…) en el directorio especificado para que pueda recargarse mediante el método from_pretrained().

Este método de clase simplemente llama a save_pretrained() y save_pretrained(). Consulte las docstrings de los métodos anteriores para obtener más información.

batch_decode

< >

( *args**kwargs )

Este método reenvía todos sus argumentos a batch_decode() de PreTrainedTokenizer. Consulte la docstring de este método para obtener más información.

decode

< >

( *args**kwargs )

Este método reenvía todos sus argumentos a decode() de PreTrainedTokenizer. Consulte la docstring de este método para obtener más información.

Wav2Vec2ProcessorWithLM

clase transformers.Wav2Vec2ProcessorWithLM

< >

( feature_extractor: FeatureExtractionMixintokenizer: PreTrainedTokenizerBasedecoder: BeamSearchDecoderCTC )

Parámetros

  • feature_extractor (feature_extractor_class) — El extractor de características es una entrada obligatoria.
  • tokenizer (tokenizer_class) — El tokenizador es una entrada obligatoria.
  • decoder (BeamSearchDecoderCTC) — Una instancia de pyctcdecode.BeamSearchDecoderCTC. El decodificador es una entrada obligatoria.

Construye un Wav2Vec2ProcessorWithLM que envuelve un extractor de características y un tokenizador en un único procesador.

Wav2Vec2ProcessorWithLM ofrece todas las funcionalidades de feature_extractor_class y tokenizer_class. Consulte ~feature_extractor_class y ~tokenizer_class para obtener más información.

__call__

< >

( *args**kwargs )

Parámetros

  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos np.ndarray de NumPy.

pad

< >

( *args**kwargs )

Cuando se utiliza en el modo normal, este método reenvía todos sus argumentos a ~FeatureExtractionMixin.pad del extractor de características y devuelve su salida. Si se utiliza en el contexto ~Wav2Vec2ProcessorWithLM.as_target_processor, este método reenvía todos sus argumentos a pad() de Wav2Vec2CTCTokenizer. Consulte la docstring de los dos métodos anteriores para obtener más información.

from_pretrained

< >

( pretrained_model_name_or_path**kwargs )

Parámetros

  • pretrained_model_name_or_path (str o os.PathLike) — Puede ser:
    • una cadena, el model id de un feature_extractor preentrenado alojado en un repositorio de modelos en huggingface.co.
    • una ruta a un directorio que contenga un archivo de extractor de características guardado usando el método save_pretrained(), por ejemplo, ./my_model_directory/.
    • una ruta a un archivo JSON de extractor de características guardado, archivo, p. ej., ./my_model_directory/preprocessor_config.json.
  • **kwargs — Argumentos de palabra clave adicionales que se pasan tanto a SequenceFeatureExtractor como a PreTrainedTokenizer

Instancia un Wav2Vec2ProcessorWithLM a partir de un procesador Wav2Vec2 preentrenado.

Este método de clase simplemente llama a from_pretrained() del extractor de características, a from_pretrained() de Wav2Vec2CTCTokenizer y a pyctcdecode.BeamSearchDecoderCTC.load_from_hf_hub.

Consulte los docstrings de los métodos anteriores para obtener más información.

save_pretrained

< >

( save_directory )

batch_decode

< >

( logits: ndarraypool: multiprocessing.pool.Pool | None = Nonenum_processes: int | None = Nonebeam_width: int | None = Nonebeam_prune_logp: float | None = Nonetoken_min_logp: float | None = Nonehotwords: collections.abc.Iterable[str] | None = Nonehotword_weight: float | None = Nonealpha: float | None = Nonebeta: float | None = Noneunk_score_offset: float | None = Nonelm_score_boundary: bool | None = Noneoutput_word_offsets: bool = Falsen_best: int = 1 )

Parámetros

  • logits (np.ndarray) — Vector de salida de logits del modelo que representa las probabilidades logarítmicas de cada token.
  • pool (multiprocessing.Pool, opcional) — Un pool gestionado por el usuario, opcional. Si no se establece, se creará y cerrará uno automáticamente. El pool debe instanciarse después Wav2Vec2ProcessorWithLM. de

    Actualmente, solo se pueden usar los pools creados con un contexto de ‘fork’. Si se pasa un pool de ‘spawn’, se ignorará y se usará la decodificación secuencial en su lugar.

  • num_processes (int, opcional) — Si pool no está definido, número de procesos sobre los que se debe paralelizar la función. Por defecto, es igual al número de CPUs disponibles.
  • beam_width (int, opcional) — Número máximo de haces en cada paso de la decodificación. El valor predeterminado es DEFAULT_BEAM_WIDTH de pyctcdecode.
  • beam_prune_logp (int, opcional) — Los haces que sean mucho peores que el mejor haz se recortarán. El valor predeterminado es DEFAULT_PRUNE_LOGP de pyctcdecode.
  • token_min_logp (int, opcional) — Los tokens con un logp inferior a este valor se omiten, a menos que sean el argmax del frame. El valor predeterminado es DEFAULT_MIN_TOKEN_LOGP de pyctcdecode.
  • hotwords (list[str], opcional) — Lista de palabras con importancia adicional, pueden ser OOV para el LM
  • hotword_weight (int, opcional) — Factor de peso para la importancia de las palabras clave. El valor predeterminado es DEFAULT_HOTWORD_WEIGHT de pyctcdecode.
  • alpha (float, opcional) — Peso del modelo de lenguaje durante la fusión superficial
  • beta (float, opcional) — Peso para el ajuste de la puntuación de longitud durante la puntuación
  • unk_score_offset (float, opcional) — Cantidad de desplazamiento de la puntuación log para los tokens desconocidos
  • lm_score_boundary (bool, opcional) — Si se debe tener en cuenta los límites al puntuar con kenlm
  • output_word_offsets (bool, opcional, valor predeterminado False) — Indica si se deben o no mostrar los desplazamientos de las palabras. Los desplazamientos de las palabras se pueden utilizar en combinación con la tasa de muestreo y la tasa de submuestreo del modelo para calcular las marcas de tiempo de las palabras transcritas.
  • n_best (int, opcional, por defecto 1) — Número de mejores hipótesis a devolver. Si n_best es mayor que 1, el valor devuelto de text será una lista de listas de cadenas, logit_score será una lista de listas de flotantes y lm_score será una lista de listas de flotantes, donde la longitud de la lista externa corresponderá al tamaño del lote y la longitud de la lista interna corresponderá al número de hipótesis devueltas. El valor debe ser >= 1.

    Echa un vistazo al ejemplo de decode() para comprender mejor cómo aprovechar output_word_offsets. batch_decode() funciona de la misma manera con salidas por lotes.

Decodifica por lotes los logits de salida en transcripción de audio con soporte de modelo de lenguaje.

Esta función utiliza el módulo multiprocessing de Python. Actualmente, multiprocessing solo está disponible en sistemas Unix (consulte este issue).

Si está decodificando varios lotes, considere crear un Pool y pasarlo a batch_decode. De lo contrario, batch_decode será muy lento, ya que creará un Pool nuevo para cada llamada. Consulte el ejemplo de uso a continuación.

Ejemplo: Vea Decodificación de varios audios.

decode

< >

( logits: ndarraybeam_width: int | None = Nonebeam_prune_logp: float | None = Nonetoken_min_logp: float | None = Nonehotwords: collections.abc.Iterable[str] | None = Nonehotword_weight: float | None = Nonealpha: float | None = Nonebeta: float | None = Noneunk_score_offset: float | None = Nonelm_score_boundary: bool | None = Noneoutput_word_offsets: bool = Falsen_best: int = 1 )

Parámetros

  • logits (np.ndarray) — Vector de salida de logits del modelo que representa las probabilidades logarítmicas de cada token.
  • beam_width (int, opcional) — Número máximo de haces en cada paso de la decodificación. El valor predeterminado es DEFAULT_BEAM_WIDTH de pyctcdecode.
  • beam_prune_logp (int, opcional) — Umbral para podar los haces con log-probs menores que best_beam_logp + beam_prune_logp. El valor debe ser <= 0. El valor predeterminado es DEFAULT_PRUNE_LOGP de pyctcdecode.
  • token_min_logp (int, opcional) — Los tokens con log-probs por debajo de token_min_logp se omiten, a menos que tengan el log-prob máximo para una utterance. El valor predeterminado es DEFAULT_MIN_TOKEN_LOGP de pyctcdecode.
  • hotwords (list[str], opcional) — Lista de palabras con importancia adicional que pueden faltar en el vocabulario del LM, p. ej. [“huggingface”]
  • hotword_weight (int, opcional) — Multiplicador de peso que aumenta las puntuaciones de las palabras clave. El valor predeterminado es DEFAULT_HOTWORD_WEIGHT de pyctcdecode.
  • alpha (float, opcional) — Peso del modelo de lenguaje durante la fusión superficial
  • beta (float, opcional) — Peso para el ajuste de la puntuación de longitud durante la puntuación
  • unk_score_offset (float, opcional) — Cantidad de desplazamiento de la puntuación log para los tokens desconocidos
  • lm_score_boundary (bool, opcional) — Si se debe tener en cuenta los límites al puntuar con kenlm
  • output_word_offsets (bool, opcional, valor predeterminado False) — Indica si se deben o no mostrar los desplazamientos de las palabras. Los desplazamientos de las palabras se pueden utilizar en combinación con la tasa de muestreo y la tasa de submuestreo del modelo para calcular las marcas de tiempo de las palabras transcritas.
  • n_best (int, opcional, por defecto 1) — Número de mejores hipótesis a devolver. Si n_best es mayor que 1, el valor devuelto de text será una lista de cadenas de caracteres, logit_score será una lista de valores flotantes y lm_score será una lista de valores flotantes, donde la longitud de estas listas corresponderá al número de hipótesis devueltas. El valor debe ser >= 1.

    Eche un vistazo al siguiente ejemplo para comprender mejor cómo aprovechar output_word_offsets.

Decodifica los logits de salida a una transcripción de audio con soporte de modelo de lenguaje.

Ejemplo:

>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoProcessor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch

>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")

>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)

>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = processor(sample["audio"]["array"], return_tensors="pt").input_values
>>> with torch.no_grad():
...     logits = model(input_values).logits[0].cpu().numpy()

>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = processor.decode(logits, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate

>>> word_offsets = [
...     {
...         "word": d["word"],
...         "start_time": round(d["start_offset"] * time_offset, 2),
...         "end_time": round(d["end_offset"] * time_offset, 2),
...     }
...     for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:4]
[{'word': 'THE', 'start_time': 0.68, 'end_time': 0.78}, {'word': 'TRACK', 'start_time': 0.88, 'end_time': 1.1}, {'word': 'APPEARS', 'start_time': 1.18, 'end_time': 1.66}, {'word': 'ON', 'start_time': 1.86, 'end_time': 1.92}]

Decodificación de varios audios

Si planeas decodificar varios lotes de audios, debes considerar usar batch_decode() y pasar una instancia de multiprocessing.Pool. De lo contrario, el rendimiento de batch_decode() será más lento que llamar a decode() para cada audio individualmente, ya que internamente instancia un nuevo Pool para cada llamada. Consulta el siguiente ejemplo:

# Let's see how to use a user-managed pool for batch decoding multiple audios
from multiprocessing import get_context

import datasets
import torch
from datasets import load_dataset

from transformers import AutoModelForCTC, AutoProcessor


# import model, feature extractor, tokenizer
model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm", device_map="auto")
processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")

# load example dataset
dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))


def map_to_array(example):
    example["speech"] = example["audio"]["array"]
    return example


# prepare speech data for batch inference
dataset = dataset.map(map_to_array, remove_columns=["audio"])


def map_to_pred(batch, pool):
    inputs = processor(batch["speech"], sampling_rate=16_000, padding=True, return_tensors="pt").to(model.device)
    inputs = {k: v.to(model.device) for k, v in inputs.items()}

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

    transcription = processor.batch_decode(logits.cpu().numpy(), pool).text
    batch["transcription"] = transcription
    return batch


# note: pool should be instantiated *after* `Wav2Vec2ProcessorWithLM`.
#       otherwise, the LM won't be available to the pool's sub-processes
# select number of processes and batch_size based on number of CPU cores available and on dataset size
with get_context("fork").Pool(processes=2) as pool:
    result = dataset.map(
        map_to_pred, batched=True, batch_size=2, fn_kwargs={"pool": pool}, remove_columns=["speech"]
    )

result["transcription"][:2]
['MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL', "NOR IS MISTER COULTER'S MANNER LESS INTERESTING THAN HIS MATTER"]

Salidas específicas de Wav2Vec2

clase transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput

< >

( text: list[list[str]] | list[str] | strlogit_score: list[list[float]] | list[float] | float = Nonelm_score: list[list[float]] | list[float] | float = Noneword_offsets: list[list[list[dict[str, int | str]]]] | list[list[dict[str, int | str]]] | list[dict[str, int | str]] = None )

Parámetros

  • text (lista de str o str) — Logits decodificados en texto. Normalmente, la transcripción del habla.
  • logit_score (lista de float o float) — Puntuación total de logits de los haces asociados con el texto generado.
  • lm_score (lista de float) — lm_score fusionado de los beams asociados con el texto generado.
  • word_offsets (lista de list[dict[str, Union[int, str]]] o list[dict[str, Union[int, str]]]) — Desplazamientos de las palabras decodificadas. En combinación con la tasa de muestreo y la tasa de submuestreo del modelo, los desplazamientos de las palabras se pueden utilizar para calcular marcas de tiempo para cada palabra.

Tipo de salida de Wav2Vec2DecoderWithLM, con transcripción.

clase transformers.modeling_outputs.Wav2Vec2BaseModelOutput

< >

( last_hidden_state: typing.Optional[torch.Tensor] = Noneextract_features: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )

Parámetros

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.
  • extract_features (torch.Tensor de forma (batch_size, sequence_length, conv_dim[-1])) — Secuencia de vectores de características extraídos de la última capa convolucional del modelo.
  • hidden_states (tuple(torch.Tensor), opcional, se devuelve cuando output_hidden_states=True se pasa o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (uno para la salida de las incrustaciones + uno 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 de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) con 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.

Clase base para modelos que han sido entrenados con el objetivo de pérdida de Wav2Vec2.

clase transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput

< >

( loss: typing.Optional[torch.Tensor] = Noneprojected_states: typing.Optional[torch.Tensor] = Noneprojected_quantized_states: typing.Optional[torch.Tensor] = Nonecodevector_perplexity: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = Nonecontrastive_loss: typing.Optional[torch.Tensor] = Nonediversity_loss: typing.Optional[torch.Tensor] = None )

Parámetros

  • loss (*optional*, returned when sample_negative_indices are passed, torch.Tensor of shape (1,)) — Total loss as the sum of the contrastive loss (L_m) and the diversity loss (L_d) as stated in the official paper.
  • projected_states (torch.Tensor de forma (batch_size, sequence_length, config.proj_codevector_dim)) — Estados ocultos del modelo proyectados a config.proj_codevector_dim que pueden utilizarse para predecir los estados cuantizados proyectados enmascarados.
  • projected_quantized_states (torch.Tensor de forma (batch_size, sequence_length, config.proj_codevector_dim)) — Vectores de características extraídas cuantizadas y proyectados a config.proj_codevector_dim que representan los vectores objetivo positivos para la pérdida contrastiva.
  • codevector_perplexity (torch.Tensor de forma (1,)) — La perplejidad de la distribución de codevector, utilizada para medir la diversidad del codebook.
  • hidden_states (tuple[torch.Tensor], opcional, se devuelve cuando output_hidden_states=True se pasa o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno 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 output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) con 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.

  • contrastive_loss (*optional*, returned when sample_negative_indices are passed, torch.Tensor of shape (1,)) — The contrastive loss (L_m) as stated in the official paper.
  • diversity_loss (*optional*, returned when sample_negative_indices are passed, torch.Tensor of shape (1,)) — The diversity loss (L_d) as stated in the official paper.

Tipo de salida de Wav2Vec2ForPreTraining, con posibles estados ocultos y atenciones.

Wav2Vec2Model

clase transformers.Wav2Vec2Model

< >

( config: Wav2Vec2Config )

Parámetros

  • config (Wav2Vec2Config) — 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() para cargar los pesos del modelo.

El modelo Wav2Vec2 básico que genera estados ocultos sin ninguna cabeza específica en la parte superior.

Este modelo hereda de PreTrainedModel. Consulta 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 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

< >

( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonemask_time_indices: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Wav2Vec2BaseModelOutput or tuple(torch.Tensor)

Parámetros

  • input_values (torch.Tensor de forma (batch_size, sequence_length), opcional) — Valores flotantes de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio .flac o .wav en un array de tipo list[float], un numpy.ndarray o un torch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array como input_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipo torch.Tensor. Consulte Wav2Vec2Processor.call() para más detalles.
  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • mask_time_indices (torch.BoolTensor de forma (batch_size, sequence_length), opcional) — Índices para enmascarar las características extraídas para la pérdida contrastiva. Cuando está en modo de entrenamiento, el modelo aprende a predecir las características extraídas enmascaradas en el espacio config.proj_codevector_dim.

Devuelve

Wav2Vec2BaseModelOutput o tuple(torch.Tensor)

Un Wav2Vec2BaseModelOutput 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 (Wav2Vec2Config) y las entradas.

El método forward de Wav2Vec2Model sobrescribe 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 pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

  • extract_features (torch.Tensor de forma (batch_size, sequence_length, conv_dim[-1])) — Secuencia de vectores de características extraídos de la última capa convolucional del modelo.

  • 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 + 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 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.

Wav2Vec2ForCTC

clase transformers.Wav2Vec2ForCTC

< >

( config: Wav2Vec2Configtarget_lang: str | None = None )

Parámetros

  • config (Wav2Vec2Config) — 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() para cargar los pesos del modelo.
  • target_lang (str, opcional) — Idioma de los pesos del adaptador. Los pesos del adaptador se almacenan en el formato adapter..safetensors o adapter..bin. Solo es relevante al usar una instancia de Wav2Vec2ForCTC con adaptadores. Usa ‘eng’ de forma predeterminada.

Modelo Wav2Vec2 con una cabeza de language modeling en la parte superior para la clasificación temporal conexionista (CTC).

Este modelo hereda de PreTrainedModel. Consulta 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 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

< >

( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutput or tuple(torch.Tensor)

Parámetros

  • input_values (torch.Tensor de forma (batch_size, sequence_length), opcional) — Valores flotantes de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio .flac o .wav en un array de tipo list[float], un numpy.ndarray o un torch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array como input_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipo torch.Tensor. Consulte Wav2Vec2Processor.call() para más detalles.
  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • labels (torch.LongTensor de forma (batch_size, target_length), opcional) — Etiquetas para la clasificación temporal conexionista. Tenga en cuenta que target_length debe ser menor o igual que la longitud de la secuencia de los logits de salida. Los índices se seleccionan en [-100, 0, ..., config.vocab_size - 1]. Todas las etiquetas establecidas en -100 se ignoran (se enmascaran); la pérdida solo se calcula para las etiquetas en [0, ..., config.vocab_size - 1].

Devuelve

CausalLMOutput o tuple(torch.Tensor)

Un CausalLMOutput 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 (Wav2Vec2Config) y las entradas.

El método forward de Wav2Vec2ForCTC 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 pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).

  • hidden_states (tuple(torch.Tensor), opcional, devuelto 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:

>>> from transformers import AutoProcessor, Wav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...

load_adapter

< >

( target_lang: strforce_load = True**kwargs )

Parámetros

  • target_lang (str) — Debe ser un identificador de idioma de un peso de adaptador existente. Los pesos de adaptador se almacenan en el formato adapter..safetensors o adapter..bin
  • force_load (bool, valor predeterminado True) — Indica si las ponderaciones deben cargarse incluso si target_lang coincide con self.target_lang.
  • cache_dir (Union[str, os.PathLike], opcional) — Ruta a un directorio en el que se debe almacenar en caché la configuración de un modelo preentrenado descargado si no se debe utilizar la caché estándar.
  • force_download (bool, opcional, valor predeterminado False) — Indica si se debe forzar la (re)descarga de los pesos del modelo y los archivos de configuración, ignorando las versiones en caché si existen.
  • proxies (dict[str, str], opcional) — Un diccionario de servidores proxy a utilizar por protocolo o punto de acceso, p. ej., {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. Los proxies se utilizan en cada solicitud.
  • local_files_only(bool, opcional, valor predeterminado False) — Indica si se deben buscar únicamente archivos locales (es decir, no intentar descargar el modelo).
  • token (str o bool, opcional) — El token que se usará como autorización HTTP bearer para archivos remotos. Si es True, o no se especifica, se usará el token generado al ejecutar hf auth login (almacenado en ~/.huggingface).
  • revision (str, opcional, por defecto "main") — La versión específica del modelo que se va a usar. Puede ser el nombre de una rama, el nombre de una etiqueta o un id de commit, ya que usamos un sistema basado en git para almacenar modelos y otros artefactos en huggingface.co, por lo que revision puede ser cualquier identificador permitido por git.

    Para probar una solicitud de extracción (pull request) que hayas realizado en el Hub, puedes pasar revision="refs/pr/<pr_number>".

  • mirror (str, opcional) — Origen de espejo para acelerar las descargas en China. Si resides en China y tienes problemas de acceso, puedes establecer esta opción para resolverlos. Ten en cuenta que no garantizamos la actualidad ni la seguridad. Consulta el sitio del espejo para obtener más información.

Cargue un modelo de adaptador de lenguaje desde un modelo de adaptador preentrenado.

Active el modo especial “offline-mode” para usar este método en un entorno con cortafuegos.

Ejemplos:

>>> from transformers import Wav2Vec2ForCTC, AutoProcessor

>>> ckpt = "facebook/mms-1b-all"
>>> processor = AutoProcessor.from_pretrained(ckpt)
>>> model = Wav2Vec2ForCTC.from_pretrained(ckpt, target_lang="eng")
>>> # set specific language
>>> processor.tokenizer.set_target_lang("spa")
>>> model.load_adapter("spa")

Wav2Vec2ForSequenceClassification

clase transformers.Wav2Vec2ForSequenceClassification

< >

( config: Wav2Vec2Config )

Parámetros

  • config (Wav2Vec2Config) — 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() para cargar los pesos del modelo.

Modelo Wav2Vec2 con una cabeza de clasificación de secuencias en la parte superior (una capa lineal sobre la salida agrupada) para tareas como SUPERB Keyword Spotting.

Este modelo hereda de PreTrainedModel. Consulta 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 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

< >

( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SequenceClassifierOutput or tuple(torch.Tensor)

Parámetros

  • input_values (torch.Tensor de forma (batch_size, sequence_length)) — Valores flotantes de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio .flac o .wav en un array de tipo list[float], un numpy.ndarray o un torch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array como input_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipo torch.Tensor. Consulte Wav2Vec2Processor.call() para más detalles.
  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • labels (torch.LongTensor de forma (batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en [0, ..., config.num_labels - 1]. Si config.num_labels == 1 se calcula una pérdida de regresión (pérdida de error cuadrático medio), si config.num_labels > 1 se calcula una pérdida de clasificación (entropía cruzada).

Devuelve

SequenceClassifierOutput o tuple(torch.Tensor)

Un SequenceClassifierOutput 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 (Wav2Vec2Config) y las entradas.

El método forward de Wav2Vec2ForSequenceClassification sobrescribe 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 pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de clasificación (o de regresión si config.num_labels==1).

  • logits (torch.Tensor de forma (batch_size, config.num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).

  • hidden_states (tuple(torch.Tensor), opcional, devuelto 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 de clasificación de una sola etiqueta:

>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h")

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

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...

Ejemplo de clasificación multietiqueta:

>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", problem_type="multi_label_classification")

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

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained(
...     "facebook/wav2vec2-base-960h", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

Wav2Vec2ForAudioFrameClassification

clase transformers.Wav2Vec2ForAudioFrameClassification

< >

( config: Wav2Vec2Config )

Parámetros

  • config (Wav2Vec2Config) — 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() para cargar los pesos del modelo.

El modelo Wav2Vec2 con una cabeza de clasificación de tramos en la parte superior para tareas como la diarización de hablantes.

Este modelo hereda de PreTrainedModel. Consulta 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 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

< >

( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → TokenClassifierOutput or tuple(torch.Tensor)

Parámetros

  • input_values (torch.Tensor de forma (batch_size, sequence_length)) — Valores flotantes de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio .flac o .wav en un array de tipo list[float], un numpy.ndarray o un torch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array como input_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipo torch.Tensor. Consulte Wav2Vec2Processor.call() para más detalles.
  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • labels (torch.LongTensor de forma (batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en [0, ..., config.num_labels - 1]. Si config.num_labels == 1 se calcula una pérdida de regresión (pérdida de error cuadrático medio), si config.num_labels > 1 se calcula una pérdida de clasificación (entropía cruzada).

Devuelve

TokenClassifierOutput o tuple(torch.Tensor)

Un TokenClassifierOutput 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 (Wav2Vec2Config) y las entradas.

El método forward de Wav2Vec2ForAudioFrameClassification sobrescribe 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 pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de clasificación.

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.num_labels)) — Puntuaciones de clasificación (antes de SoftMax).

  • hidden_states (tuple(torch.Tensor), opcional, devuelto 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:

>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForAudioFrameClassification
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForAudioFrameClassification.from_pretrained("facebook/wav2vec2-base-960h")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate)
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> probabilities = torch.sigmoid(logits[0])
>>> # labels is a one-hot array of shape (num_frames, num_speakers)
>>> labels = (probabilities > 0.5).long()
>>> labels[0].tolist()
...

Wav2Vec2ForXVector

clase transformers.Wav2Vec2ForXVector

< >

( config: Wav2Vec2Config )

Parámetros

  • config (Wav2Vec2Config) — 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() para cargar los pesos del modelo.

Modelo Wav2Vec2 con una cabeza de extracción de características XVector en la parte superior para tareas como la Verificación de Orador.

Este modelo hereda de PreTrainedModel. Consulta 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 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

< >

( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → XVectorOutput or tuple(torch.Tensor)

Parámetros

  • input_values (torch.Tensor de forma (batch_size, sequence_length)) — Valores flotantes de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio .flac o .wav en un array de tipo list[float], un numpy.ndarray o un torch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array como input_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipo torch.Tensor. Consulte Wav2Vec2Processor.call() para más detalles.
  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • labels (torch.LongTensor de forma (batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en [0, ..., config.num_labels - 1]. Si config.num_labels == 1 se calcula una pérdida de regresión (pérdida de error cuadrático medio), si config.num_labels > 1 se calcula una pérdida de clasificación (entropía cruzada).

Devuelve

XVectorOutput o tuple(torch.Tensor)

Un XVectorOutput 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 (Wav2Vec2Config) y las entradas.

El método forward de Wav2Vec2ForXVector 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 pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de clasificación.

  • logits (torch.Tensor de forma (batch_size, config.xvector_output_dim)) — Estados ocultos de clasificación antes de AMSoftmax.

  • embeddings (torch.Tensor de forma (batch_size, config.xvector_output_dim)) — Embeddings de enunciado utilizados para la recuperación basada en similitud de vectores.

  • 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 + 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 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:

>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForXVector
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForXVector.from_pretrained("facebook/wav2vec2-base-960h")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
...     [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
...     embeddings = model(**inputs).embeddings

>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()

>>> # the resulting embeddings can be used for cosine similarity-based retrieval
>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7  # the optimal threshold is dataset-dependent
>>> if similarity < threshold:
...     print("Speakers are not the same!")
>>> round(similarity.item(), 2)
...

Wav2Vec2ForPreTraining

clase transformers.Wav2Vec2ForPreTraining

< >

( config: Wav2Vec2Config )

Parámetros

  • config (Wav2Vec2Config) — 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() para cargar los pesos del modelo.

Modelo Wav2Vec2 con un cuantizador y una cabeza VQ en la parte superior.

Este modelo hereda de PreTrainedModel. Consulta 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 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

< >

( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonemask_time_indices: typing.Optional[torch.BoolTensor] = Nonesampled_negative_indices: typing.Optional[torch.BoolTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Wav2Vec2ForPreTrainingOutput or tuple(torch.Tensor)

Parámetros

  • input_values (torch.Tensor de forma (batch_size, sequence_length), opcional) — Valores flotantes de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio .flac o .wav en un array de tipo list[float], un numpy.ndarray o un torch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array como input_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipo torch.Tensor. Consulte Wav2Vec2Processor.call() para más detalles.
  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • mask_time_indices (torch.BoolTensor de forma (batch_size, sequence_length), opcional) — Índices para enmascarar las características extraídas para la pérdida contrastiva. Cuando está en modo de entrenamiento, el modelo aprende a predecir las características extraídas enmascaradas en el espacio config.proj_codevector_dim.
  • sampled_negative_indices (torch.BoolTensor de forma (batch_size, sequence_length, num_negatives), opcional) — Índices que indican qué vectores objetivo cuantizados se utilizan como vectores negativos muestreados en la pérdida contrastiva. Entrada obligatoria para el preentrenamiento.

Devuelve

Wav2Vec2ForPreTrainingOutput o tuple(torch.Tensor)

Un Wav2Vec2ForPreTrainingOutput 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 (Wav2Vec2Config) y las entradas.

El método forward de Wav2Vec2ForPreTraining 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 pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (*optional*, returned when sample_negative_indices are passed, torch.Tensor of shape (1,)) — Pérdida total como la suma de la pérdida contrastiva (L_m) y la pérdida de diversidad (L_d), tal como se indica en el artículo oficial.

  • projected_states (torch.Tensor de forma (batch_size, sequence_length, config.proj_codevector_dim)) — Estados ocultos del modelo proyectados a config.proj_codevector_dim que pueden utilizarse para predecir los estados cuantizados proyectados enmascarados.

  • projected_quantized_states (torch.Tensor de forma (batch_size, sequence_length, config.proj_codevector_dim)) — Vectores de características extraídas cuantizadas proyectados a config.proj_codevector_dim que representan los vectores objetivo positivos para la pérdida contrastiva.

  • codevector_perplexity (torch.Tensor de forma (1,)) — La perplejidad de la distribución de codevector, utilizada para medir la diversidad del codebook.

  • 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.

  • contrastive_loss (*optional*, returned when sample_negative_indices are passed, torch.Tensor of shape (1,)) — The contrastive loss (L_m) as stated in the official paper.

  • diversity_loss (*optional*, returned when sample_negative_indices are passed, torch.Tensor of shape (1,)) — The diversity loss (L_d) as stated in the official paper.

Ejemplo:

>>> import torch
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForPreTraining
>>> from transformers.models.wav2vec2.modeling_wav2vec2 import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
>>> model = Wav2Vec2ForPreTraining.from_pretrained("facebook/wav2vec2-base")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").input_values  # Batch size 1

>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length).item()
>>> mask_time_indices = _compute_mask_indices(
...     shape=(batch_size, sequence_length), mask_prob=0.2, mask_length=2
... )
>>> sampled_negative_indices = _sample_negative_indices(
...     features_shape=(batch_size, sequence_length),
...     num_negatives=model.config.num_negatives,
...     mask_time_indices=mask_time_indices,
... )
>>> mask_time_indices = torch.tensor(data=mask_time_indices, device=input_values.device, dtype=torch.long)
>>> sampled_negative_indices = torch.tensor(
...     data=sampled_negative_indices, device=input_values.device, dtype=torch.long
... )

>>> with torch.no_grad():
...     outputs = model(input_values, mask_time_indices=mask_time_indices)

>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = torch.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states, dim=-1)

>>> # show that cosine similarity is much higher than random
>>> cosine_sim[mask_time_indices.to(torch.bool)].mean() > 0.5
tensor(True)

>>> # for contrastive loss training model should be put into train mode
>>> model = model.train()
>>> loss = model(
...     input_values, mask_time_indices=mask_time_indices, sampled_negative_indices=sampled_negative_indices
... ).loss
Update on GitHub

←VITS Wav2Vec2-BERT→