# XLNet

## Visão geral

O modelo XLNet foi proposto em [XLNet: Generalized Autoregressive Pretraining for Language Understanding](https://huggingface.co/papers/1906.08237) por Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le. O XLNet é uma extensão do modelo Transformer-XL pré-treinado usando um método autoregressivo para aprender contextos bidirecionais, maximizando a verossimilhança esperada sobre todas as permutações da ordem de fatoração da sequência de entrada.

O resumo do artigo é o seguinte:

*Com a capacidade de modelar contextos bidirecionais, o pré-treinamento baseado em autoencoding de desruído, como o BERT, alcança melhor desempenho do que as abordagens de pré-treinamento baseadas em modelagem de linguagem autoregressiva. No entanto, ao depender da corrupção da entrada com máscaras, o BERT negligencia a dependência entre as posições mascaradas e sofre com uma discrepância entre o pré-treinamento e o ajuste fino. Diante dessas vantagens e desvantagens, propomos o XLNet, um método generalizado de pré-treinamento autoregressivo que (1) permite a aprendizagem de contextos bidirecionais maximizando a verossimilhança esperada sobre todas as permutações da ordem de fatoração e (2) supera as limitações do BERT graças à sua formulação autoregressiva. Além disso, o XLNet integra ideias do Transformer-XL, o modelo autoregressivo mais avançado, no pré-treinamento. Empiricamente, sob configurações de experimento comparáveis, o XLNet supera o BERT em 20 tarefas, muitas vezes por uma margem significativa, incluindo resposta a perguntas, inferência de linguagem natural, análise de sentimento e classificação de documentos.*

Este modelo foi contribuído por [thomwolf](https://huggingface.co/thomwolf). O código original pode ser encontrado [aqui](https://github.com/zihangdai/xlnet/).

## Dicas de uso

- O padrão de atenção específico pode ser controlado nos momentos de treinamento e de teste usando a entrada `perm_mask`.
- Devido à dificuldade de treinar um modelo totalmente auto-regressivo sobre várias ordens de fatorização, o XLNet é pré-treinado usando apenas um subconjunto dos tokens de saída como alvo, selecionados pela entrada `target_mapping`.
- Para usar o XLNet para decodificação sequencial (ou seja, não em configuração totalmente bidirecional), utilize as entradas `perm_mask` e `target_mapping` para controlar o alcance da atenção e as saídas
- XLNet é um dos poucos modelos que não possui limite de comprimento de sequência.
- XLNet não é um modelo autoregressivo tradicional, mas utiliza uma estratégia de treinamento que se baseia nesse conceito. Ele permuta os tokens da frase e, em seguida, permite que o modelo use os últimos n tokens para prever o token n+1. Como tudo isso é feito com uma máscara, a frase é, na verdade, inserida no modelo na ordem correta, mas, em vez de mascarar os primeiros n tokens para n+1, o XLNet usa uma máscara que oculta os tokens anteriores em alguma permutação dada de 1,…,comprimento da sequência.
- O XLNet também utiliza o mesmo mecanismo de recorrência do Transformer-XL para construir dependências de longo prazo.

## Recursos

- [Guia da tarefa de classificação de texto](../tasks/sequence_classification)
- [Guia de tarefas de classificação de tokens](../tasks/token_classification)
- [Guia da tarefa de resposta a perguntas](../tasks/question_answering)
- [Guia da tarefa de modelagem de linguagem causal](../tasks/language_modeling)
- [Guia de tarefas de múltipla escolha](../tasks/multiple_choice)

## XLNetConfig[[transformers.XLNetConfig]]

#### transformers.XLNetConfig[[transformers.XLNetConfig]]

```python
transformers.XLNetConfig(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 = 32000, d_model: int = 1024, n_layer: int = 24, n_head: int = 16, d_inner: int = 4096, d_head: int | None = None, ff_activation: str = 'gelu', attn_type: str = 'bi', initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, dropout: float | int = 0.1, mem_len: int | None = 512, reuse_len: int | None = None, use_mems_eval: bool = True, use_mems_train: bool = False, bi_data: bool = False, clamp_len: int = -1, same_length: bool = False, summary_type: str = 'last', summary_use_proj: bool = True, summary_activation: str = 'tanh', summary_last_dropout: float | int = 0.1, start_n_top: int = 5, end_n_top: int = 5, pad_token_id: int | None = 5, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, tie_word_embeddings: bool = True)
```

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

**Parâmetros:**

vocab_size (`int`, *opcional*, padrão `32000`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

d_model (`int`, *opcional*, padrão `1024`) : Tamanho das camadas do codificador e da camada pooler.

n_layer (`int`, *opcional*, padrão `24`) : Número de camadas ocultas no decodificador do Transformer.

n_head (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

d_inner (`int`, *opcional*, padrão `4096`) : Dimensão das representações do MLP.

d_head (`int`, *opcional*) : A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads

ff_activation (`str` ou `Callable`, *opcional*, padrão `"gelu"`) : A função de ativação não linear (função ou string) no. Se for string, `"gelu"`, `"relu"`, `"silu"` e `"gelu_new"` são suportadas.

attn_type (`str`, *opcional*, padrão `"bi"`) : O tipo de atenção usado pelo modelo. Defina `"bi"` para XLNet, `"uni"` para Transformer-XL.

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-12`) : O epsilon usado pelas camadas de normalização de camada.

dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A proporção para todas as camadas de dropout.

mem_len (`int` ou `None`, *opcional*) : O número de tokens a serem armazenados em cache. Os pares de chave/valor que já foram pré-computados em uma passagem de frente anterior não serão recalculados. Consulte o [quickstart](https://huggingface.co/transformers/quickstart.html#using-the-past) para mais informações.

reuse_len (`int`, *opcional*) : O número de tokens no lote atual que serão armazenados em cache e reutilizados no futuro.

use_mems_eval (`bool`, *opcional*, padrão `True`) : Se o modelo deve ou não utilizar o mecanismo de memória recorrente no modo de avaliação.

use_mems_train (`bool`, *opcional*, padrão `False`) : Se o modelo deve ou não fazer uso do mecanismo de memória recorrente no modo de treinamento. Para pré-treinamento, recomenda-se definir `use_mems_train` como `True`. Para ajuste fino, recomenda-se definir `use_mems_train` como `False`, conforme discutido [aqui](https://github.com/zihangdai/xlnet/issues/41#issuecomment-505102587). Se `use_mems_train` for definido como `True`, é necessário garantir que os lotes de treinamento sejam pré-processados corretamente, *por exemplo* `batch_1 = [[This line is], [This is the]]` e `batch_2 = [[ the first line], [ second line]]`, e que todos os lotes tenham o mesmo tamanho.

bi_data (`bool`, *opcional*, padrão `False`) : Se deve ou não usar o pipeline de entrada bidirecional. Geralmente definido como `True` durante o pré-treinamento e `False` durante o ajuste fino.

clamp_len (`int`, *opcional*, padrão -1) : Limita todas as distâncias relativas maiores que clamp_len. Definir este atributo como -1 significa que não há limitação.

same_length (`bool`, *opcional*, padrão `False`) : Se deve ou não usar o mesmo comprimento de atenção para cada token.

summary_type (`str`, *opcional*, padrão "last") : Argumento usado ao realizar o resumo da sequência. Utilizado nos modelos de classificação de sequência e escolha múltipla. Deve ser uma das seguintes opções: - `"last"`: Adota o estado oculto do último token (como no XLNet). - `"first"`: Adota o estado oculto do primeiro token (como no BERT). - `"mean"`: Adota a média dos estados ocultos de todos os tokens. - `"cls_index"`: Fornece um Tensor com a posição do token de classificação (como no GPT/GPT-2). - `"attn"`: Não implementado no momento, usa atenção multi-cabeça.

summary_use_proj (`bool`, *opcional*, padrão `True`) : Argumento utilizado ao realizar o resumo de sequência. Usado nos modelos de classificação de sequência e escolha múltipla. Indica se deve ou não adicionar uma projeção após a extração do vetor.

summary_activation (`str`, *opcional*) : Argumento usado ao realizar o resumo de sequência. Utilizado nos modelos de classificação de sequência e escolha múltipla. Passe `"tanh"` para uma ativação tanh na saída; qualquer outro valor resultará em nenhuma ativação.

summary_last_dropout (`float`, *opcional*, padrão 0.1) : Usado nos modelos de classificação de sequência e escolha múltipla. A taxa de dropout a ser usada após a projeção e a ativação.

start_n_top (`int`, *opcional*, padrão 5) : Usado no script de avaliação SQuAD.

end_n_top (`int`, *opcional*, padrão 5) : Usado no script de avaliação SQuAD.

pad_token_id (`int`, *opcional*, padrão `5`) : 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.

tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo.

Esta é a classe de configuração para armazenar a configuração de um XLNetModel. Ela é usada para instanciar um modelo Xlnet 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 [xlnet/xlnet-large-cased](https://huggingface.co/xlnet/xlnet-large-cased)

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.

Exemplos:

```python
>>> from transformers import XLNetConfig, XLNetModel

>>> # Initializing a XLNet configuration
>>> configuration = XLNetConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = XLNetModel(configuration)

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

## XLNetTokenizer[[transformers.XLNetTokenizer]]

#### transformers.XLNetTokenizer[[transformers.XLNetTokenizer]]

```python
transformers.XLNetTokenizer(vocab: str | list[tuple[str, float]] | None = None, unk_id: int = 0, do_lower_case = False, remove_space = True, keep_accents = False, bos_token = '<s>', eos_token = '</s>', unk_token = '<unk>', sep_token = '<sep>', pad_token = '<pad>', cls_token = '<cls>', mask_token = '<mask>', _spm_precompiled_charsmap = None, additional_special_tokens = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/tokenization_xlnet.py#L38)

**Parâmetros:**

vocab (`list of tuples`, *opcional*) : Lista de tuplas (token, score) para o modelo Unigram. Se não for fornecida, uma lista vazia é usada.

unk_id (`int`, *opcional*, padrão 0) : O ID do token desconhecido no vocabulário.

do_lower_case (`bool`, *opcional*, padrão `False`) : Se deve converter a entrada para minúsculas ao tokenizar.

remove_space (`bool`, *opcional*, padrão `True`) : Se deve remover espaços em branco ao tokenizar (removendo espaços excedentes antes e depois da string).

keep_accents (`bool`, *opcional*, padrão `False`) : Se deve manter acentos ao tokenizar.

bos_token (`str`, *opcional*, padrão `"<s>"`) : O token de início de sequência usado durante o pré-treinamento. Pode ser usado como token de classificador de sequência.    Ao construir uma sequência usando tokens especiais, este não é o token utilizado para o início da sequência. O token utilizado é o `cls_token`.

eos_token (`str`, *opcional*, padrão `"</s>"`) : O token de fim de sequência. Ao construir uma sequência usando tokens especiais, este não é o token utilizado para o fim da sequência. O token utilizado é o `sep_token`.

unk_token (`str`, *opcional*, padrão `"<unk>"`) : 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.

sep_token (`str`, *opcional*, padrão `"<sep>"`) : O token separador, utilizado ao construir uma sequência a partir de múltiplas sequências, por exemplo, duas sequências para classificação de sequência ou um texto e uma pergunta para resposta a perguntas. Também é usado como o último token de uma sequência construída com tokens especiais.

pad_token (`str`, *opcional*, padrão `"<pad>"`) : O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes.

cls_token (`str`, *opcional*, padrão `"<cls>"`) : O token de classificador usado ao realizar classificação de sequência (classificação da sequência inteira, em vez de classificação por token). É o primeiro token da sequência quando esta é construída com tokens especiais.

mask_token (`str`, *opcional*, padrão `"<mask>"`) : O token usado para mascarar valores. Este é o token utilizado ao treinar este modelo com modelagem de linguagem mascarada. É o token que o modelo tentará prever.

additional_special_tokens (`list[str]`, *opcional*, padrão `["<eop>", "<eod>"]`) : Tokens especiais adicionais usados pelo tokenizer.

Construa um tokenizador XLNet (baseado na biblioteca *tokenizers* do HuggingFace). Baseado em [Unigram](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=unigram#models).

Este tokenizer herda de [TokenizersBackend](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend), que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.

#### get_special_tokens_mask[[transformers.XLNetTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

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

**Parâmetros:**

token_ids_0 : Lista de IDs da sequência (possivelmente já formatada).

token_ids_1 : Não utilizado quando `already_has_special_tokens=True`. Deve ser None nesse caso.

already_has_special_tokens : Indica se a sequência já está formatada com tokens especiais.

**Retorna:** Uma lista de inteiros no intervalo [0, 1]

1 para um token especial, 0 para um token de sequência.

Obter os ids de sequência de uma lista de tokens que não possui tokens especiais adicionados.

Para tokenizadores rápidos, os data collators chamam isso com `already_has_special_tokens=True` para construir uma máscara sobre uma sequência já formatada. Nesse caso, calculamos a máscara verificando a pertença em `all_special_ids`.

#### save_vocabulary[[transformers.XLNetTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

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

## Saídas específicas do XLNet[[transformers.models.xlnet.modeling_xlnet.XLNetModelOutput]]

#### transformers.models.xlnet.modeling_xlnet.XLNetModelOutput[[transformers.models.xlnet.modeling_xlnet.XLNetModelOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetModelOutput(last_hidden_state: Tensor, mems: list[torch.Tensor] | None = 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/xlnet/modeling_xlnet.py#L659)

**Parâmetros:**

last_hidden_state (`torch.Tensor` de forma `(batch_size, num_predict, hidden_size)`) : Sequência de hidden-states na última camada do modelo. `num_predict` corresponde a `target_mapping.shape[1]`. Se `target_mapping` for `None`, então `num_predict` corresponde a `sequence_length`.

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.

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 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 de atenção 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 [XLNetModel](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetModel).

#### transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput[[transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = 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/xlnet/modeling_xlnet.py#L684)

**Parâmetros:**

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, num_predict, 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). `num_predict` corresponde a `target_mapping.shape[1]`. Se `target_mapping` for `None`, então `num_predict` corresponde a `sequence_length`.

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.

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 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 de atenção 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 [XLNetLMHeadModel](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetLMHeadModel).

#### transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = 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/xlnet/modeling_xlnet.py#L712)

**Parâmetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `label` é fornecido) : Perda de classificação (ou regressão se config.num_labels==1).

logits (`torch.Tensor` de forma `(batch_size, config.num_labels)`) : Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.

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 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 de atenção 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 [XLNetForSequenceClassification](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetForSequenceClassification).

#### transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = 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/xlnet/modeling_xlnet.py#L762)

**Parâmetros:**

loss (`torch.Tensor` de forma *(1,)*, *opcional*, retornado quando `labels` é fornecido) : Perda de classificação.

logits (`torch.Tensor` de forma `(batch_size, num_choices)`) : *num_choices* é a segunda dimensão dos tensors de entrada. (veja *input_ids* acima). Pontuações de classificação (antes do SoftMax).

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.

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 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 de atenção 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 [XLNetForMultipleChoice](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetForMultipleChoice).

#### transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = 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/xlnet/modeling_xlnet.py#L737)

**Parâmetros:**

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

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.

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 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 de atenção 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 `XLNetForTokenClassificationOutput`.

#### transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = 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/xlnet/modeling_xlnet.py#L789)

**Parâmetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) : A perda total de extração de span é a soma de uma Entropia Cruzada para as posições de início e fim.

start_logits (`torch.Tensor` de forma `(batch_size, sequence_length,)`) : Pontuações de início de span (antes do SoftMax).

end_logits (`torch.Tensor` de forma `(batch_size, sequence_length,)`) : Pontuações de fim de trecho (antes do SoftMax).

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.

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 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 de atenção 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 [XLNetForQuestionAnsweringSimple](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetForQuestionAnsweringSimple).

#### transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, start_top_log_probs: typing.Optional[torch.Tensor] = None, start_top_index: typing.Optional[torch.LongTensor] = None, end_top_log_probs: typing.Optional[torch.Tensor] = None, end_top_index: typing.Optional[torch.LongTensor] = None, cls_logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = 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/xlnet/modeling_xlnet.py#L817)

**Parâmetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, retornado se `start_positions` e `end_positions` forem fornecidos) : Perda de classificação como a soma das perdas de classificação do token inicial, do token final (e de is_impossible, se fornecido).

start_top_log_probs (`torch.Tensor` de forma `(batch_size, config.start_n_top)`, *opcional*, retornado se `start_positions` ou `end_positions` não for fornecido) : Probabilidades logarítmicas para as config.start_n_top possibilidades de tokens de início (beam-search).

start_top_index (`torch.LongTensor` de forma `(batch_size, config.start_n_top)`, *opcional*, retornado se `start_positions` ou `end_positions` não for fornecido) : Índices para as config.start_n_top melhores possibilidades de tokens de início (beam-search).

end_top_log_probs (`torch.Tensor` de forma `(batch_size, config.start_n_top * config.end_n_top)`, *opcional*, retornado se `start_positions` ou `end_positions` não for fornecido) : Probabilidades logarítmicas para as `config.start_n_top * config.end_n_top` melhores possibilidades de tokens finais (busca por feixe).

end_top_index (`torch.LongTensor` de forma `(batch_size, config.start_n_top * config.end_n_top)`, *opcional*, retornado se `start_positions` ou `end_positions` não for fornecido) : Índices para as `config.start_n_top * config.end_n_top` melhores possibilidades de tokens finais (beam-search).

cls_logits (`torch.Tensor` de forma `(batch_size,)`, *opcional*, retornado se `start_positions` ou `end_positions` não for fornecido) : Probabilidades logarítmicas para o rótulo `is_impossible` das respostas.

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.

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 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 de atenção 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 [XLNetForQuestionAnswering](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetForQuestionAnswering).

## XLNetModel[[transformers.XLNetModel]]

#### transformers.XLNetModel[[transformers.XLNetModel]]

```python
transformers.XLNetModel(config: XLNetConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L851)

**Parâmetros:**

config ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) : 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 Xlnet 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.XLNetModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L976)

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

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)

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados (veja a saída `mems` abaixo). Pode ser usado para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados. `use_mems` deve ser definido como `True` para fazer uso de `mems`.

perm_mask (`torch.Tensor` de forma `(batch_size, sequence_length, sequence_length)`, *opcional*) : Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em `[0, 1]`:  - se `perm_mask[k, i, j] = 0`, i presta atenção a j no lote k; - se `perm_mask[k, i, j] = 1`, i não presta atenção a j no lote k.  Se não for definida, cada token presta atenção a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).

