Hugging Face's logo

Transformers documentation

Wav2Vec2-BERT

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

and get access to the augmented documentation experience

to get started

Este modelo foi publicado no HF papers em 2023-12-08 e contribuído para o Hugging Face Transformers em 2024-01-18.

SDPA

Wav2Vec2-BERT

Visão geral

O modelo Wav2Vec2-BERT foi proposto em Seamless: Multilingual Expressive and Streaming Speech Translation pela equipe de Comunicação Sem Emendas da Meta AI.

Este modelo foi pré-treinado em 4,5 milhões de horas de dados de áudio não rotulados, abrangendo mais de 143 idiomas. Ele requer ajuste fino para ser usado em tarefas de nível inferior, como Reconhecimento Automático de Fala (ASR) ou Classificação de Áudio.

Os resultados oficiais do modelo podem ser encontrados na Seção 3.2.1 do artigo.

O resumo do artigo é o seguinte:

Os avanços recentes na tradução automática de fala expandiram drasticamente a cobertura de idiomas, aprimoraram as capacidades multimodais e permitiram uma ampla variedade de tarefas e funcionalidades. Dito isso, os grandes sistemas de tradução automática de fala atuais carecem de recursos-chave que tornam a comunicação mediada por máquinas mais fluida quando comparada ao diálogo entre humanos. Neste trabalho, apresentamos uma família de modelos que permite traduções expressivas e multilíngues de ponta a ponta em modo de streaming. Primeiro, contribuímos com uma versão aprimorada do modelo massivamente multilíngue e multimodal SeamlessM4T — o SeamlessM4T v2. Este novo modelo, que incorpora o framework atualizado UnitY2, foi treinado com mais dados de idiomas de baixo recurso. A versão expandida do SeamlessAlign adiciona 114.800 horas de dados alinhados automaticamente, totalizando 76 idiomas. O SeamlessM4T v2 fornece a base a partir da qual nossos dois modelos mais recentes, SeamlessExpressive e SeamlessStreaming, são iniciados. O SeamlessExpressive permite traduções que preservam estilos vocais e prosódia. Em comparação com esforços anteriores em pesquisa de fala expressiva, nosso trabalho aborda certos aspectos subexplorados da prosódia, como a taxa de fala e as pausas, ao mesmo tempo em que preserva o estilo da voz. Quanto ao SeamlessStreaming, nosso modelo utiliza o mecanismo Efficient Monotonic Multihead Attention (EMMA) para gerar traduções de destino de baixa latência sem esperar pela conclusão das falas de origem. Como o primeiro do seu tipo, o SeamlessStreaming permite a tradução simultânea de fala para fala/texto para múltiplos idiomas de origem e destino. Para entender o desempenho desses modelos, combinamos métricas automáticas novas e versões modificadas de métricas existentes para avaliar prosódia, latência e robustez. Para as avaliações humanas, adaptamos protocolos existentes para medir os atributos mais relevantes na preservação de significado, naturalidade e expressividade. Para garantir que nossos modelos possam ser usados de forma segura e responsável, implementamos o primeiro esforço conhecido de red-teaming para tradução automática multimodal, um sistema para detecção e mitigação de toxicidade adicionada, uma avaliação sistemática de viés de gênero e um mecanismo de marca d'água localizada inaudível projetado para reduzir o impacto de deepfakes. Consequentemente, reunimos os principais componentes do SeamlessExpressive e do SeamlessStreaming para formar o Seamless, o primeiro sistema publicamente disponível que desbloqueia a comunicação interlinguística expressiva em tempo real. Em suma, o Seamless nos oferece uma visão fundamental da base técnica necessária para transformar o Tradutor Universal de Fala de um conceito de ficção científica em uma tecnologia do mundo real. Por fim, as contribuições deste trabalho — incluindo modelos, código e um detector de marca d'água — são publicamente liberados e acessíveis no link abaixo.

Este modelo foi contribuído por ylacombe. O código original pode ser encontrado aqui.

Dicas de uso

  • O Wav2Vec2-BERT segue a mesma arquitetura do Wav2Vec2-Conformer, mas emprega uma camada de convolução causal depthwise e utiliza como entrada uma representação de mel-espectrograma do áudio, em vez da forma de onda bruta.
  • O Wav2Vec2-BERT pode usar embeddings de posição relativos ausentes, embeddings de posição semelhantes aos de Shaw, embeddings de posição semelhantes aos do Transformer-XL ou embeddings de posição rotativos, definindo o config.position_embeddings_type correto.
  • O Wav2Vec2-BERT também introduz uma rede adaptadora baseada em Conformer, em vez de uma rede convolucional simples.

