Transformers documentation
Wav2Vec2-Conformer
Este modelo se publicó en HF papers el 2020-10-11 y se contribuyó a Hugging Face Transformers el 2022-05-17.
Wav2Vec2-Conformer
Resumen
Wav2Vec2-Conformer se añadió a una versión actualizada de fairseq S2T: Fast Speech-to-Text Modeling with fairseq de Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Sravya Popuri, Dmytro Okhonko y Juan Pino.
Los resultados oficiales del modelo se pueden encontrar en la Tabla 3 y la Tabla 4 del artículo.
Los pesos de Wav2Vec2-Conformer fueron publicados por el equipo de Meta AI dentro de la biblioteca Fairseq.
Este modelo fue aportado por patrickvonplaten. El código original se puede encontrar aquí.
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.
Consejos de uso
- Wav2Vec2-Conformer sigue la misma arquitectura que Wav2Vec2, pero reemplaza el bloque Attention por un bloque Conformer, tal como se introdujo en Conformer: Convolution-augmented Transformer for Speech Recognition.
- Para el mismo número de capas, Wav2Vec2-Conformer requiere más parámetros que Wav2Vec2, pero también ofrece una tasa de error de palabra mejorada.
- Wav2Vec2-Conformer utiliza el mismo tokenizador y extractor de características que Wav2Vec2.
- Wav2Vec2-Conformer puede usar embeddings de posición relativos, embeddings de posición similares a los de Transformer-XL o embeddings de posición rotatorios, estableciendo el valor correcto de
config.position_embeddings_type.
Recursos
Wav2Vec2ConformerConfig
clase transformers.Wav2Vec2ConformerConfig
< source >( 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 = Nonehidden_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 = 16apply_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 = Noneposition_embeddings_type: str | None = 'relative'rotary_embedding_base: int = 10000max_source_positions: int = 5000conv_depthwise_kernel_size: int = 31conformer_conv_dropout: float | int = 0.1 )
Parámetros
- vocab_size (
int, opcional) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse medianteinput_ids. - hidden_size (
int, opcional, valor predeterminado768) — Dimensión de las representaciones ocultas. - num_hidden_layers (
int, opcional, valor predeterminado12) — Número de capas ocultas en el decodificador del Transformer. - num_attention_heads (
int, opcional, valor predeterminado12) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer. - intermediate_size (
int, opcional, valor predeterminado3072) — Dimensión de las representaciones del MLP. - hidden_act (
str, opcional, valor predeterminadogelu) — 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 predeterminado0.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 predeterminado0.1) — La proporción de dropout para las activaciones dentro de la capa totalmente conectada. - attention_dropout (
Union[float, int], opcional, valor predeterminado0.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 Wav2Vec2ConformerForCTC. - layerdrop (
Union[float, int], opcional, valor predeterminado0.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 predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - layer_norm_eps (
float, opcional, valor predeterminado1e-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]olist[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]olist[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]olist[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 predeterminadoFalse) — 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. - apply_spec_augment (
bool, opcional, valor predeterminadoTrue) — 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 ifapply_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 longitudmask_feature_lengthgeneradas a lo largo del eje temporal, en cada paso de tiempo, independientemente demask_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 ifapply_spec_augment is True`. - mask_feature_prob (
Union[float, int], opcional, valor predeterminado0.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 generamask_feature_prob*len(feature_axis)/mask_time_lengthmá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 serprob_vector_start*mask_feature_length. Tenga en cuenta que la superposición puede disminuir el porcentaje real de vectores enmascarados. Esto solo es relevante siapply_spec_augmentesTrue. - 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 longitudmask_feature_lengthgeneradas a lo largo del eje de características, en cada paso de tiempo, independientemente demask_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 predeterminadosum) — Especifica la reducción que se debe aplicar a la salida detorch.nn.CTCLoss. Solo es relevante durante el entrenamiento. - ctc_zero_infinity (
bool, opcional, valor predeterminadoFalse) — Indica si se deben poner a cero las pérdidas infinitas y los gradientes asociados detorch.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 Wav2Vec2ConformerForCTC. - use_weighted_layer_sum (
bool, opcional, valor predeterminadoFalse) — Indica si se debe utilizar una media ponderada de las salidas de las capas con pesos aprendidos. Solo es relevante al usar una instancia de Wav2Vec2ConformerForSequenceClassification. - 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]olist[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]olist[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]olist[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 predeterminado0) — Id del token utilizado para el relleno en el vocabulario. - bos_token_id (
int, opcional, valor predeterminado1) — Id del token utilizado para el inicio de la secuencia en el vocabulario. - eos_token_id (
Union[int, list[int]], opcional, valor predeterminado2) — Identificador de token utilizado para el fin de secuencia en el vocabulario. - add_adapter (
bool, opcional, valor predeterminadoFalse) — Indica si se debe apilar una red convolucional sobre el codificador Wav2Vec2Conformer. Puede ser muy útil para iniciar el entrenamiento de Wav2Vec2Conformer en 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 siadd_adapter is True. - adapter_stride (
int, opcional, valor predeterminado 2) — Paso de las capas convolucionales en la red adaptadora. Solo es relevante siadd_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 siadd_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 siadd_adapter is True. - position_embeddings_type (
str, opcional, valor predeterminado"relative") — Puede especificarse comorelativeorotarypara embeddings de posición relativos o rotatorios, respectivamente. Si se deja enNone, no se aplica ningún embedding de posición relativo. - rotary_embedding_base (
int, opcional, valor predeterminado: 10000) — Si se utilizan embeddings de posición"rotary", define el tamaño de la base del embedding. - max_source_positions (
int, opcional, valor predeterminado 5000) — si se usan embeddings de posición"relative", define las posiciones de entrada de origen máximas. - conv_depthwise_kernel_size (
int, opcional, valor predeterminado 31) — Tamaño del kernel de la capa convolucional depthwise 1D en los bloques Conformer. - conformer_conv_dropout (
float, opcional, valor predeterminado 0.1) — La probabilidad de dropout para todas las capas convolucionales en los bloques Conformer.
Esta es la clase de configuración para almacenar la configuración de un Wav2Vec2 ConformerModel. Se utiliza para instanciar un modelo Wav2Vec2 Conformer 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-conformer-rel-pos-large
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 Wav2Vec2ConformerConfig, Wav2Vec2ConformerModel
>>> # Initializing a Wav2Vec2Conformer facebook/wav2vec2-conformer-rel-pos-large style configuration
>>> configuration = Wav2Vec2ConformerConfig()
>>> # Initializing a model (with random weights) from the facebook/wav2vec2-conformer-rel-pos-large style configuration
>>> model = Wav2Vec2ConformerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configSalidas específicas de Wav2Vec2Conformer
clase transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput
< source >( 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 whensample_negative_indicesare passed,torch.Tensorof 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.Tensorde 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.Tensorde 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.Tensorde 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 cuandooutput_hidden_states=Truese pasa o cuandoconfig.output_hidden_states=True) — Tupla detorch.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 cuandooutput_attentions=Truese pasa o cuandoconfig.output_attentions=True) — Tupla detorch.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 whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — The contrastive loss (L_m) as stated in the official paper. - diversity_loss (
*optional*, returned whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — The diversity loss (L_d) as stated in the official paper.
Tipo de salida de Wav2Vec2ConformerForPreTraining, con estados ocultos y atenciones potenciales.
Wav2Vec2ConformerModel
clase transformers.Wav2Vec2ConformerModel
< source >( config: Wav2Vec2ConformerConfig )
Parámetros
- config (Wav2Vec2ConformerConfig) — 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 Conformer básico que genera estados ocultos sin ningún cabezal específico 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
< source >( 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.Tensorde 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.flaco.waven un array de tipolist[float], unnumpy.ndarrayo untorch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array comoinput_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipotorch.Tensor. Consulte Wav2Vec2Processor.call() para más detalles. - attention_mask (
torch.Tensorde 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.
- mask_time_indices (
torch.BoolTensorde 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 (Wav2Vec2ConformerConfig) y las entradas.
El método forward de Wav2Vec2ConformerModel 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
Moduledespué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.Tensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.extract_features (
torch.Tensorde 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 pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
Wav2Vec2ConformerForCTC
clase transformers.Wav2Vec2ConformerForCTC
< source >( config: Wav2Vec2ConformerConfigtarget_lang: str | None = None )
Parámetros
- config (Wav2Vec2ConformerConfig) — 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 UniSpeechSatForCTC con adaptadores. Usa ‘eng’ de forma predeterminada.
Modelo Wav2Vec2Conformer con una cabeza de language modeling en la parte superior para Connectionist Temporal Classification (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
< source >( 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.Tensorde 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.flaco.waven un array de tipolist[float], unnumpy.ndarrayo untorch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array comoinput_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipotorch.Tensor. Consulte Wav2Vec2Processor.call() para más detalles. - attention_mask (
torch.Tensorde 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.
- labels (
torch.LongTensorde forma(batch_size, target_length), opcional) — Etiquetas para la clasificación temporal conexionista. Tenga en cuenta quetarget_lengthdebe 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-100se 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 (Wav2Vec2ConformerConfig) y las entradas.
El método forward de Wav2Vec2ConformerForCTC 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).logits (
torch.Tensorde 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 pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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, Wav2Vec2ConformerForCTC
>>> 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-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForCTC.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> # 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)
...Wav2Vec2ConformerForSequenceClassification
clase transformers.Wav2Vec2ConformerForSequenceClassification
< source >( config: Wav2Vec2ConformerConfig )
Parámetros
- config (Wav2Vec2ConformerConfig) — 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 Wav2Vec2Conformer 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
< source >( 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.Tensorde 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.flaco.waven un array de tipolist[float], unnumpy.ndarrayo untorch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array comoinput_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipotorch.Tensor. ConsulteWav2Vec2ConformerProcessor.__call__para más detalles. - attention_mask (
torch.Tensorde 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.
- labels (
torch.LongTensorde 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]. Siconfig.num_labels == 1se calcula una pérdida de regresión (pérdida de error cuadrático medio), siconfig.num_labels > 1se 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 (Wav2Vec2ConformerConfig) y las entradas.
El método forward de Wav2Vec2ConformerForSequenceClassification 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación (o de regresión si config.num_labels==1).logits (
torch.Tensorde 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 pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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, Wav2Vec2ConformerForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForSequenceClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> 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 = Wav2Vec2ConformerForSequenceClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large", 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, Wav2Vec2ConformerForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForSequenceClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large", 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 = Wav2Vec2ConformerForSequenceClassification.from_pretrained(
... "facebook/wav2vec2-conformer-rel-pos-large", 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).lossWav2Vec2ConformerForAudioFrameClassification
clase transformers.Wav2Vec2ConformerForAudioFrameClassification
< source >( config: Wav2Vec2ConformerConfig )
Parámetros
- config (Wav2Vec2ConformerConfig) — 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 Conformer 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
< source >( 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.Tensorde 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.flaco.waven un array de tipolist[float], unnumpy.ndarrayo untorch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array comoinput_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipotorch.Tensor. ConsulteWav2Vec2ConformerProcessor.__call__para más detalles. - attention_mask (
torch.Tensorde 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.
- labels (
torch.LongTensorde 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]. Siconfig.num_labels == 1se calcula una pérdida de regresión (pérdida de error cuadrático medio), siconfig.num_labels > 1se 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 (Wav2Vec2ConformerConfig) y las entradas.
El método forward de Wav2Vec2ConformerForAudioFrameClassification 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación.logits (
torch.Tensorde forma(batch_size, sequence_length, config.num_labels)) — Puntuaciones de clasificación (antes de SoftMax).hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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, Wav2Vec2ConformerForAudioFrameClassification
>>> 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-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForAudioFrameClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> # 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()
...Wav2Vec2ConformerForXVector
clase transformers.Wav2Vec2ConformerForXVector
< source >( config: Wav2Vec2ConformerConfig )
Parámetros
- config (Wav2Vec2ConformerConfig) — 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 Wav2Vec2Conformer 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
< source >( 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.Tensorde 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.flaco.waven un array de tipolist[float], unnumpy.ndarrayo untorch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array comoinput_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipotorch.Tensor. ConsulteWav2Vec2ConformerProcessor.__call__para más detalles. - attention_mask (
torch.Tensorde 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.
- labels (
torch.LongTensorde 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]. Siconfig.num_labels == 1se calcula una pérdida de regresión (pérdida de error cuadrático medio), siconfig.num_labels > 1se 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 (Wav2Vec2ConformerConfig) y las entradas.
El método forward de Wav2Vec2ConformerForXVector 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación.logits (
torch.Tensorde forma(batch_size, config.xvector_output_dim)) — Estados ocultos de clasificación antes de AMSoftmax.embeddings (
torch.Tensorde 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 pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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, Wav2Vec2ConformerForXVector
>>> 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-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForXVector.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> # 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)
...Wav2Vec2ConformerForPreTraining
clase transformers.Wav2Vec2ConformerForPreTraining
< source >( config: Wav2Vec2ConformerConfig )
Parámetros
- config (Wav2Vec2ConformerConfig) — 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 Wav2Vec2Conformer 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
< source >( 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'> ) → Wav2Vec2ConformerForPreTrainingOutput or tuple(torch.Tensor)
Parámetros
- input_values (
torch.Tensorde 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.flaco.waven un array de tipolist[float], unnumpy.ndarrayo untorch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array comoinput_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipotorch.Tensor. Consulte Wav2Vec2Processor.call() para más detalles. - attention_mask (
torch.Tensorde 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.
- mask_time_indices (
torch.BoolTensorde 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.BoolTensorde 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
Wav2Vec2ConformerForPreTrainingOutput o tuple(torch.Tensor)
Un Wav2Vec2ConformerForPreTrainingOutput 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 (Wav2Vec2ConformerConfig) y las entradas.
El método forward de Wav2Vec2ConformerForPreTraining 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
Moduledespué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 whensample_negative_indicesare passed,torch.Tensorof 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.Tensorde 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.Tensorde 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.Tensorde 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 pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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 whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — La pérdida contrastiva (L_m) tal como se indica en el artículo oficial.diversity_loss (
*optional*, returned whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — The diversity loss (L_d) as stated in the official paper.
Ejemplo:
>>> import torch
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ConformerForPreTraining
>>> from transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2_conformer-base")
>>> model = Wav2Vec2ConformerForPreTraining.from_pretrained("facebook/wav2vec2_conformer-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