target_mapping (`torch.Tensor` de forma `(batch_size, num_predict, sequence_length)`, *opcional*) : Máscara para indicar os tokens de saída a serem usados. Se `target_mapping[k, i, j] = 1`, o i-ésimo predict do batch k está no j-ésimo token. Usado apenas durante o pré-treinamento para predição parcial ou para decodificação sequencial (geração).

token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

input_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. Negativo de `attention_mask`, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que estão **mascarados**, - 0 para tokens que **não estão mascarados**. Você pode usar apenas um de `input_mask` e `attention_mask`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

use_mems (`bool`, *opcional*) : Se deve usar estados de memória para acelerar a decodificação sequencial. Se definido como `True`, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [XLNetModelOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetModelOutput) ou `tuple(torch.Tensor)`

Um [XLNetModelOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetModelOutput) 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 ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) e das entradas.

O método forward do [XLNetModel](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetModel) 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, num_predict, hidden_size)`) -- Sequência de estados ocultos na última camada do modelo.

  `num_predict` corresponde a `target_mapping.shape[1]`. Se `target_mapping` for `None`, então `num_predict` corresponde a `sequence_length`.
- **mems** (`list[torch.Tensor]` de comprimento `config.n_layers`) -- Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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.

## XLNetLMHeadModel[[transformers.XLNetLMHeadModel]]

#### transformers.XLNetLMHeadModel[[transformers.XLNetLMHeadModel]]

```python
transformers.XLNetLMHeadModel(config: XLNetConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L1215)

