# UniSpeech-SAT

## Visão geral

O modelo UniSpeech-SAT foi proposto em [UniSpeech-SAT: Universal Speech Representation Learning with Speaker Aware Pre-Training](https://huggingface.co/papers/2110.05752) por Sanyuan Chen, Yu Wu, Chengyi Wang, Zhengyang Chen, Zhuo Chen, Shujie Liu, Jian Wu, Yao Qian, Furu Wei, Jinyu Li, Xiangzhan Yu.

O resumo do artigo é o seguinte:

*O aprendizado auto-supervisionado (SSL) é um objetivo de longa data para o processamento de fala, pois utiliza dados não rotulados em larga escala e evita a rotulagem extensiva por humanos. Nos últimos anos, testemunhamos grandes sucessos na aplicação do aprendizado auto-supervisionado no reconhecimento de fala, enquanto a exploração limitada foi tentada na aplicação do SSL para modelar características do falante. Neste artigo, nosso objetivo é melhorar o framework SSL existente para o aprendizado de representação de falantes. Dois métodos são introduzidos para aprimorar a extração não supervisionada de informações do falante. Primeiro, aplicamos o aprendizado multi-tarefa ao framework SSL atual, onde integramos a perda contrastiva por fala com a função objetivo do SSL. Segundo, para uma melhor discriminação do falante, propomos uma estratégia de mistura de falas para aumento de dados, onde falas sobrepostas adicionais são criadas de forma não supervisionada e incorporadas durante o treinamento. Integramos os métodos propostos no framework HuBERT. Os resultados experimentais no benchmark SUPERB mostram que o sistema proposto atinge desempenho state-of-the-art no aprendizado de representação universal, especialmente para tarefas orientadas à identificação de falantes. Um estudo de ablação é realizado verificando a eficácia de cada método proposto. Finalmente, escalamos o conjunto de dados de treinamento para 94 mil horas de dados de áudio públicos e alcançamos melhoria adicional de desempenho em todas as tarefas do SUPERB.*

Este modelo foi contribuído por [patrickvonplaten](https://huggingface.co/patrickvonplaten). O código dos autores pode ser encontrado [aqui](https://github.com/microsoft/UniSpeech/tree/main/UniSpeech-SAT).

## Dicas de uso

- UniSpeechSat é um modelo de fala que aceita um array de floats correspondente à forma de onda bruta do sinal de fala. Use [Wav2Vec2Processor](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Processor) para a extração de recursos.
- O modelo UniSpeechSat pode ser ajustado usando classificação temporal conexionista (CTC), portanto a saída do modelo deve ser decodificada usando [Wav2Vec2CTCTokenizer](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer).
- O UniSpeechSat apresenta desempenho especialmente bom em tarefas de verificação de falante, identificação de falante e diarização de falantes.

## Recursos

- [Guia da tarefa de classificação de áudio](../tasks/audio_classification)
- [Guia da tarefa de reconhecimento automático de fala](../tasks/asr)

## UniSpeechSatConfig[[transformers.UniSpeechSatConfig]]

#### transformers.UniSpeechSatConfig[[transformers.UniSpeechSatConfig]]

```python
transformers.UniSpeechSatConfig(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 = 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 = 'mean', 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 = 0, bos_token_id: int = 1, eos_token_id: int = 2, num_clusters: int = 504)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/configuration_unispeech_sat.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 [UniSpeechSatForCTC](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC).

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, 2, 2)`) : 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_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_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 `mean`) : Especifica a redução a ser aplicada à saída de `torch.nn.CTCLoss`. Relevante apenas durante o treinamento.

ctc_zero_infinity (`bool`, *opcional*, padrão `False`) : Se deve zerar perdas infinitas e os gradientes associados de `torch.nn.CTCLoss`. Perdas infinitas ocorrem principalmente quando as entradas são curtas demais para serem alinhadas aos alvos. Relevante apenas ao treinar uma instância de [UniSpeechSatForCTC](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC).

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 [UniSpeechSatForSequenceClassification](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatForSequenceClassification).

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 (`int`, *opcional*, padrão `2`) : ID do token usado para o fim do fluxo no vocabulário.

