# Wav2Vec2-BERT

## Visão geral

O modelo [Wav2Vec2-BERT](https://huggingface.co/papers/2312.05187) foi proposto em [Seamless: Multilingual Expressive and Streaming Speech Translation](https://ai.meta.com/research/publications/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, melhoraram 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 ajudam a comunicação mediada por máquinas a parecer 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 de forma em streaming. Primeiro, contribuímos com uma versão aprimorada do modelo massivamente multilíngue e multimodal SeamlessM4T — o SeamlessM4T v2. Este modelo mais novo, 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 atenuar 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 expressiva entre idiomas 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](https://huggingface.co/ylacombe). O código original pode ser encontrado [aqui](https://github.com/facebookresearch/seamless_communication).

## 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 nenhum embedding de posição relativa, 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

- Você também pode adaptar esses notebooks sobre [como ajustar um modelo de reconhecimento de fala em inglês](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/speech_recognition.ipynb) e [como ajustar um modelo de reconhecimento de fala em qualquer idioma](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multi_lingual_speech_recognition.ipynb).

- Veja também: [Guia da tarefa de classificação de áudio](../tasks/audio_classification)

## Wav2Vec2BertConfig[[transformers.Wav2Vec2BertConfig]]

#### transformers.Wav2Vec2BertConfig[[transformers.Wav2Vec2BertConfig]]

```python
transformers.Wav2Vec2BertConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int | None = None, hidden_size: int = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 16, intermediate_size: int = 4096, feature_projection_input_dim: int = 160, hidden_act: str = 'swish', hidden_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, attention_dropout: float | int = 0.0, feat_proj_dropout: float | int = 0.0, final_dropout: float | int = 0.1, layerdrop: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, apply_spec_augment: bool = True, mask_time_prob: float | int = 0.05, mask_time_length: int = 10, mask_time_min_masks: int = 2, mask_feature_prob: float | int = 0.0, mask_feature_length: int = 10, mask_feature_min_masks: int = 0, ctc_loss_reduction: str = 'sum', ctc_zero_infinity: bool = False, use_weighted_layer_sum: bool = False, classifier_proj_size: int = 768, tdnn_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 = 512, pad_token_id: int | None = 0, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, add_adapter: bool = False, adapter_kernel_size: int = 3, adapter_stride: int = 2, num_adapter_layers: int = 1, adapter_act: str = 'relu', use_intermediate_ffn_before_adapter: bool = False, output_hidden_size: int | None = None, position_embeddings_type: typing.Optional[typing.Literal['rotary', 'relative', 'relative_key']] = 'relative_key', rotary_embedding_base: int = 10000, max_source_positions: int = 5000, left_max_position_embeddings: int = 64, right_max_position_embeddings: int = 8, conv_depthwise_kernel_size: int = 31, conformer_conv_dropout: float | int = 0.1)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/configuration_wav2vec2_bert.py#L26)

**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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) ou [Wav2Vec2BertProcessor](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.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](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertForCTC).

layerdrop (`Union[float, int]`, *opcional*, padrão `0.1`) : A probabilidade de LayerDrop. Consulte o [artigo do LayerDrop](see 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, veja [SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition](https://huggingface.co/papers/1904.08779).

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 passo 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 partir da probabilidade de cada vetor de características ser escolhido como o início do intervalo 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](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.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](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertForSequenceClassification).

classifier_proj_size (`int`, *opcional*, padrão 768) : Dimensionalidade 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 convolucional 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 convolucional 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 convolucional 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) : Dimensionalidade 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 do 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 do 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 do 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*) : Dimensionalidade 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 para: - `rotary`, para embeddings de posição rotativos. - `relative`, para embeddings de posição relativos. - `relative_key`, para embeddings de posição relativos conforme definidos por Shaw em [Self-Attention with Relative Position Representations (Shaw et al.)](https://huggingface.co/papers/1803.02155). Se deixado como `None`, nenhum embedding de posição relativo é aplicado.

rotary_embedding_base (`int`, *opcional*, padrão 10000) : Se os embeddings de posição `"rotary"` forem usados, define o tamanho da base do embedding.

max_source_positions (`int`, *opcional*, padrão 5000) : se os embeddings de posição `"relative"` forem usados, define as posições máximas de entrada da fonte.

left_max_position_embeddings (`int`, *opcional*, padrão 64) : Se os embeddings de posição `"relative_key"` (também conhecidos como Shaw) forem usados, define o valor de recorte à esquerda para as posições relativas.

right_max_position_embeddings (`int`, *opcional*, padrão 8) : Se os embeddings de posição `"relative_key"` (também conhecidos como Shaw) forem usados, define o valor de recorte à 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](https://huggingface.co/facebook/w2v-bert-2.0)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> 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[[transformers.Wav2Vec2BertProcessor]]

#### transformers.Wav2Vec2BertProcessor[[transformers.Wav2Vec2BertProcessor]]

```python
transformers.Wav2Vec2BertProcessor(feature_extractor, tokenizer)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/processing_wav2vec2_bert.py#L28)

**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](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) oferece todas as funcionalidades de [Wav2Vec2FeatureExtractor](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) e [Wav2Vec2CTCTokenizer](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer). Consulte [~Wav2Vec2FeatureExtractor](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) e [~Wav2Vec2CTCTokenizer](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer) para mais informações.