**Parâmetros:**

config ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) : 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 XLNet com uma cabeça de modelagem de linguagem no topo (camada linear com pesos vinculados aos embeddings de entrada).

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L1290)

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

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)

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados (veja a saída `mems` abaixo). Pode ser usado para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados. `use_mems` deve ser definido como `True` para fazer uso de `mems`.

perm_mask (`torch.Tensor` de forma `(batch_size, sequence_length, sequence_length)`, *opcional*) : Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em `[0, 1]`:  - se `perm_mask[k, i, j] = 0`, i presta atenção a j no lote k; - se `perm_mask[k, i, j] = 1`, i não presta atenção a j no lote k.  Se não for definida, cada token presta atenção a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).

target_mapping (`torch.Tensor` de forma `(batch_size, num_predict, sequence_length)`, *opcional*) : Máscara para indicar os tokens de saída a serem usados. Se `target_mapping[k, i, j] = 1`, o i-ésimo predict do batch k está no j-ésimo token. Usado apenas durante o pré-treinamento para predição parcial ou para decodificação sequencial (geração).

token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

input_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. Negativo de `attention_mask`, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que estão **mascarados**, - 0 para tokens que **não estão mascarados**. Você pode usar apenas um de `input_mask` e `attention_mask`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

labels (`torch.LongTensor` de forma `(batch_size, num_predict)`, *opcional*) : Rótulos para modelagem de linguagem mascarada. `num_predict` corresponde a `target_mapping.shape[1]`. Se `target_mapping` for `None`, então `num_predict` corresponde a `sequence_length`. Os rótulos devem corresponder às palavras de entrada mascaradas que devem ser previstas e dependem de `target_mapping`. Observe que, para realizar a modelagem de linguagem auto-regressiva padrão, um token ** precisa ser adicionado aos `input_ids` (veja a função `prepare_inputs_for_generation` e os exemplos abaixo) Os índices são selecionados em `[-100, 0, ..., config.vocab_size]` Todos os rótulos definidos como `-100` são ignorados; a perda é calculada apenas para rótulos em `[0, ..., config.vocab_size]`