num_clusters (`int`, *opcional*, padrão 504) : Número de clusters para rotulagem fraca. Relevante apenas ao usar uma instância de [UniSpeechSatForPreTraining](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatForPreTraining).

Esta é a classe de configuração para armazenar a configuração de um Unispeech SatModel. Ela é usada para instanciar um modelo Unispeech Sat 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 [microsoft/unispeech-sat-base-100h-libri-ft](https://huggingface.co/microsoft/unispeech-sat-base-100h-libri-ft)

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 UniSpeechSatModel, UniSpeechSatConfig

>>> # Initializing a UniSpeechSat microsoft/unispeech-sat-base-100h-libri-ft style configuration
>>> configuration = UniSpeechSatConfig()

>>> # Initializing a model from the microsoft/unispeech-sat-base-100h-libri-ft style configuration
>>> model = UniSpeechSatModel(configuration)

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

## Saídas específicas do UniSpeechSat[[transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput]]

#### transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput[[transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput]]

```python
transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, logits: 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)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L65)

**Parâmetros:**

loss (`*optional*`, retornado quando o modelo está no modo de treinamento, `torch.Tensor` de forma `(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).

logits (`torch.Tensor` de forma `(batch_size, sequence_length, config.proj_codevector_dim)`, *opcional*) : Pontuações de previsão do modelo de perda contrastiva, ou seja, a saída do modelo antes do softmax final.

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.

Tipo de saída de `UniSpeechSatForPreTrainingOutput`, com estados ocultos e atenções potenciais.

## UniSpeechSatModel[[transformers.UniSpeechSatModel]]

#### transformers.UniSpeechSatModel[[transformers.UniSpeechSatModel]]

```python
transformers.UniSpeechSatModel(config: UniSpeechSatConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L878)

**Parâmetros:**

config ([UniSpeechSatConfig](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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 Unispeech Sat básico, 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.UniSpeechSatModel.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: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L941)

**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 ([UniSpeechSatConfig](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) e das entradas.

O método forward do [UniSpeechSatModel](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **extract_features** (`torch.Tensor` de forma `(batch_size, sequence_length, conv_dim[-1])`) -- Sequência de vetores de características extraídos da última camada convolucional do modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## UniSpeechSatForCTC[[transformers.UniSpeechSatForCTC]]

#### transformers.UniSpeechSatForCTC[[transformers.UniSpeechSatForCTC]]

```python
transformers.UniSpeechSatForCTC(config: UniSpeechSatConfig, target_lang: str | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1093)

**Parâmetros:**

config ([UniSpeechSatConfig](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

target_lang (`str`, *opcional*) : ID do idioma dos pesos do adaptador. Os pesos do adaptador são armazenados no formato adapter..safetensors ou adapter..bin. Relevante apenas ao usar uma instância de [UniSpeechSatForCTC](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC) com adaptadores. Usa 'eng' por padrão.

Modelo UniSpeechSat 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.UniSpeechSatForCTC.forward]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1162)

**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 ([UniSpeechSatConfig](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) e das entradas.

O método forward de [UniSpeechSatForCTC](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC) 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, UniSpeechSatForCTC
>>> 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("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForCTC.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")

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

## UniSpeechSatForSequenceClassification[[transformers.UniSpeechSatForSequenceClassification]]

#### transformers.UniSpeechSatForSequenceClassification[[transformers.UniSpeechSatForSequenceClassification]]

```python
transformers.UniSpeechSatForSequenceClassification(config: UniSpeechSatConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1220)

**Parâmetros:**

config ([UniSpeechSatConfig](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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 UniSpeechSat com uma cabeça de classificação de sequência no topo (uma camada linear sobre a saída agregada) para tarefas como Keyword Spotting do SUPERB.

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.UniSpeechSatForSequenceClassification.forward]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1253)

**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 `UniSpeechSatProcessor.__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 ([UniSpeechSatConfig](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) e das entradas.

O método forward de [UniSpeechSatForSequenceClassification](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatForSequenceClassification) 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, UniSpeechSatForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForSequenceClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")

>>> 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 = UniSpeechSatForSequenceClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft", 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, UniSpeechSatForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForSequenceClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft", 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 = UniSpeechSatForSequenceClassification.from_pretrained(
...     "microsoft/unispeech-sat-base-100h-libri-ft", 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
```

## UniSpeechSatForAudioFrameClassification[[transformers.UniSpeechSatForAudioFrameClassification]]

#### transformers.UniSpeechSatForAudioFrameClassification[[transformers.UniSpeechSatForAudioFrameClassification]]

```python
transformers.UniSpeechSatForAudioFrameClassification(config: UniSpeechSatConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1313)

**Parâmetros:**

config ([UniSpeechSatConfig](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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 Unispeech Sat com uma cabeça de classificação de quadro no topo para tarefas como Diarização de Fala.

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.UniSpeechSatForAudioFrameClassification.forward]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1345)

**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 `UniSpeechSatProcessor.__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 ([UniSpeechSatConfig](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) e das entradas.

O método forward de [UniSpeechSatForAudioFrameClassification](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatForAudioFrameClassification) 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, UniSpeechSatForAudioFrameClassification
>>> 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("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForAudioFrameClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")

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

## UniSpeechSatForXVector[[transformers.UniSpeechSatForXVector]]

#### transformers.UniSpeechSatForXVector[[transformers.UniSpeechSatForXVector]]

```python
transformers.UniSpeechSatForXVector(config: UniSpeechSatConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1459)

**Parâmetros:**

config ([UniSpeechSatConfig](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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 UniSpeechSat 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.UniSpeechSatForXVector.forward]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1509)

**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 `UniSpeechSatProcessor.__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 ([UniSpeechSatConfig](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) e das entradas.

O método forward de [UniSpeechSatForXVector](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatForXVector) 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, UniSpeechSatForXVector
>>> 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("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForXVector.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")

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

## UniSpeechSatForPreTraining[[transformers.UniSpeechSatForPreTraining]]

#### transformers.UniSpeechSatForPreTraining[[transformers.UniSpeechSatForPreTraining]]

```python
transformers.UniSpeechSatForPreTraining(config: UniSpeechSatConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L987)

**Parâmetros:**

config ([UniSpeechSatConfig](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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 UniSpeechSat com um módulo de quantização vetorial e perda ctc para pré-treino.

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.UniSpeechSatForPreTraining.forward]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1043)

**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)

**Retorna:** [UniSpeechSatForPreTrainingOutput](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput) ou `tuple(torch.Tensor)`

Um [UniSpeechSatForPreTrainingOutput](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput) 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 ([UniSpeechSatConfig](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) e das entradas.

O método forward de [UniSpeechSatForPreTraining](/docs/transformers/main/pt/model_doc/unispeech-sat#transformers.UniSpeechSatForPreTraining) 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 model is in train mode, `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).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.proj_codevector_dim)`, *opcional*) -- Pontuações de previsão do modelo de perda contrastiva, ou seja, a saída do modelo antes do softmax final.
- **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.

Exemplo:

```python
>>> import torch
>>> from transformers import AutoFeatureExtractor, UniSpeechSatForPreTraining
>>> from transformers.models.unispeech_sat.modeling_unispeech_sat import _compute_mask_indices

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/unispeech-sat-base")
>>> model = UniSpeechSatForPreTraining.from_pretrained("microsoft/unispeech-sat-base")
>>> # TODO: Add full pretraining example
```