Recursos

Automatic Speech Recognition
Audio Classification

Wav2Vec2BertConfig

classe transformers.Wav2Vec2BertConfig

< >

( 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 = 1024num_hidden_layers: int = 24num_attention_heads: int = 16intermediate_size: int = 4096feature_projection_input_dim: int = 160hidden_act: str = 'swish'hidden_dropout: float | int = 0.0activation_dropout: float | int = 0.0attention_dropout: float | int = 0.0feat_proj_dropout: float | int = 0.0final_dropout: float | int = 0.1layerdrop: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-05apply_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 = 0ctc_loss_reduction: str = 'sum'ctc_zero_infinity: bool = Falseuse_weighted_layer_sum: bool = Falseclassifier_proj_size: int = 768tdnn_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 = 1adapter_act: str = 'relu'use_intermediate_ffn_before_adapter: bool = Falseoutput_hidden_size: int | None = Noneposition_embeddings_type: typing.Optional[typing.Literal['rotary', 'relative', 'relative_key']] = 'relative_key'rotary_embedding_base: int = 10000max_source_positions: int = 5000left_max_position_embeddings: int = 64right_max_position_embeddings: int = 8conv_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 pelos input_ids.
  • hidden_size (int, opcional, padrão 1024) — Dimensão das representações ocultas.
  • num_hidden_layers (int, opcional, padrão 24) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • intermediate_size (int, opcional, padrão 4096) — Dimensão das representações do MLP.
  • feature_projection_input_dim (int, opcional, padrão 160) — Dimensão de entrada deste modelo, ou seja, a dimensão após o processamento dos áudios de entrada com SeamlessM4TFeatureExtractor ou Wav2Vec2BertProcessor.
  • hidden_act (str, opcional, padrão swish) — 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ão 0.0) — A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.
  • activation_dropout (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as ativações dentro da camada totalmente conectada.
  • attention_dropout (Union[float, int], opcional, padrão 0.0) — 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 projeção de recursos.
  • final_dropout (float, opcional, padrão 0.1) — A probabilidade de dropout para a camada de projeção final de Wav2Vec2BertForCTC.
  • layerdrop (Union[float, int], opcional, padrão 0.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ão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • layer_norm_eps (float, opcional, padrão 1e-05) — O epsilon usado pelas camadas de normalização de camada.
  • apply_spec_augment (bool, opcional, padrão True) — 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_prob*len(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_start*mask_time_length. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant if apply_spec_augment is True`.
  • mask_time_length (int, opcional, 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 comprimento mask_feature_length geradas ao longo do eixo do tempo, em cada etapa de tempo, independentemente de mask_feature_prob. Relevante apenas se mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks.
  • mask_feature_prob (float, opcional, padrão 0.0) — Porcentagem (entre 0 e 1) de todos os vetores de características ao longo do eixo de características que serão mascarados. O procedimento de mascaramento gera mask_feature_prob*len(feature_axis)/mask_time_length máscaras independentes sobre o eixo. Se o raciocínio for feito a partir da probabilidade de cada vetor de características ser escolhido como o início do espano de vetores a ser mascarado, mask_feature_prob deve ser prob_vector_start*mask_feature_length. Observe que a sobreposição pode diminuir a porcentagem real de vetores mascarados. Isso é relevante apenas se apply_spec_augment is True.
  • 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 comprimento mask_feature_length geradas ao longo do eixo de recursos, a cada passo de tempo, independentemente de mask_feature_prob. Relevante apenas se mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks.
  • ctc_loss_reduction (str, opcional, padrão sum) — Especifica a redução a ser aplicada à saída de torch.nn.CTCLoss. Relevante apenas durante o treinamento.
  • ctc_zero_infinity (bool, opcional, padrão False) — Se deve zerar perdas infinitas e os gradientes associados de torch.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 Wav2Vec2BertForCTC.
  • use_weighted_layer_sum (bool, opcional, padrão False) — Se deve usar uma média ponderada das saídas das camadas com pesos aprendidos. Relevante apenas ao usar uma instância de Wav2Vec2BertForSequenceClassification.
  • classifier_proj_size (int, opcional, padrão 768) — Dimensão da projeção antes do token mean-pooling para classificação.
  • tdnn_dim (tuple[int] ou list[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] ou list[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] ou list[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ão 0) — ID do token usado para preenchimento no vocabulário.
  • bos_token_id (int, opcional, padrão 1) — ID do token usado para o início do fluxo no vocabulário.
  • eos_token_id (Union[int, list[int]], opcional, padrão 2) — ID do token usado para o fim do fluxo no vocabulário.
  • add_adapter (bool, opcional, padrão False) — Se uma rede de atenção convolucional deve ser empilhada sobre o Encoder do Wav2Vec2Bert. Pode ser muito útil para iniciar o Wav2Vec2Bert para modelos SpeechEncoderDecoder.
  • adapter_kernel_size (int, opcional, padrão 3) — Tamanho do kernel das camadas convolucionais na rede do adaptador. Relevante apenas se add_adapter is True.
  • adapter_stride (int, opcional, padrão 2) — Passo das camadas convolucionais na rede de adaptador. Relevante apenas se add_adapter is True.
  • num_adapter_layers (int, opcional, padrão 1) — Número de camadas convolucionais que devem ser usadas na rede de adaptador. Relevante apenas se add_adapter is True.
  • adapter_act (str ou function, opcional, padrão "relu") — A função de ativação não linear (função ou string) nas camadas de adaptador. Se for string, "gelu", "relu", "selu", "swish" e "gelu_new" são suportadas.
  • use_intermediate_ffn_before_adapter (bool, opcional, padrão False) — Se um bloco feed-forward intermediário deve ser empilhado sobre o Encoder do Wav2Vec2Bert e antes da rede adaptadora. Relevante apenas se add_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 se add_adapter is True.
  • position_embeddings_type (str, opcional, padrão é "relative_key") — Pode ser especificado como:
    • rotary, para embeddings de posição rotativos.
    • relative, para incorporações de posição relativa.
    • relative_key, para incorporações de posição relativa conforme definido por Shaw em Self-Attention with Relative Position Representations (Shaw et al.). Se deixado como None, nenhuma incorporação de posição relativa é aplicada.
  • 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.
  • left_max_position_embeddings (int, opcional, padrão 64) — Se forem usados embeddings de posição "relative_key" (também conhecidos como Shaw), define o valor de recorte à esquerda para as posições relativas.
  • right_max_position_embeddings (int, opcional, padrão 8) — Se forem usados embeddings de posição "relative_key" (também conhecidos como Shaw), define o valor de corte à direita para as posições relativas.
  • 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 BertModel. Ela é usada para instanciar um modelo Wav2Vec2 Bert 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/w2v-bert-2.0

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 Wav2Vec2BertConfig, Wav2Vec2BertModel

>>> # Initializing a Wav2Vec2Bert facebook/wav2vec2-bert-rel-pos-large style configuration
>>> configuration = Wav2Vec2BertConfig()

>>> # Initializing a model (with random weights) from the facebook/wav2vec2-bert-rel-pos-large style configuration
>>> model = Wav2Vec2BertModel(configuration)

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

Wav2Vec2BertProcessor

classe transformers.Wav2Vec2BertProcessor

< >

( feature_extractortokenizer )

Parâmetros

  • feature_extractor (Wav2Vec2FeatureExtractor) — O extrator de recursos é uma entrada obrigatória.
  • tokenizer (Wav2Vec2CTCTokenizer) — O tokenizer é uma entrada obrigatória.

Constrói um Wav2Vec2BertProcessor que encapsula um extrator de recursos e um tokenizador em um único processador.

Wav2Vec2BertProcessor oferece todas as funcionalidades de Wav2Vec2FeatureExtractor e Wav2Vec2CTCTokenizer. Consulte ~Wav2Vec2FeatureExtractor e ~Wav2Vec2CTCTokenizer para mais informações.

__call__

< >

( audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | None = None**kwargs: *<class 'transformers.models.wav2vec2_bert.processing_wav2vec2_bert.Wav2Vec2BertProcessorKwargs'> ) → BatchEncoding

Parâmetros

  • audio (Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor]], opcional) — O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio.
  • text (Union[str, list[str]], opcional) — A sequência ou lote de sequências a serem codificadas. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se você passar uma entrada pré-tokenizada, defina is_split_into_words=True para evitar ambiguidade com entradas em lote.
  • return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

Retorna

BatchEncoding

Um BatchEncoding com os seguintes campos:

  • input_features — Recursos de entrada de áudio a serem fornecidos a um modelo. Retornado quando audio não é None.
  • attention_mask — Lista de índices que especifica quais timestamps devem ser considerados pelo modelo quando audio não é None. Quando apenas text é especificado, retorna a máscara de atenção dos tokens.
  • labels — Lista de ids de tokens a serem fornecidos a um modelo. Retornada quando text e audio não são None.
  • input_ids — Lista de ids de tokens a serem fornecidos a um modelo. Retornado quando text não é None e audio é None.

pad

< >

( input_features = Nonelabels = None**kwargs )

Se input_features não for None, este método encaminha os argumentos input_features e kwargs para o pad() do SeamlessM4TFeatureExtractor para aplicar padding às features de entrada. Se labels não for None, este método encaminha os argumentos labels e kwargs para o pad() do PreTrainedTokenizer para aplicar padding ao(s) rótulo(s). Consulte a docstring dos dois métodos acima para mais informações.

from_pretrained

< >

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

Parâmetros

  • pretrained_model_name_or_path (str ou os.PathLike) — Pode ser:
    • uma string, o model id de um feature_extractor pré-treinado hospedado em um repositório de modelos no huggingface.co.
    • um caminho para um diretório contendo um arquivo de extrator de recursos salvo usando o método save_pretrained(), por exemplo, ./my_model_directory/.
    • um caminho para um arquivo JSON de extrator de recursos salvo file, por exemplo, ./my_model_directory/preprocessor_config.json.
  • **kwargs — Argumentos de palavra-chave adicionais passados para from_pretrained() e ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained.

Instancie um processador associado a um modelo pré-treinado.

Este método de classe simplesmente chama o método from_pretrained() do extrator de recursos, o método ImageProcessingMixin do processador de imagem e o método ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained do tokenizador. Consulte as docstrings dos métodos acima para mais informações.

save_pretrained

< >

( save_directorypush_to_hub: bool = False**kwargs )

Parâmetros

  • save_directory (str ou os.PathLike) — Diretório onde o arquivo JSON do extrator de recursos e os arquivos do tokenizer serão salvos (o diretório será criado se não existir).
  • push_to_hub (bool, opcional, padrão False) — Indica se o modelo deve ser enviado para o Hugging Face model hub após ser salvo. Você pode especificar o repositório de destino com repo_id (por padrão, será usado o nome de save_directory no seu namespace).
  • kwargs (dict[str, Any], opcional) — Argumentos de palavra-chave adicionais passados ao método push_to_hub().

Salva os atributos deste processador (extrator de recursos, tokenizador…) no diretório especificado para que ele possa ser recarregado usando o método from_pretrained().

Este método de classe simplesmente chama save_pretrained() e save_pretrained(). Consulte as docstrings dos métodos acima para mais informações.

batch_decode

< >

( *args**kwargs )

Este método encaminha todos os seus argumentos para o batch_decode() do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações.

decode

< >

( *args**kwargs )

Este método encaminha todos os seus argumentos para o decode() do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações.

Wav2Vec2BertModel

classe transformers.Wav2Vec2BertModel

< >

( config: Wav2Vec2BertConfig )

Parâmetros

  • config (Wav2Vec2BertConfig) — 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 Bert básico, que produz estados ocultos brutos sem nenhuma cabeça específica 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

< >

( input_features: 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_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim), opcional) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando Wav2Vec2FeatureExtractor. Consulte Wav2Vec2FeatureExtractor.call() para mais detalhes (Wav2Vec2BertProcessor usa Wav2Vec2FeatureExtractor para processar áudios).
  • attention_mask (torch.Tensor de 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.

    O que são máscaras de atenção?

  • mask_time_indices (torch.BoolTensor de 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 (Wav2Vec2BertConfig) e das entradas.

O método forward do Wav2Vec2BertModel 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 Module em 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.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

  • extract_features (torch.Tensor de 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 quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.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 quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.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.

Wav2Vec2BertForCTC

classe transformers.Wav2Vec2BertForCTC

< >

( config: Wav2Vec2BertConfigtarget_lang: str | None = None )

Parâmetros

  • config (Wav2Vec2BertConfig) — 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 Wav2Vec2Bert com uma cabeça 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

< >

( input_features: 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_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim), opcional) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando Wav2Vec2FeatureExtractor. Consulte Wav2Vec2FeatureExtractor.call() para mais detalhes (Wav2Vec2BertProcessor usa Wav2Vec2FeatureExtractor para processar áudios).
  • attention_mask (torch.Tensor de 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.

    O que são máscaras de atenção?

  • labels (torch.LongTensor de forma (batch_size, target_length), opcional) — Rótulos para classificação temporal conexionista. Observe que target_length deve 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 -100 sã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 (Wav2Vec2BertConfig) e das entradas.

O método forward de Wav2Vec2BertForCTC 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 Module em 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.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).

  • logits (torch.Tensor de 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 quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.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 quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.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, Wav2Vec2BertForCTC
>>> 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/w2v-bert-2.0")
>>> model = Wav2Vec2BertForCTC.from_pretrained("facebook/w2v-bert-2.0")

>>> # 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)
...

Wav2Vec2BertForSequenceClassification

classe transformers.Wav2Vec2BertForSequenceClassification

< >

( config: Wav2Vec2BertConfig )

Parâmetros

  • config (Wav2Vec2BertConfig) — 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 Wav2Vec2Bert 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

< >

( input_features: 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_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim), opcional) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando Wav2Vec2FeatureExtractor. Consulte Wav2Vec2FeatureExtractor.call() para mais detalhes (Wav2Vec2BertProcessor usa Wav2Vec2FeatureExtractor para processar áudios).
  • attention_mask (torch.Tensor de 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.

    O que são máscaras de atenção?

  • labels (torch.LongTensor de 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]. Se config.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Se config.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 (Wav2Vec2BertConfig) e das entradas.

O método forward de Wav2Vec2BertForSequenceClassification 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 Module em 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.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de classificação (ou regressão se config.num_labels==1).

  • logits (torch.Tensor de 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 quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.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 quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.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, Wav2Vec2BertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/w2v-bert-2.0")
>>> model = Wav2Vec2BertForSequenceClassification.from_pretrained("facebook/w2v-bert-2.0")

>>> 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 = Wav2Vec2BertForSequenceClassification.from_pretrained("facebook/w2v-bert-2.0", 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, Wav2Vec2BertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/w2v-bert-2.0")
>>> model = Wav2Vec2BertForSequenceClassification.from_pretrained("facebook/w2v-bert-2.0", 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 = Wav2Vec2BertForSequenceClassification.from_pretrained(
...     "facebook/w2v-bert-2.0", num_labels=num_labels, problem_type="multi_label_classification"
... )

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

Wav2Vec2BertForAudioFrameClassification

classe transformers.Wav2Vec2BertForAudioFrameClassification

< >

( config: Wav2Vec2BertConfig )

Parâmetros

  • config (Wav2Vec2BertConfig) — 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 Bert 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

< >

( input_features: 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_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim), opcional) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando Wav2Vec2FeatureExtractor. Consulte Wav2Vec2FeatureExtractor.call() para mais detalhes (Wav2Vec2BertProcessor usa Wav2Vec2FeatureExtractor para processar áudios).
  • attention_mask (torch.Tensor de 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.

    O que são máscaras de atenção?

  • labels (torch.LongTensor de 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]. Se config.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Se config.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 (Wav2Vec2BertConfig) e das entradas.

O método forward de Wav2Vec2BertForAudioFrameClassification 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 Module em 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.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de classificação.

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.num_labels)) — Pontuações de classificação (antes do SoftMax).

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.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 quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.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, Wav2Vec2BertForAudioFrameClassification
>>> 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/w2v-bert-2.0")
>>> model = Wav2Vec2BertForAudioFrameClassification.from_pretrained("facebook/w2v-bert-2.0")

>>> # 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()
...

Wav2Vec2BertForXVector

classe transformers.Wav2Vec2BertForXVector

< >

( config: Wav2Vec2BertConfig )

Parâmetros

  • config (Wav2Vec2BertConfig) — 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 Wav2Vec2Bert com um cabeçalho 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

< >

( input_features: 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_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim), opcional) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando Wav2Vec2FeatureExtractor. Consulte Wav2Vec2FeatureExtractor.call() para mais detalhes (Wav2Vec2BertProcessor usa Wav2Vec2FeatureExtractor para processar áudios).
  • attention_mask (torch.Tensor de 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.

    O que são máscaras de atenção?

  • labels (torch.LongTensor de 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]. Se config.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Se config.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 (Wav2Vec2BertConfig) e das entradas.

O método forward de Wav2Vec2BertForXVector 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 Module em 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.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de classificação.

  • logits (torch.Tensor de forma (batch_size, config.xvector_output_dim)) — Estados ocultos de classificação antes do AMSoftmax.

  • embeddings (torch.Tensor de 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 quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.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 quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.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, Wav2Vec2BertForXVector
>>> 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/w2v-bert-2.0")
>>> model = Wav2Vec2BertForXVector.from_pretrained("facebook/w2v-bert-2.0")

>>> # 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)
...
Update on GitHub

←Wav2Vec2 Wav2Vec2-Conformer→