use_mems (`bool`, *opcional*) : Se deve usar estados de memória para acelerar a decodificação sequencial. Se definido como `True`, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, padrão `0`) : Se for um `int`, calcula os logits para os últimos `logits_to_keep` tokens. Se for `0`, calcula os logits para todos os `input_ids` (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um `torch.Tensor`, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência).

**Retorna:** [XLNetLMHeadModelOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput) ou `tuple(torch.Tensor)`

Um [XLNetLMHeadModelOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput) 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 ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) e das entradas.

O método forward do [XLNetLMHeadModel](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetLMHeadModel) 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 modelagem de linguagem (para previsão do próximo token).
- **logits** (`torch.Tensor` de forma `(batch_size, num_predict, 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).

  `num_predict` corresponde a `target_mapping.shape[1]`. Se `target_mapping` for `None`, então `num_predict` corresponde a `sequence_length`.
- **mems** (`list[torch.Tensor]` de comprimento `config.n_layers`) -- Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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.

Exemplos:

```python
>>> from transformers import AutoTokenizer, XLNetLMHeadModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetLMHeadModel.from_pretrained("xlnet/xlnet-large-cased")

>>> # We show how to setup inputs to predict a next token using a bi-directional context.
>>> input_ids = torch.tensor(
...     tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
...     0
... )  # We will predict the masked token
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[:, :, -1] = 1.0  # Previous tokens don't see last token
>>> target_mapping = torch.zeros(
...     (1, 1, input_ids.shape[1]), dtype=torch.float
... )  # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
...     0, 0, -1
... ] = 1.0  # Our first (and only) prediction will be the last token of the sequence (the masked token)

