Transformers documentation
Wav2Vec2-Conformer
Este modelo foi publicado no HF papers em 2020-10-11 e contribuído para o Hugging Face Transformers em 2022-05-17.
Wav2Vec2-Conformer
Visão geral
O Wav2Vec2-Conformer foi adicionado a uma versão atualizada do fairseq S2T: Fast Speech-to-Text Modeling with fairseq, de Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Sravya Popuri, Dmytro Okhonko e Juan Pino.
Os resultados oficiais do modelo podem ser encontrados na Tabela 3 e na Tabela 4 do artigo.
Os pesos do Wav2Vec2-Conformer foram liberados pela equipe da Meta AI dentro da biblioteca Fairseq.
Este modelo foi contribuído por patrickvonplaten. O código original pode ser encontrado aqui.
Nota: a Meta (FAIR) lançou uma nova versão do Wav2Vec2-BERT 2.0 - ela foi pré-treinada em 4,5 milhões de horas de áudio. Recomendamos especialmente o seu uso em tarefas de fine-tuning, por exemplo, conforme este guia.
Dicas de uso
- O Wav2Vec2-Conformer segue a mesma arquitetura do Wav2Vec2, mas substitui o bloco Attention por um bloco Conformer, conforme introduzido em Conformer: Convolution-augmented Transformer for Speech Recognition.
- Para o mesmo número de camadas, o Wav2Vec2-Conformer requer mais parâmetros do que o Wav2Vec2, mas também produz uma taxa de erro de palavra melhorada.
- O Wav2Vec2-Conformer usa o mesmo tokenizer e feature extractor que o Wav2Vec2.
- O Wav2Vec2-Conformer pode usar embeddings de posição relativos ausentes, embeddings de posição semelhantes aos do Transformer-XL ou embeddings de posição rotativos, definindo o
config.position_embeddings_typecorreto.
Recursos
Wav2Vec2ConformerConfig
classe 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) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - hidden_size (
int, opcional, padrão768) — Dimensão das representações ocultas. - num_hidden_layers (
int, opcional, padrão12) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão12) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - intermediate_size (
int, opcional, padrão3072) — Dimensão das representações do MLP. - hidden_act (
str, opcional, padrãogelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - hidden_dropout (
Union[float, int], opcional, padrão0.1) — A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder e pooler. - activation_dropout (
Union[float, int], opcional, padrão0.1) — A taxa de dropout para as ativações dentro da camada totalmente conectada. - attention_dropout (
Union[float, int], opcional, padrão0.1) — A taxa de dropout para as probabilidades de atenção. - feat_proj_dropout (
float, opcional, padrão 0.0) — A probabilidade de dropout para a saída do codificador de recursos. - feat_quantizer_dropout (
float, opcional, padrão 0.0) — A probabilidade de dropout para a saída do codificador de recursos usado pelo quantizador. - final_dropout (
float, opcional, padrão 0.1) — A probabilidade de dropout para a camada de projeção final de Wav2Vec2ConformerForCTC. - layerdrop (
Union[float, int], opcional, padrão0.1) — A probabilidade do LayerDrop. Consulte o [artigo do LayerDrop](veja https://huggingface.co/papers/1909.11556) para mais detalhes. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - layer_norm_eps (
float, opcional, padrão1e-05) — O epsilon usado pelas camadas de normalização de camada. - feat_extract_norm (
str, opcional, padrão"group") — A normalização a ser aplicada às camadas convolucionais 1D no codificador de recursos. Pode ser"group"para normalização por grupo apenas da primeira camada convolucional 1D ou"layer"para normalização por camada de todas as camadas convolucionais 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]oulist[int], opcional, padrão(512, 512, 512, 512, 512, 512, 512)) — Uma tupla de inteiros que define o número de canais de entrada e saída de cada camada convolucional 1D no codificador de recursos. O comprimento de conv_dim define o número de camadas convolucionais 1D. - conv_stride (
tuple[int]oulist[int], opcional, padrão(5, 2, 2, 2, 2, 2, 2)) — Uma tupla de inteiros que define o stride de cada camada convolucional 1D no codificador de recursos. O comprimento de conv_stride define o número de camadas convolucionais e deve corresponder ao comprimento de conv_dim. - conv_kernel (
tuple[int]oulist[int], opcional, padrão(10, 3, 3, 3, 3, 3, 3)) — Uma tupla de inteiros que define o tamanho do kernel de cada camada convolucional 1D no codificador de recursos. O tamanho de conv_kernel define o número de camadas convolucionais e deve corresponder ao tamanho de conv_dim. - conv_bias (
bool, opcional, padrãoFalse) — Indica se as camadas de convolução 1D possuem viés. - num_conv_pos_embeddings (
int, opcional, padrão 128) — Número de embeddings posicionais convolucionais. Define o tamanho do kernel da camada de embeddings posicionais convolucionais 1D. - num_conv_pos_embedding_groups (
int, opcional, padrão 16) — Número de grupos da camada de embeddings posicionais convolucionais 1D. - apply_spec_augment (
bool, opcional, padrãoTrue) — Indica se a ampliação de dados SpecAugment deve ser aplicada às saídas do codificador de recursos. Para referência, 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, padrão 10) — Comprimento da extensão do vetor ao longo do eixo do tempo. - mask_time_min_masks (
int, opcional, padrão 2), — O número mínimo de máscaras de comprimentomask_feature_lengthgeradas ao longo do eixo do tempo, em cada passo de tempo, independentemente demask_feature_prob. Relevante apenas se ”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, padrão0.0) — Porcentagem (entre 0 e 1) de todos os vetores de recursos ao longo do eixo de recursos que serão mascarados. O procedimento de mascaramento geramask_feature_prob*len(feature_axis)/mask_time_lengthmáscaras independentes sobre o eixo. Se o raciocínio for feito a partir da probabilidade de cada vetor de recurso ser escolhido como o início do espano de vetores a ser mascarado, mask_feature_prob deve serprob_vector_start*mask_feature_length. Observe que a sobreposição pode diminuir a porcentagem real de vetores mascarados. Isso é relevante apenas seapply_spec_augmentforTrue. - mask_feature_length (
int, opcional, padrão 10) — Comprimento da extensão do vetor ao longo do eixo de recursos. - mask_feature_min_masks (
int, opcional, padrão 0), — O número mínimo de máscaras de comprimentomask_feature_lengthgeradas ao longo do eixo de recursos, a cada passo de tempo, independentemente demask_feature_prob. Relevante apenas se ”mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks” - num_codevectors_per_group (
int, opcional, padrão 320) — Número de entradas em cada livro de quantização (grupo). - num_codevectors_per_group (
int, opcional, padrão 320) — Número de entradas em cada livro de quantização (grupo). - num_codevector_groups (
int, opcional, padrão 2) — Número de grupos de codevector para quantização de codevector por produto. - contrastive_logits_temperature (
float, opcional, padrão 0.1) — A temperatura kappa na perda contrastiva. - num_negatives (
int, opcional, padrão 100) — Número de amostras negativas para a perda contrastiva. - codevector_dim (
int, opcional, padrão 256) — Dimensão dos vetores de recursos quantizados. - proj_codevector_dim (
int, opcional, padrão 256) — Dimensão da projeção final tanto das features quantizadas quanto das features do transformer. - diversity_loss_weight (
int, opcional, padrão 0.1) — O peso do componente de perda de diversidade do codebook. - ctc_loss_reduction (
str, opcional, padrãosum) — Especifica a redução a ser aplicada à saída detorch.nn.CTCLoss. Relevante apenas durante o treinamento. - ctc_zero_infinity (
bool, opcional, padrãoFalse) — Se deve zerar perdas infinitas e os gradientes associados detorch.nn.CTCLoss. Perdas infinitas ocorrem principalmente quando as entradas são curtas demais para serem alinhadas aos alvos. Relevante apenas ao treinar uma instância de Wav2Vec2ConformerForCTC. - use_weighted_layer_sum (
bool, opcional, padrãoFalse) — Se deve usar uma média ponderada das saídas das camadas com pesos aprendidos. Relevante apenas ao usar uma instância de Wav2Vec2ConformerForSequenceClassification. - classifier_proj_size (
int, opcional, padrão 256) — Dimensão da projeção antes do token mean-pooling para classificação. - tdnn_dim (
tuple[int]oulist[int], opcional, padrão(512, 512, 512, 512, 1500)) — Uma tupla de inteiros que define o número de canais de saída de cada camada de convolução 1D no módulo TDNN do modelo XVector. O comprimento de tdnn_dim define o número de camadas TDNN. - tdnn_kernel (
tuple[int]oulist[int], opcional, padrão(5, 3, 3, 1, 1)) — Uma tupla de inteiros que define o tamanho do kernel de cada camada de convolução 1D no módulo TDNN do modelo XVector. O comprimento de tdnn_kernel deve corresponder ao comprimento de tdnn_dim. - tdnn_dilation (
tuple[int]oulist[int], opcional, padrão(1, 2, 3, 1, 1)) — Uma tupla de inteiros que define o fator de dilatação de cada camada de convolução 1D no módulo TDNN do modelo XVector. O comprimento de tdnn_dilation deve corresponder ao comprimento de tdnn_dim. - xvector_output_dim (
int, opcional, padrão 512) — Dimensão dos vetores de incorporação XVector. - pad_token_id (
int, opcional, padrão0) — ID do token usado para preenchimento no vocabulário. - bos_token_id (
int, opcional, padrão1) — ID do token usado para o início do fluxo no vocabulário. - eos_token_id (
Union[int, list[int]], opcional, padrão2) — ID do token usado para o fim do fluxo no vocabulário. - add_adapter (
bool, opcional, padrãoFalse) — Se uma rede convolucional deve ser empilhada sobre o Encoder Wav2Vec2Conformer. Pode ser muito útil para iniciar o treinamento (warm-start) do Wav2Vec2Conformer para modelos SpeechEncoderDecoder. - adapter_kernel_size (
int, opcional, padrão 3) — Tamanho do kernel das camadas convolucionais na rede do adaptador. Relevante apenas seadd_adapter is True. - adapter_stride (
int, opcional, padrão 2) — Passo das camadas convolucionais na rede de adaptador. Relevante apenas seadd_adapter is True. - num_adapter_layers (
int, opcional, padrão 3) — Número de camadas convolucionais que devem ser usadas na rede de adaptador. Relevante apenas seadd_adapter is True. - output_hidden_size (
int, opcional) — Dimensão da camada de saída do codificador. Se não for definida, o valor padrão é hidden-size. Relevante apenas seadd_adapter is True. - position_embeddings_type (
str, opcional, padrão"relative") — Pode ser especificado comorelativeourotarypara embeddings de posição relativos ou rotativos, respectivamente. Se deixado comoNone, nenhum embedding de posição relativo é aplicado. - rotary_embedding_base (
int, opcional, padrão 10000) — Se forem usados embeddings de posição"rotary", define o tamanho da base do embedding. - max_source_positions (
int, opcional, padrão 5000) — se forem usados embeddings de posição"relative", define as posições máximas de entrada da fonte. - conv_depthwise_kernel_size (
int, opcional, padrão 31) — Tamanho do kernel da camada convolucional depthwise 1D nos blocos Conformer. - conformer_conv_dropout (
float, opcional, padrão 0.1) — A probabilidade de dropout para todas as camadas convolucionais nos blocos Conformer.
Esta é a classe de configuração para armazenar a configuração de um Wav2Vec2 ConformerModel. Ela é usada para instanciar um modelo Wav2Vec2 Conformer de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do facebook/wav2vec2-conformer-rel-pos-large
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
Exemplo:
>>> 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.configSaídas específicas do Wav2Vec2Conformer
classe 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,)) — Perda total como a soma da perda contrastiva (L_m) e da perda de diversidade (L_d), conforme descrito no artigo oficial. - projected_states (
torch.Tensorde forma(batch_size, sequence_length, config.proj_codevector_dim)) — Estados ocultos do modelo projetados para config.proj_codevector_dim que podem ser usados para prever os estados quantizados projetados mascarados. - projected_quantized_states (
torch.Tensorde forma(batch_size, sequence_length, config.proj_codevector_dim)) — Vetores de recursos extraídos quantizados projetados em config.proj_codevector_dim, representando os vetores-alvo positivos para a perda contrastiva. - codevector_perplexity (
torch.Tensorde forma(1,)) — A perplexidade da distribuição de codevector, usada para medir a diversidade do codebook. - hidden_states (
tuple[torch.Tensor], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- attentions (
tuple[torch.Tensor], opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com a forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
- 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 saída de Wav2Vec2ConformerForPreTraining, com estados ocultos e atenções potenciais.
Wav2Vec2ConformerModel
classe transformers.Wav2Vec2ConformerModel
< source >( config: Wav2Vec2ConformerConfig )
Parâmetros
- config (Wav2Vec2ConformerConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo Wav2Vec2 Conformer básico, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
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 em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão em um tensor do tipotorch.Tensor. Consulte Wav2Vec2Processor.call() para mais detalhes. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- mask_time_indices (
torch.BoolTensorde forma(batch_size, sequence_length), opcional) — Índices para mascarar os recursos extraídos para a perda contrastiva. Quando em modo de treinamento, o modelo aprende a prever os recursos extraídos mascarados no espaço config.proj_codevector_dim.
Retorna
Wav2Vec2BaseModelOutput ou tuple(torch.Tensor)
Um Wav2Vec2BaseModelOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (Wav2Vec2ConformerConfig) e das entradas.
O método forward do Wav2Vec2ConformerModel sobrescreve o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.extract_features (
torch.Tensorde forma(batch_size, sequence_length, conv_dim[-1])) — Sequência de vetores de características extraídos da última camada convolucional do modelo.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Wav2Vec2ConformerForCTC
classe transformers.Wav2Vec2ConformerForCTC
< source >( config: Wav2Vec2ConformerConfigtarget_lang: str | None = None )
Parâmetros
- config (Wav2Vec2ConformerConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
- target_lang (
str, opcional) — Idioma dos pesos do adaptador. Os pesos do adaptador são armazenados no formato adapter..safetensors ou adapter. .bin. Relevante apenas ao usar uma instância de UniSpeechSatForCTC com adaptadores. Usa ‘eng’ por padrão.
Modelo Wav2Vec2Conformer com um cabeçalho de language modeling no topo para Connectionist Temporal Classification (CTC).
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
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 em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão em um tensor do tipotorch.Tensor. Consulte Wav2Vec2Processor.call() para mais detalhes. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- labels (
torch.LongTensorde forma(batch_size, target_length), opcional) — Rótulos para classificação temporal conexionista. Observe quetarget_lengthdeve ser menor ou igual ao comprimento da sequência dos logits de saída. Os índices são selecionados em[-100, 0, ..., config.vocab_size - 1]. Todos os rótulos definidos como-100são ignorados (mascarados); a perda é calculada apenas para rótulos em[0, ..., config.vocab_size - 1].
Retorna
CausalLMOutput ou tuple(torch.Tensor)
Um CausalLMOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (Wav2Vec2ConformerConfig) e das entradas.
O método forward de Wav2Vec2ConformerForCTC substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Exemplo:
>>> 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
classe transformers.Wav2Vec2ConformerForSequenceClassification
< source >( config: Wav2Vec2ConformerConfig )
Parâmetros
- config (Wav2Vec2ConformerConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
Modelo Wav2Vec2Conformer com uma cabeça de classificação de sequência no topo (uma camada linear sobre a saída agregada) para tarefas como SUPERB Keyword Spotting.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
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 em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão em um tensor do tipotorch.Tensor. ConsulteWav2Vec2ConformerProcessor.__call__para mais detalhes. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em[0, ..., config.num_labels - 1]. Seconfig.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Seconfig.num_labels > 1, uma perda de classificação é calculada (entropia cruzada).
Retorna
SequenceClassifierOutput ou tuple(torch.Tensor)
Um SequenceClassifierOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (Wav2Vec2ConformerConfig) e das entradas.
O método forward de Wav2Vec2ConformerForSequenceClassification sobrescreve o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de classificação (ou regressão se config.num_labels==1).logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Exemplo de classificação de rótulo único:
>>> 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)
...Exemplo de classificação multirótulo:
>>> 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
classe transformers.Wav2Vec2ConformerForAudioFrameClassification
< source >( config: Wav2Vec2ConformerConfig )
Parâmetros
- config (Wav2Vec2ConformerConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O Modelo Wav2Vec2 Conformer com uma cabeça de classificação de quadro no topo para tarefas como Diarização de Falantes.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
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 em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão em um tensor do tipotorch.Tensor. ConsulteWav2Vec2ConformerProcessor.__call__para mais detalhes. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em[0, ..., config.num_labels - 1]. Seconfig.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Seconfig.num_labels > 1, uma perda de classificação é calculada (entropia cruzada).
Retorna
TokenClassifierOutput ou tuple(torch.Tensor)
Um TokenClassifierOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (Wav2Vec2ConformerConfig) e das entradas.
O método forward de Wav2Vec2ConformerForAudioFrameClassification substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de classificação.logits (
torch.Tensorde forma(batch_size, sequence_length, config.num_labels)) — Pontuações de classificação (antes do SoftMax).hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Exemplo:
>>> 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
classe transformers.Wav2Vec2ConformerForXVector
< source >( config: Wav2Vec2ConformerConfig )
Parâmetros
- config (Wav2Vec2ConformerConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
Modelo Wav2Vec2Conformer com uma cabeça de extração de recursos XVector no topo para tarefas como Verificação de Falante.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
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 em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão em um tensor do tipotorch.Tensor. ConsulteWav2Vec2ConformerProcessor.__call__para mais detalhes. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em[0, ..., config.num_labels - 1]. Seconfig.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Seconfig.num_labels > 1, uma perda de classificação é calculada (entropia cruzada).
Retorna
XVectorOutput ou tuple(torch.Tensor)
Um XVectorOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (Wav2Vec2ConformerConfig) e das entradas.
O método forward de Wav2Vec2ConformerForXVector substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de classificação.logits (
torch.Tensorde forma(batch_size, config.xvector_output_dim)) — Estados ocultos de classificação antes do AMSoftmax.embeddings (
torch.Tensorde forma(batch_size, config.xvector_output_dim)) — Embeddings de fala usados para recuperação baseada em similaridade vetorial.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Exemplo:
>>> 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
classe transformers.Wav2Vec2ConformerForPreTraining
< source >( config: Wav2Vec2ConformerConfig )
Parâmetros
- config (Wav2Vec2ConformerConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
Modelo Wav2Vec2Conformer com um quantizador e uma cabeça VQ no topo.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
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 em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão em um tensor do tipotorch.Tensor. Consulte Wav2Vec2Processor.call() para mais detalhes. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- mask_time_indices (
torch.BoolTensorde forma(batch_size, sequence_length), opcional) — Índices para mascarar os recursos extraídos para a perda contrastiva. Quando em modo de treinamento, o modelo aprende a prever os recursos extraídos mascarados no espaço config.proj_codevector_dim. - sampled_negative_indices (
torch.BoolTensorde forma(batch_size, sequence_length, num_negatives), opcional) — Índices que indicam quais vetores de destino quantizados são usados como vetores negativos amostrados na perda contrastiva. Entrada obrigatória para o pré-treinamento.
Retorna
Wav2Vec2ConformerForPreTrainingOutput ou tuple(torch.Tensor)
Um Wav2Vec2ConformerForPreTrainingOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (Wav2Vec2ConformerConfig) e das entradas.
O método forward de Wav2Vec2ConformerForPreTraining sobrescreve o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
*optional*, returned whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — Perda total como a soma da perda contrastiva (L_m) e da perda de diversidade (L_d), conforme descrito no artigo oficial.projected_states (
torch.Tensorde forma(batch_size, sequence_length, config.proj_codevector_dim)) — Hidden-states do modelo projetados para config.proj_codevector_dim que podem ser usados para prever os estados quantizados mascarados projetados.projected_quantized_states (
torch.Tensorde forma(batch_size, sequence_length, config.proj_codevector_dim)) — Vetores de características extraídas quantizados e projetados para config.proj_codevector_dim, representando os vetores-alvo positivos para a perda contrastiva.codevector_perplexity (
torch.Tensorde forma(1,)) — A perplexidade da distribuição de codevector, usada para medir a diversidade do codebook.hidden_states (
tuple[torch.Tensor], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple[torch.Tensor], opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
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.
Exemplo:
>>> 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