#### __call__[[transformers.Wav2Vec2BertProcessor.__call__]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/processing_wav2vec2_bert.py#L32)

**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 pretokenizada). Se você passar uma entrada pretokenizada, defina `is_split_into_words=True` para evitar ambiguidade com entradas em lote.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores 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](/docs/transformers/main/pt/main_classes/processors#transformers.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](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding)

Um [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.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. Retornado quando tanto `text` quanto `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[[transformers.Wav2Vec2BertProcessor.pad]]

```python
pad(input_features = None, labels = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/processing_wav2vec2_bert.py#L70)

Se `input_features` não for `None`, este método encaminha os argumentos `input_features` e `kwargs` para o [pad()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) do SeamlessM4TFeatureExtractor para preencher os recursos de entrada. Se `labels` não for `None`, este método encaminha os argumentos `labels` e `kwargs` para o [pad()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) do PreTrainedTokenizer para preencher o(s) rótulo(s). Consulte a docstring dos dois métodos acima para mais informações.

#### from_pretrained[[transformers.Wav2Vec2BertProcessor.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1750)

**Parâmetros:**

pretrained_model_name_or_path (`str` or `os.PathLike`) : This can be either:  - a string, the *model id* of a pretrained feature_extractor hosted inside a model repo on huggingface.co. - a path to a *directory* containing a feature extractor file saved using the [save_pretrained()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) method, e.g., `./my_model_directory/`. - a path to a saved feature extractor JSON *file*, e.g., `./my_model_directory/preprocessor_config.json`.

- ****kwargs** : Argumentos de palavra-chave adicionais passados tanto para [from_pretrained()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) quanto para `~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()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) do extrator de recursos, o método [ImageProcessingMixin](/docs/transformers/main/pt/internal/image_processing_utils#transformers.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[[transformers.Wav2Vec2BertProcessor.save_pretrained]]

```python
save_pretrained(save_directory, push_to_hub: bool = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1165)

**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 caso não exista).

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()](/docs/transformers/main/pt/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Salva os atributos deste processador (feature extractor, tokenizer...) no diretório especificado para que ele possa ser recarregado usando o método [from_pretrained()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Processor.from_pretrained).

Este método de classe simplesmente chama [save_pretrained()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) e [save_pretrained()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained). Consulte as docstrings dos métodos acima para mais informações.

#### batch_decode[[transformers.Wav2Vec2BertProcessor.batch_decode]]

```python
batch_decode(*args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2005)

Este método encaminha todos os seus argumentos para o [batch_decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações.

#### decode[[transformers.Wav2Vec2BertProcessor.decode]]

```python
decode(*args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2014)

Este método encaminha todos os seus argumentos para o [decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações.

## Wav2Vec2BertModel[[transformers.Wav2Vec2BertModel]]

#### transformers.Wav2Vec2BertModel[[transformers.Wav2Vec2BertModel]]

```python
transformers.Wav2Vec2BertModel(config: Wav2Vec2BertConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L940)

**Parâmetros:**

config ([Wav2Vec2BertConfig](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.Wav2Vec2BertModel.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, mask_time_indices: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1007)

**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](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Veja [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) para detalhes ([Wav2Vec2BertProcessor](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) usa [Wav2Vec2FeatureExtractor](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.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?](../glossary#attention-mask)

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](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.modeling_outputs.Wav2Vec2BaseModelOutput) ou `tuple(torch.Tensor)`

Um [Wav2Vec2BaseModelOutput](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) e das entradas.

O método forward do [Wav2Vec2BertModel](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.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 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 nas cabeças de autoatenção.

## Wav2Vec2BertForCTC[[transformers.Wav2Vec2BertForCTC]]

#### transformers.Wav2Vec2BertForCTC[[transformers.Wav2Vec2BertForCTC]]

```python
transformers.Wav2Vec2BertForCTC(config: Wav2Vec2BertConfig, target_lang: str | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1053)

**Parâmetros:**

config ([Wav2Vec2BertConfig](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

target_lang (`str`, *opcional*) : ID do 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](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.Wav2Vec2BertForCTC.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1083)

**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](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Veja [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) para detalhes ([Wav2Vec2BertProcessor](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) usa [Wav2Vec2FeatureExtractor](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.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?](../glossary#attention-mask)

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](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutput) ou `tuple(torch.Tensor)`

Um [CausalLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) e das entradas.

O método forward de [Wav2Vec2BertForCTC](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.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) com a 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 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 nas cabeças de autoatenção.

Exemplo:

```python
>>> 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[[transformers.Wav2Vec2BertForSequenceClassification]]

#### transformers.Wav2Vec2BertForSequenceClassification[[transformers.Wav2Vec2BertForSequenceClassification]]

```python
transformers.Wav2Vec2BertForSequenceClassification(config: Wav2Vec2BertConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1143)

**Parâmetros:**

config ([Wav2Vec2BertConfig](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.Wav2Vec2BertForSequenceClassification.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1169)

**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](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Veja [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) para detalhes ([Wav2Vec2BertProcessor](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) usa [Wav2Vec2FeatureExtractor](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.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?](../glossary#attention-mask)

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](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou `tuple(torch.Tensor)`

Um [SequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) e das entradas.

O método forward de [Wav2Vec2BertForSequenceClassification](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.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 de 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) com a 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 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 nas cabeças de autoatenção.

Exemplo de classificação de rótulo único:

```python
>>> 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:

```python
>>> 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[[transformers.Wav2Vec2BertForAudioFrameClassification]]

#### transformers.Wav2Vec2BertForAudioFrameClassification[[transformers.Wav2Vec2BertForAudioFrameClassification]]

```python
transformers.Wav2Vec2BertForAudioFrameClassification(config: Wav2Vec2BertConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1227)

**Parâmetros:**

config ([Wav2Vec2BertConfig](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.Wav2Vec2BertForAudioFrameClassification.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1252)

**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](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Veja [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) para detalhes ([Wav2Vec2BertProcessor](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) usa [Wav2Vec2FeatureExtractor](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.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?](../glossary#attention-mask)

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](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou `tuple(torch.Tensor)`

Um [TokenClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) e das entradas.

O método forward de [Wav2Vec2BertForAudioFrameClassification](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.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) com a 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 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 nas cabeças de autoatenção.

Exemplo:

```python
>>> 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[[transformers.Wav2Vec2BertForXVector]]

#### transformers.Wav2Vec2BertForXVector[[transformers.Wav2Vec2BertForXVector]]

```python
transformers.Wav2Vec2BertForXVector(config: Wav2Vec2BertConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1360)

**Parâmetros:**

config ([Wav2Vec2BertConfig](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.Wav2Vec2BertForXVector.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1403)

**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](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Veja [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) para detalhes ([Wav2Vec2BertProcessor](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) usa [Wav2Vec2FeatureExtractor](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.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?](../glossary#attention-mask)

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](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.XVectorOutput) ou `tuple(torch.Tensor)`

Um [XVectorOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) e das entradas.

O método forward de [Wav2Vec2BertForXVector](/docs/transformers/main/pt/model_doc/wav2vec2-bert#transformers.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 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 nas cabeças de autoatenção.

Exemplo:

```python
>>> 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)
...
```