>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping)
>>> next_token_logits = outputs[
...     0
... ]  # Output has shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]

>>> # The same way can the XLNetLMHeadModel be used to be trained by standard auto-regressive language modeling.
>>> input_ids = torch.tensor(
...     tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
...     0
... )  # We will predict the masked token
>>> labels = torch.tensor(tokenizer.encode("cute", add_special_tokens=False)).unsqueeze(0)
>>> assert labels.shape[0] == 1, "only one word will be predicted"
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[
...     :, :, -1
... ] = 1.0  # Previous tokens don't see last token as is done in standard auto-regressive lm training
>>> target_mapping = torch.zeros(
...     (1, 1, input_ids.shape[1]), dtype=torch.float
... )  # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
...     0, 0, -1
... ] = 1.0  # Our first (and only) prediction will be the last token of the sequence (the masked token)

>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping, labels=labels)
>>> loss = outputs.loss
>>> next_token_logits = (
...     outputs.logits
... )  # Logits have shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]
```

## XLNetForSequenceClassification[[transformers.XLNetForSequenceClassification]]

#### transformers.XLNetForSequenceClassification[[transformers.XLNetForSequenceClassification]]

```python
transformers.XLNetForSequenceClassification(config: XLNetConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L1462)

**Parâmetros:**

config ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) : 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 XLNet com uma cabeça de classificação/regressão de sequência no topo (uma camada linear no topo da saída agregada), por exemplo, para tarefas GLUE.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L1475)

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

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)

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados (veja a saída `mems` abaixo). Pode ser usado para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados. `use_mems` deve ser definido como `True` para fazer uso de `mems`.

