# Wav2Vec2
## Visão geral
O modelo Wav2Vec2 foi proposto em [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations](https://huggingface.co/papers/2006.11477) por Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli.
O resumo do artigo é o seguinte:
*Demonstramos pela primeira vez que aprender representações poderosas a partir apenas de áudio de fala, seguido de ajuste fino em fala transcrita, pode superar os melhores métodos semi-supervisionados, sendo ao mesmo tempo conceitualmente mais simples. O wav2vec 2.0 mascara a entrada de fala no espaço latente e resolve uma tarefa contrastiva definida sobre uma quantização das representações latentes, que são aprendidas conjuntamente. Experimentos utilizando todos os dados rotulados do Librispeech alcançam 1,8/3,3 WER nos conjuntos de teste clean/other. Ao reduzir a quantidade de dados rotulados para uma hora, o wav2vec 2.0 supera o estado da arte anterior no subconjunto de 100 horas, utilizando 100 vezes menos dados rotulados. Usando apenas dez minutos de dados rotulados e pré-treinamento em 53 mil horas de dados não rotulados, ainda se alcança 4,8/8,2 WER. Isso demonstra a viabilidade do reconhecimento de fala com quantidades limitadas de dados rotulados.*
Este modelo foi contribuído por [patrickvonplaten](https://huggingface.co/patrickvonplaten).
Nota: A Meta (FAIR) lançou uma nova versão do [Wav2Vec2-BERT 2.0](./wav2vec2-bert) - ele foi pré-treinado em 4,5M de horas de áudio. Recomendamos especialmente o seu uso para tarefas de fine-tuning, por exemplo, conforme [este guia](https://huggingface.co/blog/fine-tune-w2v2-bert).
> [!TIP]
> Defina `use_kernels=True` em [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para substituir camadas compatíveis por kernels otimizados do Hub. Consulte [Carregando kernels](../kernel_doc/loading_kernels) para saber mais.
## Dicas de uso
- Wav2Vec2 é um modelo de fala que aceita um array de float correspondente à forma de onda bruta do sinal de fala.
- O modelo Wav2Vec2 foi treinado usando classificação temporal conexionista (CTC), portanto a saída do modelo precisa ser decodificada usando [Wav2Vec2CTCTokenizer](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer).
## Usando Flash Attention 2
Flash Attention 2 é uma versão mais rápida e otimizada do modelo.
### Instalação
Primeiro, verifique se o seu hardware é compatível com Flash Attention 2. A lista mais recente de hardware compatível pode ser encontrada na [documentação oficial](https://github.com/Dao-AILab/flash-attention#installation-and-features).
Em seguida, [instale](https://github.com/Dao-AILab/flash-attention#installation-and-features) a versão mais recente do Flash Attention 2:
```bash
pip install -U flash-attn --no-build-isolation
```
### Uso
Para carregar um modelo usando Flash Attention 2, podemos passar o argumento `attn_implementation="flash_attention_2"` para [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained). Também carregaremos o modelo em meia precisão (por exemplo, `torch.float16`), pois isso resulta em quase nenhuma degradação na qualidade do áudio, mas com uso de memória significativamente menor e inferência mais rápida:
```python
from transformers import Wav2Vec2Model
model = Wav2Vec2Model.from_pretrained("facebook/wav2vec2-large-960h-lv60-self", attn_implementation="flash_attention_2", device_map="auto")
...
```
### Acelerações esperadas
Abaixo, há um diagrama de aceleração esperada comparando o tempo de inferência puro entre a implementação nativa em transformers do modelo `facebook/wav2vec2-large-960h-lv60-self` e as versões flash-attention-2 e sdpa (scale-dot-product-attention). Mostramos a aceleração média obtida no split de validação `librispeech_asr` `clean`:
## Recursos
Uma lista de recursos oficiais do Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o Wav2Vec2. Se você tiver interesse em enviar um recurso para ser incluído aqui, sinta-se à vontade para abrir um Pull Request e faremos a revisão! O recurso deve, idealmente, demonstrar algo novo em vez de duplicar um recurso existente.
- Um notebook sobre como [utilizar um modelo Wav2Vec2 pré-treinado para classificação de emoções](https://colab.research.google.com/github/m3hrdadfi/soxan/blob/main/notebooks/Emotion_recognition_in_Greek_speech_using_Wav2Vec2.ipynb). 🌎
- [Wav2Vec2ForCTC](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) é suportado por este [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/audio_classification.ipynb).
- [Guia da tarefa de classificação de áudio](../tasks/audio_classification)
- Um post de blog sobre [potencializar o Wav2Vec2 com n-grams no 🤗 Transformers](https://huggingface.co/blog/wav2vec2-with-ngram).
- Um post de blog sobre como [ajustar o Wav2Vec2 para ASR em inglês com o 🤗 Transformers](https://huggingface.co/blog/fine-tune-wav2vec2-english).
- Um post de blog sobre [ajuste fino do XLS-R para ASR multilíngue com 🤗 Transformers](https://huggingface.co/blog/fine-tune-xlsr-wav2vec2).
- Um notebook sobre como [criar legendas para o YouTube a partir de qualquer vídeo transcrevendo o áudio com Wav2Vec2](https://colab.research.google.com/github/Muennighoff/ytclipcc/blob/main/wav2vec_youtube_captions.ipynb). 🌎
- [Wav2Vec2ForCTC](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) é suportado por um notebook 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).
- [Guia da tarefa de reconhecimento automático de fala](../tasks/asr)
🚀 Implantação
- Um post de blog sobre como implantar o Wav2Vec2 para [Reconhecimento Automático de Fala com Transformers da Hugging Face & Amazon SageMaker](https://www.philschmid.de/automatic-speech-recognition-sagemaker).
## Wav2Vec2Config[[transformers.Wav2Vec2Config]]
#### transformers.Wav2Vec2Config[[transformers.Wav2Vec2Config]]
```python
transformers.Wav2Vec2Config(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 = 32, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, feat_proj_dropout: float | int = 0.0, feat_quantizer_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, feat_extract_norm: str = 'group', feat_extract_activation: str = 'gelu', conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512), conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2), conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2), conv_bias: bool = False, num_conv_pos_embeddings: int = 128, num_conv_pos_embedding_groups: int = 16, do_stable_layer_norm: bool = False, 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, num_codevectors_per_group: int = 320, num_codevector_groups: int = 2, contrastive_logits_temperature: float = 0.1, num_negatives: int = 100, codevector_dim: int = 256, proj_codevector_dim: int = 256, diversity_loss_weight: float = 0.1, ctc_loss_reduction: str = 'sum', ctc_zero_infinity: bool = False, use_weighted_layer_sum: bool = False, classifier_proj_size: int = 256, 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 = 3, output_hidden_size: int | None = None, adapter_attn_dim: int | None = None)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/configuration_wav2vec2.py#L27)
**Parâmetros:**
vocab_size (`int`, *opcional*, padrão `32`) : 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 `768`) : Dimensão das representações ocultas.
num_hidden_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer.
num_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
intermediate_size (`int`, *opcional*, padrão `3072`) : Dimensão das representações do MLP.
hidden_act (`str`, *opcional*, padrão `gelu`) : 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.1`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder e pooler.
activation_dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A taxa de dropout para as ativações dentro da camada totalmente conectada.
attention_dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A taxa de dropout para as probabilidades de atenção.
feat_proj_dropout (`float`, *opcional*, padrão 0.0) : A probabilidade de dropout para a saída do codificador de recursos.
feat_quantizer_dropout (`float`, *opcional*, padrão 0.0) : A probabilidade de dropout para a saída do codificador de recursos usado pelo quantizador.
final_dropout (`float`, *opcional*, padrão 0.1) : A probabilidade de dropout para a camada de projeção final de [Wav2Vec2ForCTC](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).
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.
feat_extract_norm (`str`, *opcional*, padrão `"group"`) : A normalização a ser aplicada às camadas de convolução 1D no codificador de recursos. Pode ser `"group"` para normalização de grupo apenas na primeira camada de convolução 1D ou `"layer"` para normalização de camada em todas as camadas de convolução 1D.
feat_extract_activation (`str, `optional`, defaults to `"gelu"`) : The non-linear activation function (function or string) in the 1D convolutional layers of the feature extractor. If string, `"gelu"`, `"relu"`, `"selu"` and `"gelu_new"` are supported.
conv_dim (`tuple[int]` ou `list[int]`, *opcional*, padrão `(512, 512, 512, 512, 512, 512, 512)`) : Uma tupla de inteiros que define o número de canais de entrada e saída de cada camada convolucional 1D no codificador de recursos. O comprimento de *conv_dim* define o número de camadas convolucionais 1D.
conv_stride (`tuple[int]` ou `list[int]`, *opcional*, padrão `(5, 2, 2, 2, 2, 2, 2)`) : Uma tupla de inteiros que define o stride de cada camada convolucional 1D no codificador de recursos. O comprimento de *conv_stride* define o número de camadas convolucionais e deve corresponder ao comprimento de *conv_dim*.
conv_kernel (`tuple[int]` ou `list[int]`, *opcional*, padrão `(10, 3, 3, 3, 3, 3, 3)`) : Uma tupla de inteiros que define o tamanho do kernel de cada camada convolucional 1D no codificador de recursos. O comprimento de *conv_kernel* define o número de camadas convolucionais e deve corresponder ao comprimento de *conv_dim*.
conv_bias (`bool`, *opcional*, padrão `False`) : Indica se as camadas de convolução 1D possuem viés.
num_conv_pos_embeddings (`int`, *opcional*, padrão 128) : Número de embeddings posicionais convolucionais. Define o tamanho do kernel da camada de embeddings posicionais convolucionais 1D.
num_conv_pos_embedding_groups (`int`, *opcional*, padrão 16) : Número de grupos da camada de embeddings posicionais de convolução 1D.
do_stable_layer_norm (`bool`, *opcional*, padrão `False`) : Se deve aplicar a arquitetura de layer norm *estável* do codificador Transformer. `do_stable_layer_norm is True` corresponde a aplicar layer norm antes da camada de atenção, enquanto `do_stable_layer_norm is False` corresponde a aplicar layer norm depois da camada de atenção.
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`, *opcional*, padrão 0.05) : Porcentagem (entre 0 e 1) de todos os vetores de características ao longo do eixo do tempo que serão mascarados. O procedimento de mascaramento gera ''mask_time_prob*len(time_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 intervalo de vetores a ser mascarado, *mask_time_prob* deve ser `prob_vector_start*mask_time_length`. Observe que a sobreposição pode diminuir a porcentagem real de vetores mascarados. Isso é relevante apenas se `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 for feito a 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_prob (`Union[float, int]`, *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 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` for `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''
num_codevectors_per_group (`int`, *opcional*, padrão 320) : Número de entradas em cada codebook de quantização (grupo).
num_codevectors_per_group (`int`, *opcional*, padrão 320) : Número de entradas em cada codebook de quantização (grupo).
num_codevector_groups (`int`, *opcional*, padrão 2) : Número de grupos de codevectors para quantização de codevectors por produto.
contrastive_logits_temperature (`float`, *opcional*, padrão 0.1) : A temperatura *kappa* na perda contrastiva.
num_negatives (`int`, *opcional*, padrão 100) : Número de amostras negativas para a perda contrastiva.
codevector_dim (`int`, *opcional*, padrão 256) : Dimensionalidade dos vetores de recursos quantizados.
proj_codevector_dim (`int`, *opcional*, padrão 256) : Dimensionalidade da projeção final tanto das features quantizadas quanto das features do transformer.
diversity_loss_weight (`int`, *opcional*, padrão 0.1) : O peso do componente de perda de diversidade do codebook.
ctc_loss_reduction (`str`, *opcional*, padrão `"sum"`) : Especifica a redução a ser aplicada à saída de `torch.nn.CTCLoss`. Relevante apenas ao treinar uma instância de [Wav2Vec2ForCTC](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).
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 [Wav2Vec2ForCTC](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).
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 [Wav2Vec2ForSequenceClassification](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ForSequenceClassification).
classifier_proj_size (`int`, *opcional*, padrão 256) : 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 convolucional deve ser empilhada sobre o Encoder do Wav2Vec2. Pode ser muito útil para iniciar o Wav2Vec2 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 3) : Número de camadas convolucionais que devem ser usadas na rede do adaptador. 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`.
adapter_attn_dim (`int`, *opcional*) : Dimensão dos pesos do adaptador de atenção a serem usados em cada bloco de atenção. Um exemplo de modelo que usa adaptadores de atenção é [facebook/mms-1b-all](https://huggingface.co/facebook/mms-1b-all).
Esta é a classe de configuração para armazenar a configuração de um Wav2Vec2Model. Ela é usada para instanciar um modelo Wav2Vec2 de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [facebook/wav2vec2-base-960h](https://huggingface.co/facebook/wav2vec2-base-960h)
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 Wav2Vec2Config, Wav2Vec2Model
>>> # Initializing a Wav2Vec2 facebook/wav2vec2-base-960h style configuration
>>> configuration = Wav2Vec2Config()
>>> # Initializing a model (with random weights) from the facebook/wav2vec2-base-960h style configuration
>>> model = Wav2Vec2Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```
## Wav2Vec2CTCTokenizer[[transformers.Wav2Vec2CTCTokenizer]]
#### transformers.Wav2Vec2CTCTokenizer[[transformers.Wav2Vec2CTCTokenizer]]
```python
transformers.Wav2Vec2CTCTokenizer(vocab_file, bos_token = '', eos_token = '', unk_token = '', pad_token = '', word_delimiter_token = '|', replace_word_delimiter_char = ' ', do_lower_case = False, target_lang = None, **kwargs)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L101)
**Parâmetros:**
vocab_file (`str`) : Arquivo contendo o vocabulário.
bos_token (`str`, *opcional*, padrão `""`) : O token de início de frase.
eos_token (`str`, *opcional*, padrão `""`) : O token de fim de sentença.
unk_token (`str`, *opcional*, padrão `""`) : O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso.
pad_token (`str`, *opcional*, padrão `""`) : O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes.
word_delimiter_token (`str`, *opcional*, padrão `"|"`) : O token usado para definir o fim de uma palavra.
do_lower_case (`bool`, *opcional*, padrão `False`) : Se deve ou não aceitar entrada em minúsculas e converter a saída para minúsculas durante a decodificação.
target_lang (`str`, *opcional*) : Um idioma de destino que o tokenizer deve definir por padrão. `target_lang` precisa ser definido para vocabulários aninhados multilíngues, como [facebook/mms-1b-all](https://huggingface.co/facebook/mms-1b-all).
- ****kwargs** : Argumentos de palavra-chave adicionais passados para [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend)
Constrói um tokenizador Wav2Vec2CTC.
Este tokenizer herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend), que contém alguns dos principais métodos. Os usuários devem consultar a superclasse para mais informações sobre esses métodos.
#### __call__[[transformers.Wav2Vec2CTCTokenizer.__call__]]
```python
__call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2449)
**Parâmetros:**
text (`str`, `list[str]`, `list[list[str]]`, *opcional*) : A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir `is_split_into_words=True` (para eliminar a ambiguidade com um lote de sequências).
text_pair (`str`, `list[str]`, `list[list[str]]`, *opcional*) : A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir `is_split_into_words=True` (para eliminar a ambiguidade com um lote de sequências).
text_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : A sequência ou lote de sequências a serem codificadas como textos de destino. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir `is_split_into_words=True` (para eliminar a ambiguidade com um lote de sequências).
text_pair_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : A sequência ou lote de sequências a serem codificadas como textos de destino. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir `is_split_into_words=True` (para eliminar a ambiguidade com um lote de sequências).
tokenizer_kwargs (`dict[str, Any]`, *opcional*) : Kwargs adicionais para passar ao tokenizer. Eles serão mesclados com os parâmetros explícitos e outros kwargs, com os parâmetros explícitos tendo precedência.
add_special_tokens (`bool`, *opcional*, padrão `True`) : Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza a função subjacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você deseja adicionar automaticamente tokens `bos` ou `eos`.
padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Ativa e controla o padding. Aceita os seguintes valores: - `True` ou `'longest'`: Preenche até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Preenche até o comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, padrão `False`) : Ativa e controla a truncagem. Aceita os seguintes valores: - `True` ou `'longest_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_second'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `False` ou `'do_not_truncate'` (padrão): Sem truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissível do modelo).
max_length (`int`, *opcional*) : Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento. Se não for definido ou for definido como `None`, será usado o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento até um comprimento máximo será desativado.
stride (`int`, *opcional*, padrão 0) : Se definido como um número junto com `max_length`, os tokens excedentes retornados quando `return_overflowing_tokens=True` conterão alguns tokens do final da sequência truncada retornada, para fornecer alguma sobreposição entre as sequências truncada e excedente. O valor deste argumento define o número de tokens sobrepostos.
is_split_into_words (`bool`, *opcional*, padrão `False`) : Indica se a entrada já está pré-tokenizada (por exemplo, dividida em palavras). Se definido como `True`, o tokenizer assume que a entrada já foi dividida em palavras (por exemplo, separando por espaços em branco) e a tokenizará. Isso é útil para NER ou classificação de tokens.
pad_to_multiple_of (`int`, *opcional*) : Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Exige que `padding` esteja ativado. Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação `>= 7.5` (Volta).
padding_side (`str`, *opcional*) : O lado em que o modelo deve ter padding aplicado. Deve ser selecionado entre ['right', 'left']. O valor padrão é obtido do atributo de classe com o mesmo nome.
return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de lista de inteiros do Python. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do Numpy.
return_token_type_ids (`bool`, *opcional*) : Se deve retornar os IDs de tipo de token. Se mantido no padrão, retornará os IDs de tipo de token de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`. [O que são IDs de tipo de token?](../glossary#token-type-ids)
return_attention_mask (`bool`, *opcional*) : Indica se a máscara de atenção deve ser retornada. Se mantido o valor padrão, a máscara de atenção será retornada de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`. [O que são máscaras de atenção?](../glossary#attention-mask)
return_overflowing_tokens (`bool`, *opcional*, padrão `False`) : Indica se as sequências de tokens que excedem o limite devem ser retornadas. Se um par de sequências de ids de entrada (ou um lote de pares) for fornecido com `truncation_strategy = longest_first` ou `True`, um erro será lançado em vez de retornar os tokens excedentes.
return_special_tokens_mask (`bool`, *opcional*, padrão `False`) : Se deve ou não retornar informações da máscara de tokens especiais.
return_offsets_mapping (`bool`, *opcional*, padrão `False`) : Indica se deve ou não retornar `(char_start, char_end)` para cada token. Isso está disponível apenas em tokenizadores rápidos que herdam de [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend); se estiver usando o tokenizador do Python, este método lançará `NotImplementedError`.
return_length (`bool`, *opcional*, padrão `False`) : Indica se as comprimentos das entradas codificadas devem ser retornados.
verbose (`bool`, *opcional*, padrão `True`) : Se deve ou não exibir mais informações e avisos.
- ****kwargs** : passados para o método `self.tokenize()`
**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_ids** -- Lista de ids de tokens a serem fornecidos a um modelo.
[O que são IDs de entrada?](../glossary#input-ids)
- **token_type_ids** -- Lista de ids de tipo de token a serem fornecidos a um modelo (quando `return_token_type_ids=True` ou se *"token_type_ids"* estiver em `self.model_input_names`).
[O que são IDs de tipo de token?](../glossary#token-type-ids)
- **attention_mask** -- Lista de índices que especifica quais tokens devem ser considerados pelo modelo (quando `return_attention_mask=True` ou se *"attention_mask"* estiver em `self.model_input_names`).
[O que são máscaras de atenção?](../glossary#attention-mask)
- **overflowing_tokens** -- Lista de sequências de tokens excedentes (quando um `max_length` é especificado e `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Número de tokens truncados (quando um `max_length` é especificado e `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Lista de 0s e 1s, em que 1 especifica tokens especiais adicionados e 0 especifica tokens regulares da sequência (quando `add_special_tokens=True` e `return_special_tokens_mask=True`).
- **length** -- O comprimento das entradas (quando `return_length=True`)
Método principal para tokenizar e preparar uma ou várias sequências ou um ou vários pares de sequências para o modelo.
#### save_vocabulary[[transformers.Wav2Vec2CTCTokenizer.save_vocabulary]]
```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L643)
#### decode[[transformers.Wav2Vec2CTCTokenizer.decode]]
```python
decode(token_ids: typing.Union[int, list[int], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, output_char_offsets: bool = False, output_word_offsets: bool = False, **kwargs)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L538)
**Parâmetros:**
token_ids (`Union[int, list[int], np.ndarray, torch.Tensor]`) : Lista de ids de entrada tokenizados. Pode ser obtido usando o método `__call__`.
skip_special_tokens (`bool`, *opcional*, padrão `False`) : Indica se os tokens especiais devem ser removidos durante a decodificação.
clean_up_tokenization_spaces (`bool`, *opcional*) : Se deve ou não limpar os espaços de tokenização.
output_char_offsets (`bool`, *opcional*, padrão `False`) : Indica se os deslocamentos de caracteres devem ser exibidos na saída. Os deslocamentos de caracteres podem ser usados em conjunto com a taxa de amostragem e a taxa de redução de amostragem do modelo para calcular os carimbos de tempo dos caracteres transcritos. Consulte o exemplo abaixo para entender melhor como utilizar `output_char_offsets`.
output_word_offsets (`bool`, *opcional*, padrão `False`) : Indica se os deslocamentos de palavras devem ser exibidos ou não. Os deslocamentos de palavras podem ser usados em conjunto com a taxa de amostragem e a taxa de subamostragem do modelo para calcular os carimbos de tempo das palavras transcritas. Consulte o exemplo abaixo para entender melhor como utilizar `output_word_offsets`.
kwargs (argumentos de palavra-chave adicionais, *opcional*) : Serão passados para o método de decodificação específico do modelo subjacente.
**Retorna:** `str` ou `Wav2Vec2CTCTokenizerOutput`
A lista de frases decodificadas. Será um `Wav2Vec2CTCTokenizerOutput` quando `output_char_offsets == True` ou `output_word_offsets == True`.
Converte uma sequência de ids em uma string, usando o tokenizer e o vocabulário, com opções para remover tokens especiais e limpar os espaços de tokenização.
Semelhante a executar `self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))`.
Exemplo:
```python
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoFeatureExtractor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch
>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)
>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = feature_extractor(sample["audio"]["array"], return_tensors="pt").input_values
>>> logits = model(input_values).logits[0]
>>> pred_ids = torch.argmax(logits, axis=-1)
>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = tokenizer.decode(pred_ids, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / feature_extractor.sampling_rate
>>> word_offsets = [
... {
... "word": d["word"],
... "start_time": round(d["start_offset"] * time_offset, 2),
... "end_time": round(d["end_offset"] * time_offset, 2),
... }
... for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:3]
[{'word': 'THE', 'start_time': 0.7, 'end_time': 0.78}, {'word': 'TRICK', 'start_time': 0.88, 'end_time': 1.08}, {'word': 'APPEARS', 'start_time': 1.2, 'end_time': 1.64}]
```
#### batch_decode[[transformers.Wav2Vec2CTCTokenizer.batch_decode]]
```python
batch_decode(sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, output_char_offsets: bool = False, output_word_offsets: bool = False, **kwargs)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L468)
**Parâmetros:**
sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Lista de ids de entrada tokenizados. Pode ser obtido usando o método `__call__`.
skip_special_tokens (`bool`, *opcional*, padrão `False`) : Indica se os tokens especiais devem ser removidos durante a decodificação.
clean_up_tokenization_spaces (`bool`, *opcional*) : Se deve ou não limpar os espaços de tokenização.
output_char_offsets (`bool`, *opcional*, padrão `False`) : Indica se os deslocamentos de caracteres devem ser exibidos na saída. Os deslocamentos de caracteres podem ser usados em conjunto com a taxa de amostragem e a taxa de redução de amostragem do modelo para calcular os carimbos de tempo dos caracteres transcritos. Consulte o Exemplo de [decode()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.decode) para entender melhor como utilizar `output_char_offsets`. [batch_decode()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.batch_decode) funciona da mesma maneira com saída em lote.
output_word_offsets (`bool`, *opcional*, padrão `False`) : Se deve ou não produzir deslocamentos de palavras. Os deslocamentos de palavras podem ser usados em combinação com a taxa de amostragem e a taxa de subamostragem do modelo para calcular os carimbos de tempo das palavras transcritas. Por favor, veja o Exemplo de [decode()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.decode) para entender melhor como utilizar `output_word_offsets`. [batch_decode()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.batch_decode) funciona da mesma maneira com saída em lote.
kwargs (argumentos de palavra-chave adicionais, *opcional*) : Serão passados para o método de decodificação específico do modelo subjacente.
**Retorna:** `list[str]` ou `Wav2Vec2CTCTokenizerOutput`
A lista de frases decodificadas. Será um `Wav2Vec2CTCTokenizerOutput` quando `output_char_offsets == True` ou `output_word_offsets == True`.
Converta uma lista de listas de ids de tokens em uma lista de strings chamando decode.
#### set_target_lang[[transformers.Wav2Vec2CTCTokenizer.set_target_lang]]
```python
set_target_lang(target_lang: str)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L184)
Defina o idioma de destino de um dicionário multilíngue aninhado
## Wav2Vec2FeatureExtractor[[transformers.Wav2Vec2FeatureExtractor]]
#### transformers.Wav2Vec2FeatureExtractor[[transformers.Wav2Vec2FeatureExtractor]]
```python
transformers.Wav2Vec2FeatureExtractor(feature_size = 1, sampling_rate = 16000, padding_value = 0.0, return_attention_mask = False, do_normalize = True, **kwargs)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/feature_extraction_wav2vec2.py#L28)
**Parâmetros:**
feature_size (`int`, *opcional*, padrão 1) : A dimensão dos recursos das características extraídas.
sampling_rate (`int`, *opcional*, padrão 16000) : A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz).
padding_value (`float`, *opcional*, padrão 0.0) : O valor usado para preencher os valores de padding.
do_normalize (`bool`, *opcional*, padrão `True`) : Se deve ou não normalizar a entrada com média zero e variância unitária. A normalização pode ajudar a melhorar significativamente o desempenho de alguns modelos, *por exemplo*, [wav2vec2-lv60](https://huggingface.co/models?search=lv60).
return_attention_mask (`bool`, *opcional*, padrão `False`) : Se [__call__()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) deve ou não retornar `attention_mask`. Modelos Wav2Vec2 que definiram `config.feat_extract_norm == "group"`, como [wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base-960h), **não** foram treinados usando `attention_mask`. Para esses modelos, `input_values` deve simplesmente ser preenchido com 0 e nenhum `attention_mask` deve ser passado. Para modelos Wav2Vec2 que definiram `config.feat_extract_norm == "layer"`, como [wav2vec2-lv60](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self), `attention_mask` deve ser passado para inferência em lote.
Constrói um extrator de recursos Wav2Vec2.
Este extrator de características herda de [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contém a maioria dos métodos principais. Os usuários devem consultar esta superclasse para obter mais informações sobre esses métodos.
#### __call__[[transformers.Wav2Vec2FeatureExtractor.__call__]]
```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], padding: bool | str | transformers.utils.generic.PaddingStrategy = False, max_length: int | None = None, truncation: bool = False, pad_to_multiple_of: int | None = None, return_attention_mask: bool | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None, **kwargs)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/feature_extraction_wav2vec2.py#L99)
**Parâmetros:**
raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : A sequência ou lote de sequências a serem preenchidas. Cada sequência pode ser um array numpy, uma lista de valores float, uma lista de arrays numpy ou uma lista de listas de valores float. Deve ser áudio mono canal, não estéreo, ou seja, um único float por timestep.
padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Selecione uma estratégia para aplicar padding às sequências retornadas (de acordo com o lado de padding e o índice de padding do modelo) entre: - `True` ou `'longest'`: Aplica padding até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Aplica padding até um comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode retornar um lote com sequências de comprimentos diferentes).
max_length (`int`, *opcional*) : Comprimento máximo da lista retornada e, opcionalmente, o comprimento do padding (veja acima).
truncation (`bool`) : Ativa o truncamento para cortar sequências de entrada mais longas que *max_length* para *max_length*.
pad_to_multiple_of (`int`, *opcional*) : Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Isso é especialmente útil para permitir o uso de Tensor Cores em hardware NVIDIA com capacidade de computação `>= 7.5` (Volta) ou em TPUs, que se beneficiam de ter comprimentos de sequência que sejam múltiplos de 128.
return_attention_mask (`bool`, *opcional*) : Se deve retornar a máscara de atenção. Se deixado no padrão, retornará a máscara de atenção de acordo com o padrão do feature_extractor específico. [O que são máscaras de atenção?](../glossary#attention-mask) Modelos Wav2Vec2 que definiram `config.feat_extract_norm == "group"`, como o [wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base-960h), **não** foram treinados usando `attention_mask`. Para esses modelos, `input_values` deve simplesmente ser preenchido com 0 e nenhuma `attention_mask` deve ser passada. Para modelos Wav2Vec2 que definiram `config.feat_extract_norm == "layer"`, como o [wav2vec2-lv60](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self), `attention_mask` deve ser passada para inferência em lote.
return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de lista de inteiros do Python. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do Numpy.
sampling_rate (`int`, *opcional*) : A taxa de amostragem na qual a entrada `raw_speech` foi amostrada. É fortemente recomendável passar `sampling_rate` na chamada de forward para evitar erros silenciosos.
padding_value (`float`, *opcional*, padrão 0.0) --
Método principal para criar recursos e preparar uma ou várias sequências para o modelo.
## Wav2Vec2Processor[[transformers.Wav2Vec2Processor]]
#### transformers.Wav2Vec2Processor[[transformers.Wav2Vec2Processor]]
```python
transformers.Wav2Vec2Processor(feature_extractor, tokenizer)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/processing_wav2vec2.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 Wav2Vec2Processor que encapsula um extrator de recursos e um tokenizador em um único processador.
[Wav2Vec2Processor](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Processor) 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.Wav2Vec2Processor.__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: *)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/processing_wav2vec2.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:**
Este método retorna os resultados de cada método `call`. Se ambos forem usados, a saída é um dicionário contendo os resultados de ambos.
#### pad[[transformers.Wav2Vec2Processor.pad]]
```python
pad(*args, **kwargs)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/processing_wav2vec2.py#L65)
**Parâmetros:**
input_features : Quando o primeiro argumento é um dicionário contendo um lote de tensores, ou o argumento `input_features` está presente, ele é passado para [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad).
labels : Quando o argumento `label` está presente, ele é passado para [PreTrainedTokenizer.pad()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad).
**Retorna:**
Este método retorna os resultados de cada método `pad`. Se ambos forem usados, a saída é um dicionário contendo os resultados de ambos.
Este método opera em lotes de recursos extraídos e/ou texto tokenizado. Ele encaminha todos os argumentos para [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) e/ou [PreTrainedTokenizer.pad()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad), dependendo da modalidade de entrada, e retorna suas saídas. Se ambas as modalidades forem passadas, [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) e [PreTrainedTokenizer.pad()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) serão chamados.
#### from_pretrained[[transformers.Wav2Vec2Processor.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.Wav2Vec2Processor.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.Wav2Vec2Processor.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.Wav2Vec2Processor.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.
## Wav2Vec2ProcessorWithLM[[transformers.Wav2Vec2ProcessorWithLM]]
#### transformers.Wav2Vec2ProcessorWithLM[[transformers.Wav2Vec2ProcessorWithLM]]
```python
transformers.Wav2Vec2ProcessorWithLM(feature_extractor: FeatureExtractionMixin, tokenizer: PreTrainedTokenizerBase, decoder: BeamSearchDecoderCTC)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L69)
**Parâmetros:**
feature_extractor (`feature_extractor_class`) : O extrator de recursos é uma entrada obrigatória.
tokenizer (`tokenizer_class`) : O tokenizer é uma entrada obrigatória.
decoder (`BeamSearchDecoderCTC`) : Uma instância de `pyctcdecode.BeamSearchDecoderCTC`. O decodificador é uma entrada obrigatória.
Constrói um Wav2Vec2ProcessorWithLM que encapsula um extrator de recursos e um tokenizer em um único processador.
[Wav2Vec2ProcessorWithLM](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) oferece todas as funcionalidades de `feature_extractor_class` e `tokenizer_class`. Consulte `~feature_extractor_class` e `~tokenizer_class` para mais informações.
#### __call__[[transformers.Wav2Vec2ProcessorWithLM.__call__]]
```python
__call__(*args, **kwargs)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L208)
**Parâmetros:**
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.
#### pad[[transformers.Wav2Vec2ProcessorWithLM.pad]]
```python
pad(*args, **kwargs)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L233)
Quando usado no modo normal, este método encaminha todos os seus argumentos para o `~FeatureExtractionMixin.pad` do extrator de recursos e retorna sua saída. Se usado no contexto `~Wav2Vec2ProcessorWithLM.as_target_processor`, este método encaminha todos os seus argumentos para o [pad()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) do Wav2Vec2CTCTokenizer. Consulte a docstring dos dois métodos acima para mais informações.
#### from_pretrained[[transformers.Wav2Vec2ProcessorWithLM.from_pretrained]]
```python
from_pretrained(pretrained_model_name_or_path, **kwargs)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L106)
**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 para [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) e [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend)
Instancie um [Wav2Vec2ProcessorWithLM](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) a partir de um processador Wav2Vec2 pré-treinado.
Este método de classe simplesmente chama o [from_pretrained()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) do extrator de recursos, o [from_pretrained()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.from_pretrained) do Wav2Vec2CTCTokenizer e o `pyctcdecode.BeamSearchDecoderCTC.load_from_hf_hub`.
Consulte os docstrings dos métodos acima para obter mais informações.
#### save_pretrained[[transformers.Wav2Vec2ProcessorWithLM.save_pretrained]]
```python
save_pretrained(save_directory)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L102)
#### batch_decode[[transformers.Wav2Vec2ProcessorWithLM.batch_decode]]
```python
batch_decode(logits: ndarray, pool: multiprocessing.pool.Pool | None = None, num_processes: int | None = None, beam_width: int | None = None, beam_prune_logp: float | None = None, token_min_logp: float | None = None, hotwords: collections.abc.Iterable[str] | None = None, hotword_weight: float | None = None, alpha: float | None = None, beta: float | None = None, unk_score_offset: float | None = None, lm_score_boundary: bool | None = None, output_word_offsets: bool = False, n_best: int = 1)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L260)
**Parâmetros:**
logits (`np.ndarray`) : O vetor de saída de logits do modelo, representando as log probabilidades para cada token.
pool (`multiprocessing.Pool`, *opcional*) : Um pool gerenciado pelo usuário, opcional. Se não for definido, um será criado e fechado automaticamente. O pool deve ser instanciado *após* `Wav2Vec2ProcessorWithLM`. Caso contrário, o LM não estará disponível para os subprocessos do pool. Atualmente, apenas pools criados com um contexto 'fork' podem ser usados. Se um pool 'spawn' for passado, ele será ignorado e a decodificação sequencial será usada em vez disso.
num_processes (`int`, *opcional*) : Se `pool` não estiver definido, número de processos sobre os quais a função deve ser paralelizada. O padrão é o número de CPUs disponíveis.
beam_width (`int`, *opcional*) : Número máximo de feixes em cada etapa da decodificação. O padrão é DEFAULT_BEAM_WIDTH do pyctcdecode.
beam_prune_logp (`int`, *opcional*) : Feixes que forem muito piores que o melhor feixe serão podados. O valor padrão é DEFAULT_PRUNE_LOGP do pyctcdecode.
token_min_logp (`int`, *opcional*) : Tokens abaixo deste logp são ignorados, a menos que sejam o argmax do frame. O valor padrão é DEFAULT_MIN_TOKEN_LOGP do pyctcdecode.
hotwords (`list[str]`, *opcional*) : Lista de palavras com importância extra, podem ser OOV para o LM
hotword_weight (`int`, *opcional*) : Fator de peso para a importância da palavra-chave. O valor padrão é DEFAULT_HOTWORD_WEIGHT do pyctcdecode.
alpha (`float`, *opcional*) : Peso para o modelo de linguagem durante a fusão rasa
beta (`float`, *opcional*) : Peso para ajuste da pontuação de comprimento durante a pontuação
unk_score_offset (`float`, *opcional*) : Quantidade de deslocamento da pontuação de log para tokens desconhecidos
lm_score_boundary (`bool`, *opcional*) : Se o kenlm deve respeitar fronteiras ao pontuar
output_word_offsets (`bool`, *opcional*, padrão `False`) : Se deve ou não exibir os deslocamentos de palavras. Os deslocamentos de palavras podem ser usados em combinação com a taxa de amostragem e a taxa de subamostragem do modelo para calcular os carimbos de tempo das palavras transcritas.
n_best (`int`, *opcional*, padrão `1`) : Número de melhores hipóteses a serem retornadas. Se `n_best` for maior que 1, o `text` retornado será uma lista de listas de strings, `logit_score` será uma lista de listas de floats e `lm_score` será uma lista de listas de floats, em que o comprimento da lista externa corresponderá ao tamanho do lote e o comprimento da lista interna corresponderá ao número de hipóteses retornadas. O valor deve ser >= 1. Consulte o Exemplo de [decode()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.decode) para entender melhor como utilizar `output_word_offsets`. [batch_decode()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) funciona da mesma forma com saída em lote.
**Retorna:**
`~models.wav2vec2.Wav2Vec2DecoderWithLMOutput`.
Decodifique em lote os logits de saída para transcrição de áudio com suporte a modelo de linguagem.
Esta função faz uso do multiprocessing do Python. Atualmente, o multiprocessing está disponível apenas em sistemas Unix (veja esta [questão](https://github.com/kensho-technologies/pyctcdecode/issues/65)).
Se você estiver decodificando vários lotes, considere criar um `Pool` e passá-lo para `batch_decode`. Caso contrário, `batch_decode` será muito lento, pois criará um `Pool` novo para cada chamada. Veja um exemplo de uso abaixo.
Exemplo: Veja [Decodificação de múltiplos áudios](#decoding-multiple-audios).
#### decode[[transformers.Wav2Vec2ProcessorWithLM.decode]]
```python
decode(logits: ndarray, beam_width: int | None = None, beam_prune_logp: float | None = None, token_min_logp: float | None = None, hotwords: collections.abc.Iterable[str] | None = None, hotword_weight: float | None = None, alpha: float | None = None, beta: float | None = None, unk_score_offset: float | None = None, lm_score_boundary: bool | None = None, output_word_offsets: bool = False, n_best: int = 1)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L445)
**Parâmetros:**
logits (`np.ndarray`) : O vetor de saída de logits do modelo, representando as log probabilidades para cada token.
beam_width (`int`, *opcional*) : Número máximo de feixes em cada etapa da decodificação. O padrão é DEFAULT_BEAM_WIDTH do pyctcdecode.
beam_prune_logp (`int`, *opcional*) : Um limite para podar feixes com log-probs menores que best_beam_logp + beam_prune_logp. O valor deve ser <= 0. O padrão é DEFAULT_PRUNE_LOGP do pyctcdecode.
token_min_logp (`int`, *opcional*) : Tokens com log-probs abaixo de token_min_logp são ignorados, a menos que tenham o log-prob máximo para uma utterance. O valor padrão é DEFAULT_MIN_TOKEN_LOGP do pyctcdecode.
hotwords (`list[str]`, *opcional*) : Lista de palavras com importância extra que podem estar ausentas do vocabulário do LM, por exemplo, ["huggingface"]
hotword_weight (`int`, *opcional*) : Multiplicador de peso que aumenta as pontuações das palavras-chave. O padrão é DEFAULT_HOTWORD_WEIGHT do pyctcdecode.
alpha (`float`, *opcional*) : Peso para o modelo de linguagem durante a fusão rasa
beta (`float`, *opcional*) : Peso para ajuste da pontuação de comprimento durante a pontuação
unk_score_offset (`float`, *opcional*) : Quantidade de deslocamento da pontuação de log para tokens desconhecidos
lm_score_boundary (`bool`, *opcional*) : Se o kenlm deve respeitar fronteiras ao pontuar
output_word_offsets (`bool`, *opcional*, padrão `False`) : Se deve ou não exibir os deslocamentos de palavras. Os deslocamentos de palavras podem ser usados em combinação com a taxa de amostragem e a taxa de subamostragem do modelo para calcular os carimbos de tempo das palavras transcritas.
n_best (`int`, *opcional*, padrão `1`) : Número de melhores hipóteses a serem retornadas. Se `n_best` for maior que 1, o `text` retornado será uma lista de strings, `logit_score` será uma lista de floats e `lm_score` será uma lista de floats, em que o comprimento dessas listas corresponderá ao número de hipóteses retornadas. O valor deve ser >= 1. Por favor, veja o exemplo abaixo para entender melhor como utilizar `output_word_offsets`.
**Retorna:**
`~models.wav2vec2.Wav2Vec2DecoderWithLMOutput`.
Decodifique os logits de saída para transcrição de áudio com suporte a modelos de linguagem.
Exemplo:
```python
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoProcessor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch
>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)
>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = processor(sample["audio"]["array"], return_tensors="pt").input_values
>>> with torch.no_grad():
... logits = model(input_values).logits[0].cpu().numpy()
>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = processor.decode(logits, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
>>> word_offsets = [
... {
... "word": d["word"],
... "start_time": round(d["start_offset"] * time_offset, 2),
... "end_time": round(d["end_offset"] * time_offset, 2),
... }
... for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:4]
[{'word': 'THE', 'start_time': 0.68, 'end_time': 0.78}, {'word': 'TRACK', 'start_time': 0.88, 'end_time': 1.1}, {'word': 'APPEARS', 'start_time': 1.18, 'end_time': 1.66}, {'word': 'ON', 'start_time': 1.86, 'end_time': 1.92}]
```
### Decodificação de vários áudios
Se você planeja decodificar vários lotes de áudios, considere usar [batch_decode()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) e passar uma instância de `multiprocessing.Pool`. Caso contrário, o desempenho de [batch_decode()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) será mais lento do que chamar [decode()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.decode) para cada áudio individualmente, pois ele instancia internamente um novo `Pool` a cada chamada. Veja o exemplo abaixo:
```python
# Let's see how to use a user-managed pool for batch decoding multiple audios
from multiprocessing import get_context
import datasets
import torch
from datasets import load_dataset
from transformers import AutoModelForCTC, AutoProcessor
# import model, feature extractor, tokenizer
model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm", device_map="auto")
processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
# load example dataset
dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
def map_to_array(example):
example["speech"] = example["audio"]["array"]
return example
# prepare speech data for batch inference
dataset = dataset.map(map_to_array, remove_columns=["audio"])
def map_to_pred(batch, pool):
inputs = processor(batch["speech"], sampling_rate=16_000, padding=True, return_tensors="pt").to(model.device)
inputs = {k: v.to(model.device) for k, v in inputs.items()}
with torch.no_grad():
logits = model(**inputs).logits
transcription = processor.batch_decode(logits.cpu().numpy(), pool).text
batch["transcription"] = transcription
return batch
# note: pool should be instantiated *after* `Wav2Vec2ProcessorWithLM`.
# otherwise, the LM won't be available to the pool's sub-processes
# select number of processes and batch_size based on number of CPU cores available and on dataset size
with get_context("fork").Pool(processes=2) as pool:
result = dataset.map(
map_to_pred, batched=True, batch_size=2, fn_kwargs={"pool": pool}, remove_columns=["speech"]
)
result["transcription"][:2]
['MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL', "NOR IS MISTER COULTER'S MANNER LESS INTERESTING THAN HIS MATTER"]
```
## Saídas específicas do Wav2Vec2[[transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput]]
#### transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput[[transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput]]
```python
transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput(text: list[list[str]] | list[str] | str, logit_score: list[list[float]] | list[float] | float = None, lm_score: list[list[float]] | list[float] | float = None, word_offsets: list[list[list[dict[str, int | str]]]] | list[list[dict[str, int | str]]] | list[dict[str, int | str]] = None)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L46)
**Parâmetros:**
text (lista de `str` ou `str`) : Logits decodificados em texto. Geralmente, a transcrição da fala.
logit_score (lista de `float` ou `float`) : Pontuação total de logit dos feixes associados ao texto produzido.
lm_score (lista de `float`) : lm_score fundido dos feixes associados ao texto produzido.
word_offsets (lista de `list[dict[str, Union[int, str]]]` ou `list[dict[str, Union[int, str]]]`) : Deslocamentos das palavras decodificadas. Em combinação com a taxa de amostragem e a taxa de subamostragem do modelo, os deslocamentos das palavras podem ser usados para calcular os carimbos de tempo de cada palavra.
Tipo de saída de `Wav2Vec2DecoderWithLM`, com transcrição.
#### transformers.modeling_outputs.Wav2Vec2BaseModelOutput[[transformers.modeling_outputs.Wav2Vec2BaseModelOutput]]
```python
transformers.modeling_outputs.Wav2Vec2BaseModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, extract_features: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1299)
**Parâmetros:**
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) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas dos embeddings iniciais.
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 das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Classe base para modelos que foram treinados com o objetivo de perda Wav2Vec2.
#### transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput[[transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput]]
```python
transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, projected_states: typing.Optional[torch.Tensor] = None, projected_quantized_states: typing.Optional[torch.Tensor] = None, codevector_perplexity: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None, contrastive_loss: typing.Optional[torch.Tensor] = None, diversity_loss: typing.Optional[torch.Tensor] = None)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L75)
**Parâmetros:**
loss (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) : Perda total como a soma da perda contrastiva (L_m) e da perda de diversidade (L_d), conforme descrito no [artigo oficial](https://huggingface.co/papers/2006.11477).
projected_states (`torch.Tensor` de forma `(batch_size, sequence_length, config.proj_codevector_dim)`) : Estados ocultos do modelo projetados para *config.proj_codevector_dim* que podem ser usados para prever os estados quantizados projetados mascarados.
projected_quantized_states (`torch.Tensor` de forma `(batch_size, sequence_length, config.proj_codevector_dim)`) : Vetores de características extraídas quantizadas projetados em *config.proj_codevector_dim*, representando os vetores de destino positivos para a perda contrastiva.
codevector_perplexity (`torch.Tensor` de forma `(1,)`) : A perplexidade da distribuição de codevectors, usada para medir a diversidade do codebook.
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)`. Hidden-states do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings.
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 das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
contrastive_loss (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) : The contrastive loss (L_m) as stated in the [official paper](https://huggingface.co/papers/2006.11477).
diversity_loss (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) : The diversity loss (L_d) as stated in the [official paper](https://huggingface.co/papers/2006.11477).
Tipo de saída de [Wav2Vec2ForPreTraining](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ForPreTraining), com estados ocultos e atenções potenciais.
## Wav2Vec2Model[[transformers.Wav2Vec2Model]]
#### transformers.Wav2Vec2Model[[transformers.Wav2Vec2Model]]
```python
transformers.Wav2Vec2Model(config: Wav2Vec2Config)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1194)
**Parâmetros:**
config ([Wav2Vec2Config](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 puro, que produz estados ocultos brutos sem nenhum cabeçalho específico 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.Wav2Vec2Model.forward]]
```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, mask_time_indices: typing.Optional[torch.Tensor] = None, **kwargs: *)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1268)
**Parâmetros:**
input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio `.flac` ou `.wav` em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor) deve ser usado para padding e conversão em um tensor do tipo `torch.Tensor`. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para mais detalhes.
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 ([Wav2Vec2Config](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Config)) e das entradas.
O método forward do [Wav2Vec2Model](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Model) 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.
- **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.
## Wav2Vec2ForCTC[[transformers.Wav2Vec2ForCTC]]
#### transformers.Wav2Vec2ForCTC[[transformers.Wav2Vec2ForCTC]]
```python
transformers.Wav2Vec2ForCTC(config: Wav2Vec2Config, target_lang: str | None = None)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1522)
**Parâmetros:**
config ([Wav2Vec2Config](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 [Wav2Vec2ForCTC](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) com adaptadores. Usa 'eng' por padrão.
Modelo Wav2Vec2 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.Wav2Vec2ForCTC.forward]]
```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1591)
**Parâmetros:**
input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio `.flac` ou `.wav` em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor) deve ser usado para padding e conversão em um tensor do tipo `torch.Tensor`. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para mais detalhes.
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 ([Wav2Vec2Config](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Config)) e das entradas.
O método forward do [Wav2Vec2ForCTC](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) 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, Wav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)
>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...
>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids
>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...
```
#### load_adapter[[transformers.Wav2Vec2ForCTC.load_adapter]]
```python
load_adapter(target_lang: str, force_load = True, **kwargs)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1017)
**Parâmetros:**
target_lang (`str`) : Deve ser um id de idioma de um peso de adaptador existente. Os pesos de adaptador são armazenados no formato adapter..safetensors ou adapter..bin
force_load (`bool`, padrão `True`) : Se os pesos devem ser carregados mesmo que `target_lang` corresponda a `self.target_lang`.
cache_dir (`Union[str, os.PathLike]`, *opcional*) : Caminho para um diretório no qual a configuração de um modelo pré-treinado baixado deve ser armazenada em cache, caso o cache padrão não deva ser usado.
force_download (`bool`, *opcional*, padrão `False`) : Indica se deve forçar o (re-)download dos pesos do modelo e dos arquivos de configuração, sobrescrevendo as versões em cache, caso existam.
proxies (`dict[str, str]`, *opcional*) : Um dicionário de servidores proxy a serem usados por protocolo ou endpoint, por exemplo, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Os proxies são usados em cada solicitação.
local_files_only(`bool`, *opcional*, padrão `False`) : Indica se deve considerar apenas arquivos locais (ou seja, não tentar baixar o modelo).
token (`str` ou `bool`, *opcional*) : O token a ser usado como autorização HTTP bearer para arquivos remotos. Se `True`, ou não especificado, usará o token gerado ao executar `hf auth login` (armazenado em `~/.huggingface`).
revision (`str`, *opcional*, padrão `"main"`) : A versão específica do modelo a ser usada. Pode ser o nome de uma branch, o nome de uma tag ou um id de commit, pois usamos um sistema baseado em git para armazenar modelos e outros artefatos no huggingface.co, portanto `revision` pode ser qualquer identificador permitido pelo git. Para testar um pull request que você fez no Hub, você pode passar `revision="refs/pr/"`.
mirror (`str`, *opcional*) : Origem do espelho para acelerar downloads na China. Se você está na China e tiver problemas de acessibilidade, pode definir esta opção para resolvê-los. Observe que não garantimos a pontualidade nem a segurança. Consulte o site do espelho para mais informações.
Carregue um modelo de adaptador de linguagem a partir de um modelo de adaptador pré-treinado.
Ative o modo especial ["offline-mode"](https://huggingface.co/transformers/installation.html#offline-mode) para usar este método em um ambiente com firewall.
Exemplos:
```python
>>> from transformers import Wav2Vec2ForCTC, AutoProcessor
>>> ckpt = "facebook/mms-1b-all"
>>> processor = AutoProcessor.from_pretrained(ckpt)
>>> model = Wav2Vec2ForCTC.from_pretrained(ckpt, target_lang="eng")
>>> # set specific language
>>> processor.tokenizer.set_target_lang("spa")
>>> model.load_adapter("spa")
```
## Wav2Vec2ForSequenceClassification[[transformers.Wav2Vec2ForSequenceClassification]]
#### transformers.Wav2Vec2ForSequenceClassification[[transformers.Wav2Vec2ForSequenceClassification]]
```python
transformers.Wav2Vec2ForSequenceClassification(config: Wav2Vec2Config)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1649)
**Parâmetros:**
config ([Wav2Vec2Config](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 Wav2Vec2 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.Wav2Vec2ForSequenceClassification.forward]]
```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1682)
**Parâmetros:**
input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio `.flac` ou `.wav` em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor) deve ser usado para preenchimento (padding) e conversão em um tensor do tipo `torch.Tensor`. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para mais detalhes.
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 ([Wav2Vec2Config](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Config)) e das entradas.
O método forward de [Wav2Vec2ForSequenceClassification](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ForSequenceClassification) 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 (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, Wav2Vec2ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```
Exemplo de classificação multirótulo:
```python
>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained(
... "facebook/wav2vec2-base-960h", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
```
## Wav2Vec2ForAudioFrameClassification[[transformers.Wav2Vec2ForAudioFrameClassification]]
#### transformers.Wav2Vec2ForAudioFrameClassification[[transformers.Wav2Vec2ForAudioFrameClassification]]
```python
transformers.Wav2Vec2ForAudioFrameClassification(config: Wav2Vec2Config)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1742)
**Parâmetros:**
config ([Wav2Vec2Config](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 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.Wav2Vec2ForAudioFrameClassification.forward]]
```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1774)
**Parâmetros:**
input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio `.flac` ou `.wav` em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor) deve ser usado para preenchimento (padding) e conversão em um tensor do tipo `torch.Tensor`. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para mais detalhes.
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 ([Wav2Vec2Config](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Config)) e das entradas.
O método forward de [Wav2Vec2ForAudioFrameClassification](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ForAudioFrameClassification) 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, Wav2Vec2ForAudioFrameClassification
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForAudioFrameClassification.from_pretrained("facebook/wav2vec2-base-960h")
>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate)
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> probabilities = torch.sigmoid(logits[0])
>>> # labels is a one-hot array of shape (num_frames, num_speakers)
>>> labels = (probabilities > 0.5).long()
>>> labels[0].tolist()
...
```
## Wav2Vec2ForXVector[[transformers.Wav2Vec2ForXVector]]
#### transformers.Wav2Vec2ForXVector[[transformers.Wav2Vec2ForXVector]]
```python
transformers.Wav2Vec2ForXVector(config: Wav2Vec2Config)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1888)
**Parâmetros:**
config ([Wav2Vec2Config](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 Wav2Vec2 com uma cabeça 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.Wav2Vec2ForXVector.forward]]
```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1938)
**Parâmetros:**
input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio `.flac` ou `.wav` em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor) deve ser usado para preenchimento (padding) e conversão em um tensor do tipo `torch.Tensor`. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para mais detalhes.
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 ([Wav2Vec2Config](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Config)) e das entradas.
O método forward de [Wav2Vec2ForXVector](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ForXVector) 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, Wav2Vec2ForXVector
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForXVector.from_pretrained("facebook/wav2vec2-base-960h")
>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
... [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
... embeddings = model(**inputs).embeddings
>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()
>>> # the resulting embeddings can be used for cosine similarity-based retrieval
>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7 # the optimal threshold is dataset-dependent
>>> if similarity < threshold:
... print("Speakers are not the same!")
>>> round(similarity.item(), 2)
...
```
## Wav2Vec2ForPreTraining[[transformers.Wav2Vec2ForPreTraining]]
#### transformers.Wav2Vec2ForPreTraining[[transformers.Wav2Vec2ForPreTraining]]
```python
transformers.Wav2Vec2ForPreTraining(config: Wav2Vec2Config)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1319)
**Parâmetros:**
config ([Wav2Vec2Config](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 Wav2Vec2 com um quantizador e um cabeçalho `VQ` 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.Wav2Vec2ForPreTraining.forward]]
```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, mask_time_indices: typing.Optional[torch.BoolTensor] = None, sampled_negative_indices: typing.Optional[torch.BoolTensor] = None, **kwargs: *)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1367)
**Parâmetros:**
input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio `.flac` ou `.wav` em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor) deve ser usado para padding e conversão em um tensor do tipo `torch.Tensor`. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para mais detalhes.
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*.
sampled_negative_indices (`torch.BoolTensor` de forma `(batch_size, sequence_length, num_negatives)`, *opcional*) : Índices que indicam quais vetores de destino quantizados são usados como vetores negativos amostrados na perda contrastiva. Entrada obrigatória para o pré-treinamento.
**Retorna:** [Wav2Vec2ForPreTrainingOutput](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput) ou `tuple(torch.Tensor)`
Um [Wav2Vec2ForPreTrainingOutput](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput) 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 ([Wav2Vec2Config](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Config)) e das entradas.
O método forward de [Wav2Vec2ForPreTraining](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ForPreTraining) 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** (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) -- Total loss as the sum of the contrastive loss (L_m) and the diversity loss (L_d) as stated in the [official paper](https://huggingface.co/papers/2006.11477).
- **projected_states** (`torch.Tensor` de forma `(batch_size, sequence_length, config.proj_codevector_dim)`) -- Hidden-states do modelo projetados para *config.proj_codevector_dim* que podem ser usados para prever os estados quantizados projetados mascarados.
- **projected_quantized_states** (`torch.Tensor` de forma `(batch_size, sequence_length, config.proj_codevector_dim)`) -- Vetores de características extraídas quantizados projetados em *config.proj_codevector_dim*, representando os vetores-alvo positivos para a perda contrastiva.
- **codevector_perplexity** (`torch.Tensor` de forma `(1,)`) -- A perplexidade da distribuição de codevector, usada para medir a diversidade do codebook.
- **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 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.
- **contrastive_loss** (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) -- The contrastive loss (L_m) as stated in the [official paper](https://huggingface.co/papers/2006.11477).
- **diversity_loss** (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) -- The diversity loss (L_d) as stated in the [official paper](https://huggingface.co/papers/2006.11477).
Exemplo:
```python
>>> import torch
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForPreTraining
>>> from transformers.models.wav2vec2.modeling_wav2vec2 import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
>>> model = Wav2Vec2ForPreTraining.from_pretrained("facebook/wav2vec2-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").input_values # Batch size 1
>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length).item()
>>> mask_time_indices = _compute_mask_indices(
... shape=(batch_size, sequence_length), mask_prob=0.2, mask_length=2
... )
>>> sampled_negative_indices = _sample_negative_indices(
... features_shape=(batch_size, sequence_length),
... num_negatives=model.config.num_negatives,
... mask_time_indices=mask_time_indices,
... )
>>> mask_time_indices = torch.tensor(data=mask_time_indices, device=input_values.device, dtype=torch.long)
>>> sampled_negative_indices = torch.tensor(
... data=sampled_negative_indices, device=input_values.device, dtype=torch.long
... )
>>> with torch.no_grad():
... outputs = model(input_values, mask_time_indices=mask_time_indices)
>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = torch.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states, dim=-1)
>>> # show that cosine similarity is much higher than random
>>> cosine_sim[mask_time_indices.to(torch.bool)].mean() > 0.5
tensor(True)
>>> # for contrastive loss training model should be put into train mode
>>> model = model.train()
>>> loss = model(
... input_values, mask_time_indices=mask_time_indices, sampled_negative_indices=sampled_negative_indices
... ).loss
```