perm_mask (`torch.Tensor` de forma `(batch_size, sequence_length, sequence_length)`, *opcional*) : Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em `[0, 1]`:  - se `perm_mask[k, i, j] = 0`, i presta atenção a j no lote k; - se `perm_mask[k, i, j] = 1`, i não presta atenção a j no lote k.  Se não for definida, cada token presta atenção a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).

target_mapping (`torch.Tensor` de forma `(batch_size, num_predict, sequence_length)`, *opcional*) : Máscara para indicar os tokens de saída a serem usados. Se `target_mapping[k, i, j] = 1`, o i-ésimo predict do batch k está no j-ésimo token. Usado apenas durante o pré-treinamento para predição parcial ou para decodificação sequencial (geração).

token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

input_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. Negativo de `attention_mask`, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que estão **mascarados**, - 0 para tokens que **não estão mascarados**. Você pode usar apenas um de `input_mask` e `attention_mask`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

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

use_mems (`bool`, *opcional*) : Se deve usar estados de memória para acelerar a decodificação sequencial. Se definido como `True`, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [XLNetForSequenceClassificationOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput) ou `tuple(torch.Tensor)`

Um [XLNetForSequenceClassificationOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput) 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 ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) e das entradas.

O método forward de [XLNetForSequenceClassification](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetForSequenceClassification) 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 `label` é fornecido) -- Perda de classificação (ou regressão se config.num_labels==1).
- **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).
- **mems** (`list[torch.Tensor]` de comprimento `config.n_layers`) -- Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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, XLNetForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased")

>>> 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 = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased", 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, XLNetForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased", 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 = XLNetForSequenceClassification.from_pretrained(
...     "xlnet/xlnet-large-cased", 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
```

## XLNetForMultipleChoice[[transformers.XLNetForMultipleChoice]]

#### transformers.XLNetForMultipleChoice[[transformers.XLNetForMultipleChoice]]

```python
transformers.XLNetForMultipleChoice(config: XLNetConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L1694)

**Parâmetros:**

config ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) : 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 Xlnet com uma cabeça de classificação de múltipla escolha no topo (uma camada linear no topo da saída agregada e um softmax), por exemplo, para as tarefas RocStories/SWAG.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L1705)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, num_choices, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

token_type_ids (`torch.LongTensor` de forma `(batch_size, num_choices, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

input_mask (`torch.Tensor` de forma `batch_size, num_choices, sequence_length`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Negativo de `attention_mask`, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que estão **mascarados**, - 0 para tokens que **não estão mascarados**. Você pode usar apenas um de `input_mask` e `attention_mask`.

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)

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados (veja a saída `mems` abaixo). Pode ser usado para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados. `use_mems` deve ser definido como `True` para fazer uso de `mems`.

perm_mask (`torch.Tensor` de forma `(batch_size, sequence_length, sequence_length)`, *opcional*) : Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em `[0, 1]`:  - se `perm_mask[k, i, j] = 0`, i presta atenção a j no lote k; - se `perm_mask[k, i, j] = 1`, i não presta atenção a j no lote k.  Se não for definida, cada token presta atenção a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).

target_mapping (`torch.Tensor` de forma `(batch_size, num_predict, sequence_length)`, *opcional*) : Máscara para indicar os tokens de saída a serem usados. Se `target_mapping[k, i, j] = 1`, o i-ésimo predict do batch k está no j-ésimo token. Usado apenas durante o pré-treinamento para predição parcial ou para decodificação sequencial (geração).

inputs_embeds (`torch.Tensor` de forma `(batch_size, num_choices, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de incorporação interna do modelo.

labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para calcular a perda de classificação de múltipla escolha. Os índices devem estar em `[0, ...,

use_mems (`bool`, *opcional*) : Se deve usar estados de memória para acelerar a decodificação sequencial. Se definido como `True`, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [XLNetForMultipleChoiceOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput) ou `tuple(torch.Tensor)`

Um [XLNetForMultipleChoiceOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput) 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 ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) e das entradas.

O método forward de [XLNetForMultipleChoice](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetForMultipleChoice) 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, num_choices)`) -- *num_choices* é a segunda dimensão dos tensors de entrada. (veja *input_ids* acima).

  Pontuações de classificação (antes do SoftMax).
- **mems** (`list[torch.Tensor]` de comprimento `config.n_layers`) -- Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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 AutoTokenizer, XLNetForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForMultipleChoice.from_pretrained("xlnet/xlnet-large-cased")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## XLNetForTokenClassification[[transformers.XLNetForTokenClassification]]

#### transformers.XLNetForTokenClassification[[transformers.XLNetForTokenClassification]]

```python
transformers.XLNetForTokenClassification(config: XLNetConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L1586)

**Parâmetros:**

config ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) : 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 transformer Xlnet com uma cabeça de classificação de tokens no topo (uma camada linear no topo da saída dos estados ocultos), por exemplo, para tarefas de Reconhecimento de Entidades Nomeadas (NER).

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L1597)

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

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)

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados (veja a saída `mems` abaixo). Pode ser usado para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados. `use_mems` deve ser definido como `True` para fazer uso de `mems`.

perm_mask (`torch.Tensor` de forma `(batch_size, sequence_length, sequence_length)`, *opcional*) : Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em `[0, 1]`:  - se `perm_mask[k, i, j] = 0`, i presta atenção a j no lote k; - se `perm_mask[k, i, j] = 1`, i não presta atenção a j no lote k.  Se não for definida, cada token presta atenção a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).

target_mapping (`torch.Tensor` de forma `(batch_size, num_predict, sequence_length)`, *opcional*) : Máscara para indicar os tokens de saída a serem usados. Se `target_mapping[k, i, j] = 1`, o i-ésimo predict do batch k está no j-ésimo token. Usado apenas durante o pré-treinamento para predição parcial ou para decodificação sequencial (geração).

token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

input_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. Negativo de `attention_mask`, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que estão **mascarados**, - 0 para tokens que **não estão mascarados**. Você pode usar apenas um de `input_mask` e `attention_mask`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para calcular a perda de classificação de múltipla escolha. Os índices devem estar em `[0, ..., num_choices]`, onde *num_choices* é o tamanho da segunda dimensão dos tensores de entrada. (veja *input_ids* acima)

use_mems (`bool`, *opcional*) : Se deve usar estados de memória para acelerar a decodificação sequencial. Se definido como `True`, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial. Estados de memória para acelerar a decodificação sequencial. Se definido como `True`, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [XLNetForTokenClassificationOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput) ou `tuple(torch.Tensor)`

Um [XLNetForTokenClassificationOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput) 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 ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) e das entradas.

O método forward de [XLNetForTokenClassification](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetForTokenClassification) 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).
- **mems** (`list[torch.Tensor]` de comprimento `config.n_layers`) -- Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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 AutoTokenizer, XLNetForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForTokenClassification.from_pretrained("xlnet/xlnet-large-cased")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

## XLNetForQuestionAnsweringSimple[[transformers.XLNetForQuestionAnsweringSimple]]

#### transformers.XLNetForQuestionAnsweringSimple[[transformers.XLNetForQuestionAnsweringSimple]]

```python
transformers.XLNetForQuestionAnsweringSimple(config: XLNetConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L1838)

**Parâmetros:**

config ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) : 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 XLNet com uma cabeça de classificação de span no topo para tarefas de question-answering extrativo, como SQuAD (uma camada linear no topo da saída dos hidden-states para calcular `span start logits` e `span end logits`).

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L1849)

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

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)

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados (veja a saída `mems` abaixo). Pode ser usado para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados. `use_mems` deve ser definido como `True` para fazer uso de `mems`.

perm_mask (`torch.Tensor` de forma `(batch_size, sequence_length, sequence_length)`, *opcional*) : Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em `[0, 1]`:  - se `perm_mask[k, i, j] = 0`, i presta atenção a j no lote k; - se `perm_mask[k, i, j] = 1`, i não presta atenção a j no lote k.  Se não for definida, cada token presta atenção a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).

target_mapping (`torch.Tensor` de forma `(batch_size, num_predict, sequence_length)`, *opcional*) : Máscara para indicar os tokens de saída a serem usados. Se `target_mapping[k, i, j] = 1`, o i-ésimo predict do batch k está no j-ésimo token. Usado apenas durante o pré-treinamento para predição parcial ou para decodificação sequencial (geração).

token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

input_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. Negativo de `attention_mask`, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que estão **mascarados**, - 0 para tokens que **não estão mascarados**. Você pode usar apenas um de `input_mask` e `attention_mask`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

start_positions (`torch.Tensor` de forma `(batch_size,)`, *opcional*) : Rótulos para a posição (índice) do início do trecho rotulado para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (`sequence_length`). Posições fora da sequência não são consideradas no cálculo da perda.

end_positions (`torch.Tensor` de forma `(batch_size,)`, *opcional*) : Rótulos para a posição (índice) do final do trecho rotulado para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (`sequence_length`). Posições fora da sequência não são consideradas no cálculo da perda.

use_mems (`bool`, *opcional*) : Se deve usar estados de memória para acelerar a decodificação sequencial. Se definido como `True`, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [XLNetForQuestionAnsweringSimpleOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput) ou `tuple(torch.Tensor)`

Um [XLNetForQuestionAnsweringSimpleOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput) 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 ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) e das entradas.

O método forward de [XLNetForQuestionAnsweringSimple](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetForQuestionAnsweringSimple) 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` é fornecida) -- A perda total de extração de spans é a soma de uma Cross-Entropy para as posições de início e fim.
- **start_logits** (`torch.Tensor` de forma `(batch_size, sequence_length,)`) -- Pontuações de início de trecho (antes do SoftMax).
- **end_logits** (`torch.Tensor` de forma `(batch_size, sequence_length,)`) -- Pontuações de fim de trecho (antes do SoftMax).
- **mems** (`list[torch.Tensor]` de comprimento `config.n_layers`) -- Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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 AutoTokenizer, XLNetForQuestionAnsweringSimple
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForQuestionAnsweringSimple.from_pretrained("xlnet/xlnet-large-cased")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...
```

## XLNetForQuestionAnswering[[transformers.XLNetForQuestionAnswering]]

#### transformers.XLNetForQuestionAnswering[[transformers.XLNetForQuestionAnswering]]

```python
transformers.XLNetForQuestionAnswering(config: XLNetConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L1959)

**Parâmetros:**

config ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) : 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 transformer Xlnet com uma cabeça de classificação de spans no topo para tarefas de question-answering extrativo como SQuAD (uma camada linear no topo da saída dos hidden-states para calcular `span start logits` e `span end logits`).

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, is_impossible: typing.Optional[torch.Tensor] = None, cls_index: typing.Optional[torch.Tensor] = None, p_mask: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlnet/modeling_xlnet.py#L1973)

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

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)

mems (`list[torch.Tensor]` de comprimento `config.n_layers`) : Contém hidden-states pré-computados (veja a saída `mems` abaixo). Pode ser usado para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados. `use_mems` deve ser definido como `True` para fazer uso de `mems`.

perm_mask (`torch.Tensor` de forma `(batch_size, sequence_length, sequence_length)`, *opcional*) : Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em `[0, 1]`:  - se `perm_mask[k, i, j] = 0`, i presta atenção a j no lote k; - se `perm_mask[k, i, j] = 1`, i não presta atenção a j no lote k.  Se não for definida, cada token presta atenção a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).

target_mapping (`torch.Tensor` de forma `(batch_size, num_predict, sequence_length)`, *opcional*) : Máscara para indicar os tokens de saída a serem usados. Se `target_mapping[k, i, j] = 1`, o i-ésimo predict do batch k está no j-ésimo token. Usado apenas durante o pré-treinamento para predição parcial ou para decodificação sequencial (geração).

token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

input_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. Negativo de `attention_mask`, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que estão **mascarados**, - 0 para tokens que **não estão mascarados**. Você pode usar apenas um de `input_mask` e `attention_mask`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

start_positions (`torch.Tensor` de forma `(batch_size,)`, *opcional*) : Rótulos para a posição (índice) do início do trecho rotulado para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (`sequence_length`). Posições fora da sequência não são consideradas no cálculo da perda.

end_positions (`torch.Tensor` de forma `(batch_size,)`, *opcional*) : Rótulos para a posição (índice) do final do trecho rotulado para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (`sequence_length`). Posições fora da sequência não são consideradas no cálculo da perda.

is_impossible (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos indicando se uma pergunta tem uma resposta ou não (SQuAD 2.0)

cls_index (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para a posição (índice) do token de classificação a ser usado como entrada para o cálculo da plausibilidade da resposta.

p_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara opcional de tokens que não podem estar nas respostas (por exemplo, [CLS], [PAD], ...). 1.0 significa que o token deve ser mascarado. 0.0 significa que o token não é mascarado.

use_mems (`bool`, *opcional*) : Se deve usar estados de memória para acelerar a decodificação sequencial. Se definido como `True`, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [XLNetForQuestionAnsweringOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput) ou `tuple(torch.Tensor)`

Um [XLNetForQuestionAnsweringOutput](/docs/transformers/main/pt/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput) 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 ([XLNetConfig](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetConfig)) e das entradas.

O método forward de [XLNetForQuestionAnswering](/docs/transformers/main/pt/model_doc/xlnet#transformers.XLNetForQuestionAnswering) 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 se `start_positions` e `end_positions` forem fornecidos) -- Perda de classificação como a soma das perdas de classificação do token inicial, do token final (e de is_impossible, se fornecido).
- **start_top_log_probs** (`torch.Tensor` de forma `(batch_size, config.start_n_top)`, *opcional*, retornado se `start_positions` ou `end_positions` não forem fornecidos) -- Probabilidades logarítmicas para as config.start_n_top melhores possibilidades de tokens de início (beam-search).
- **start_top_index** (`torch.LongTensor` de forma `(batch_size, config.start_n_top)`, *opcional*, retornado se `start_positions` ou `end_positions` não for fornecido) -- Índices para as config.start_n_top melhores possibilidades de tokens de início (busca por feixe).
- **end_top_log_probs** (`torch.Tensor` de forma `(batch_size, config.start_n_top * config.end_n_top)`, *opcional*, retornado se `start_positions` ou `end_positions` não forem fornecidos) -- Probabilidades logarítmicas para as `config.start_n_top * config.end_n_top` melhores possibilidades de tokens finais (beam-search).
- **end_top_index** (`torch.LongTensor` de forma `(batch_size, config.start_n_top * config.end_n_top)`, *opcional*, retornado se `start_positions` ou `end_positions` não for fornecido) -- Índices para as `config.start_n_top * config.end_n_top` melhores possibilidades de tokens de fim (beam-search).
- **cls_logits** (`torch.Tensor` de forma `(batch_size,)`, *opcional*, retornado se `start_positions` ou `end_positions` não forem fornecidos) -- Probabilidades logarítmicas para o rótulo `is_impossible` das respostas.
- **mems** (`list[torch.Tensor]` de comprimento `config.n_layers`) -- Contém hidden-states pré-computados. Pode ser usado (veja a entrada `mems`) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados como `input_ids`, pois já foram computados.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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 AutoTokenizer, XLNetForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = XLNetForQuestionAnswering.from_pretrained("xlnet/xlnet-base-cased")

>>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(
...     0
... )  # Batch size 1
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([3])
>>> outputs = model(input_ids, start_positions=start_positions, end_positions=end_positions)

>>> loss = outputs.loss
```