# Reformer

## Visão geral

O modelo Reformer foi proposto no artigo [Reformer: The Efficient Transformer](https://huggingface.co/papers/2001.04451), de Nikita Kitaev, Łukasz Kaiser e Anselm Levskaya.

O resumo do artigo é o seguinte:

*Modelos de Transformer de grande porte alcançam rotineiramente resultados de estado da arte em diversas tarefas, mas o treinamento desses modelos pode ser proibitivamente caro, especialmente em sequências longas. Apresentamos duas técnicas para melhorar a eficiência dos Transformers. Em primeiro lugar, substituímos a atenção de produto escalar por uma que utiliza hashing sensível à localidade, alterando sua complexidade de O(L^2) para O(Llog(L)), onde L é o comprimento da sequência. Além disso, utilizamos camadas residuais reversíveis em vez das residuais padrão, o que permite armazenar as ativações apenas uma vez no processo de treinamento, em vez de N vezes, onde N é o número de camadas. O modelo resultante, o Reformer, apresenta desempenho equivalente ao dos modelos Transformer, sendo muito mais eficiente em memória e muito mais rápido em sequências longas.*

Este modelo foi contribuído por [patrickvonplaten](https://huggingface.co/patrickvonplaten). O código dos autores pode ser encontrado [aqui](https://github.com/google/trax/tree/master/trax/models/reformer).

## Dicas de uso

- O Reformer **não** funciona com *torch.nn.DataParallel* devido a um bug no PyTorch, veja [issue #36035](https://github.com/pytorch/pytorch/issues/36035).
- Use a codificação de posição axial (veja abaixo para mais detalhes). Trata-se de um mecanismo para evitar a necessidade de uma enorme matriz de codificação de posição (quando o comprimento da sequência é muito grande) ao fatorá-la em matrizes menores.
- Substitua a atenção tradicional pela atenção LSH (local-sensitive hashing) (veja abaixo para mais detalhes). Trata-se de uma técnica para evitar o cálculo do produto completo query-key nas camadas de atenção.
- Evite armazenar os resultados intermediários de cada camada usando camadas de transformador reversíveis para obtê-los durante a passagem reversa (subtrair os resíduos da entrada da camada seguinte os recupera) ou recalculando-os para os resultados dentro de uma camada específica (menos eficiente do que armazená-los, mas economiza memória).
- Calcule as operações de feedforward em blocos e não em todo o lote.

### Codificações Posicionais Axiais

Os Encodings Posicionais Axiais foram implementados pela primeira vez na [trax library](https://github.com/google/trax/blob/4d99ad4965bab1deba227539758d59f0df0fef48/trax/layers/research/position_encodings.py#L29) do Google e desenvolvidos pelos autores do paper deste modelo. Em modelos que tratam sequências de entrada muito longas, os encodings de id de posição convencionais armazenam um vetor de embeddings de tamanho $d$, sendo o `config.hidden_size` para cada posição $i, \ldots, n_s$, com $n_s$ sendo o `config.max_embedding_size`. Isso significa que ter um comprimento de sequência de $n_s = 2^{19} \approx 0.5M$ e um `config.hidden_size` de $d = 2^{10} \approx 1000$ resultaria em uma matriz de encoding de posição:

$$X_{i,j}, \text{ com } i \in \left[1,\ldots, d\right] \text{ e } j \in \left[1,\ldots, n_s\right]$$

que sozinho possui mais de 500M de parâmetros para armazenar. As codificações posicionais axiais fatorizam $X_{i,j}$ em duas matrizes:

$$X^{1}_{i,j}, \text{ com } i \in \left[1,\ldots, d^1\right] \text{ e } j \in \left[1,\ldots, n_s^1\right]$$

e

$$X^{2}_{i,j}, \text{ com } i \in \left[1,\ldots, d^2\right] \text{ e } j \in \left[1,\ldots, n_s^2\right]$$

com:

$$d = d^1 + d^2 \text{ e } n_s = n_s^1 \times n_s^2 .$$

Portanto, o seguinte é válido:

$$X_{i,j} = \begin{cases} X^{1}_{i, k}, & \text{se }\ i < d^1 \text{ com } k = j \mod n_s^1 \\ X^{2}_{i - d^1, l}, & \text{se } i \ge d^1 \text{ com } l = \lfloor\frac{j}{n_s^1}\rfloor \end{cases}$$

Intuitivamente, isso significa que um vetor de incorporação de posição $x_j \in \mathbb{R}^{d}$ agora é a composição de dois vetores de incorporação fatorados: $x^1_{k, l} + x^2_{l, k}$, onde a dimensão $j$ do `config.max_embedding_size` é fatorada em $k \text{ e } l$. Esse design garante que cada vetor de incorporação de posição $x_j$ seja único.

Usando novamente o exemplo acima, a codificação de posição axial com $d^1 = 2^9, d^2 = 2^9, n_s^1 = 2^9, n_s^2 = 2^{10}$ pode reduzir drasticamente o número de parâmetros de 500 000 000 para $2^{18} + 2^{19} \approx 780 000$ parâmetros, o que significa 85% menos uso de memória.

Na prática, o parâmetro `config.axial_pos_embds_dim` é definido como uma tupla $(d^1, d^2)$ cuja soma deve ser igual a `config.hidden_size` e `config.axial_pos_shape` é definido como uma tupla $(n_s^1, n_s^2)$ cujo produto deve ser igual a `config.max_embedding_size`, que durante o treinamento deve ser igual ao *comprimento da sequência* dos `input_ids`.

### LSH Self Attention

Na autoatenção com hashing sensível à localidade (LSH), os pesos de projeção das chaves e das consultas são compartilhados. Portanto, os vetores de incorporação das chaves e consultas também são compartilhados. A autoatenção LSH utiliza o mecanismo de hashing sensível à localidade proposto em [Practical and Optimal LSH for Angular Distance](https://huggingface.co/papers/1509.02897) para atribuir cada um dos vetores de incorporação compartilhados de chave e consulta a um dos `config.num_buckets` buckets possíveis. A premissa é que quanto mais "similares" forem os vetores de incorporação de chave e consulta entre si (em termos de *similaridade de cosseno*), maior a probabilidade de serem atribuídos ao mesmo bucket.

A precisão do mecanismo de LSH pode ser melhorada aumentando `config.num_hashes` ou diretamente o argumento `num_hashes` da função forward, de modo que a saída da autoatenção LSH aproxime melhor a saída da autoatenção total "normal". Os buckets são então ordenados e divididos em blocos de vetores de incorporação de consulta-chave, cada um com comprimento `config.lsh_chunk_length`. Para cada bloco, os vetores de incorporação de consulta prestam atenção aos seus vetores de chave (que estão vinculados a si mesmos) e aos vetores de incorporação de chave de `config.lsh_num_chunks_before` blocos vizinhos anteriores e `config.lsh_num_chunks_after` blocos vizinhos subsequentes.

Para mais informações, consulte o [artigo original](https://huggingface.co/papers/2001.04451) ou este ótimo [post de blog](https://www.pragmatic.ml/reformer-deep-dive/).

Observe que `config.num_buckets` também pode ser fatorado em uma lista $(n_{\text{buckets}}^1, n_{\text{buckets}}^2)). Dessa forma, em vez de atribuir os vetores de incorporação de chave de consulta a um de $(1,\ldots, n_{\text{buckets}})$, eles são atribuídos a um de $(1-1,\ldots, n_{\text{buckets}}^1-1, \ldots, 1-n_{\text{buckets}}^2, \ldots, n_{\text{buckets}}^1-n_{\text{buckets}}^2)$. Isso é crucial para sequências muito longas para economizar memória.

Ao treinar um modelo do zero, é recomendado deixar `config.num_buckets=None`, para que, dependendo do comprimento da sequência, um bom valor para `num_buckets` seja calculado em tempo de execução. Esse valor será então salvo automaticamente na configuração e deve ser reutilizado para inferência.

Ao usar a autoatenção LSH, a complexidade de memória e tempo da operação de multiplicação de matrizes query-key pode ser reduzida de $\mathcal{O}(n_s \times n_s)$ para $\mathcal{O}(n_s \times \log(n_s))$, o que geralmente representa o gargalo de memória e tempo em um modelo transformer, sendo $n_s$ o comprimento da sequência.

### Autoatendimento local

A autoatenção local é essencialmente uma camada de autoatenção “normal” com projeções de chave, consulta e valor, mas é dividida em blocos, de modo que, em cada bloco de comprimento `config.local_chunk_length`, os vetores de incorporação de consulta atendem apenas aos vetores de incorporação de chave em seu bloco e aos vetores de incorporação de chave dos `config.local_num_chunks_before` blocos vizinhos anteriores e dos `config.local_num_chunks_after` blocos vizinhos seguintes.

Ao usar Local self attention, a complexidade de memória e tempo da operação de multiplicação de matrizes query-key pode ser reduzida de $\mathcal{O}(n_s \times n_s)$ para $\mathcal{O}(n_s \times \log(n_s))$, o que geralmente representa o gargalo de memória e tempo em um modelo transformer, sendo $n_s$ o comprimento da sequência.

### Treinamento

Durante o treinamento, devemos garantir que o comprimento da sequência seja definido para um valor que possa ser dividido pelo mínimo múltiplo comum de `config.lsh_chunk_length` e `config.local_chunk_length` e que os parâmetros dos Axial Positional Encodings sejam corretamente definidos, conforme descrito acima. O Reformer é muito eficiente em termos de memória, de modo que o modelo pode ser facilmente treinado em sequências com até 64000 tokens.

Para o treinamento, o [ReformerModelWithLMHead](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerModelWithLMHead) deve ser usado da seguinte forma:

```python
input_ids = tokenizer.encode("This is a sentence from the training data", return_tensors="pt").to(model.device)
loss = model(input_ids, labels=input_ids)[0]
```

## Recursos

- [Guia da tarefa de classificação de texto](../tasks/sequence_classification)
- [Guia da tarefa de resposta a perguntas](../tasks/question_answering)
- [Guia da tarefa de modelagem de linguagem causal](../tasks/language_modeling)
- [Guia da tarefa de modelagem de linguagem mascarada](../tasks/masked_language_modeling)

## ReformerConfig[[transformers.ReformerConfig]]

#### transformers.ReformerConfig[[transformers.ReformerConfig]]

```python
transformers.ReformerConfig(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, attention_head_size: int = 64, attn_layers: list[str] | tuple[str, ...] = ('local', 'lsh', 'local', 'lsh', 'local', 'lsh'), axial_norm_std: float = 1.0, axial_pos_embds: bool = True, axial_pos_shape: list[int] | tuple[int, ...] = (64, 64), axial_pos_embds_dim: list[int] | tuple[int, ...] = (64, 192), chunk_size_lm_head: int = 0, eos_token_id: int | list[int] | None = 2, feed_forward_size: int = 512, hash_seed: int | None = None, hidden_act: str = 'relu', hidden_dropout_prob: float | int = 0.05, hidden_size: int = 256, initializer_range: float = 0.02, is_decoder: bool = False, layer_norm_eps: float = 1e-12, local_num_chunks_before: int = 1, local_num_chunks_after: int = 0, local_attention_probs_dropout_prob: float | int = 0.05, local_attn_chunk_length: int = 64, lsh_attn_chunk_length: int | None = 64, lsh_attention_probs_dropout_prob: float | None = 0.0, lsh_num_chunks_before: int | None = 1, lsh_num_chunks_after: int | None = 0, max_position_embeddings: int = 4096, num_attention_heads: int = 12, num_buckets: int | list[int] | None = None, num_hashes: int = 1, vocab_size: int = 320, tie_word_embeddings: bool = False, use_cache: bool = True, classifier_dropout: float | int | None = None, bos_token_id: int | None = None, pad_token_id: int | None = 0)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/configuration_reformer.py#L25)

**Parâmetros:**

attention_head_size (`int`, *opcional*, padrão 64) : Dimensionalidade dos vetores de chave, consulta e valor projetados

attn_layers (`list[str]`, *opcional*, padrão `["local", "lsh", "local", "lsh", "local", "lsh"]`) : Lista dos tipos de camadas de atenção em ordem ascendente. Pode ser escolhido entre uma camada LSHSelfAttention (`"lsh"`) e uma camada LocalSelfAttention (`"local"`). Para mais informações sobre a camada LSHSelfAttention, veja [LSH Self Attention](reformer#lsh-self-attention). Para mais informações sobre a camada LocalSelfAttention, veja [Local Self Attention](reformer#local-self-attention).

axial_norm_std (`float`, *opcional*, padrão 1.0) : O desvio padrão do normal_initializer para inicializar as matrizes de pesos das codificações posicionais axiais.

axial_pos_embds (`bool`, *opcional*, padrão `True`) : Se deve ou não usar embeddings de posição axial. Para mais informações sobre como os embeddings de posição axial funcionam, veja [Axial Position Encodings](reformer#axial-positional-encodings).

axial_pos_shape (`list[int]`, *opcional*, padrão `[64, 64]`) : As dimensões de posição das codificações de posição axiais. Durante o treinamento, o produto das dimensões de posição deve ser igual ao comprimento da sequência. Para mais informações sobre como as incorporações de posição axial funcionam, veja [Axial Position Encodings](reformer#axial-positional-encodings).

axial_pos_embds_dim (`list[int]`, *opcional*, padrão `[64, 192]`) : As dimensões de incorporação das codificações de posição axial. A soma das dimensões de incorporação deve ser igual ao tamanho oculto. Para mais informações sobre como funcionam as incorporações de posição axial, consulte [Codificações de Posição Axial](reformer#axial-positional-encodings).

chunk_size_lm_head (`int`, *opcional*, padrão 0) : O tamanho do bloco da camada final de feed forward do modelo de linguagem. Um tamanho de bloco de 0 significa que a camada de feed forward não é dividida em blocos. Um tamanho de bloco de n significa que a camada de feed forward processa n < sequence_length embeddings de cada vez. Para mais informações sobre a divisão em blocos de feed forward, veja [Como funciona a divisão em blocos de Feed Forward?](../glossary#feed-forward-chunking).

eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `2`) : ID do token usado para o fim do fluxo no vocabulário.

feed_forward_size (`int`, *opcional*, padrão 512) : Dimensionalidade da camada feed_forward no bloco de atenção residual.

hash_seed (`int`, *opcional*) : Semente que pode ser usada para tornar o hashing sensível local em `LSHSelfAttention` determinístico. Isso deve ser definido apenas para fins de teste. Para fins de avaliação e treinamento, `hash_seed` deve ser mantido como `None` para garantir rotações totalmente aleatórias no esquema de hashing sensível local.

hidden_act (`str`, *opcional*, padrão `relu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.05`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no codificador e no pooler.

hidden_size (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

is_decoder (`bool`, *opcional*, padrão `False`) : Indica se o modelo é usado como decodificador ou não. Se `False`, o modelo é usado como codificador.

layer_norm_eps (`float`, *opcional*, padrão `1e-12`) : O epsilon usado pelas camadas de normalização de camada.

local_num_chunks_before (`int`, *opcional*, padrão 1) : Número de blocos vizinhos anteriores para os quais a camada `LocalSelfAttention` deve prestar atenção a si mesma.

local_num_chunks_after (`int`, *opcional*, padrão 0) : Número de blocos vizinhos subsequentes a serem considerados pela camada `LocalSelfAttention`, além do próprio bloco.

local_attention_probs_dropout_prob (`float`, *opcional*, padrão 0.1) : A taxa de dropout para as probabilidades de atenção em `LocalSelfAttention`.

local_attn_chunk_length (`int`, *opcional*, padrão 64) : Comprimento de cada bloco nas camadas de atenção local.

lsh_attn_chunk_length (`int`, *opcional*, padrão 64) : Comprimento do bloco que atende a si mesmo em `LSHSelfAttention`. A divisão em blocos reduz a complexidade de memória de comprimento da sequência x comprimento da sequência (autoatenção) para comprimento do bloco x comprimento do bloco x comprimento da sequência / comprimento do bloco (autoatenção em blocos).

lsh_attention_probs_dropout_prob (`float`, *opcional*, padrão 0.1) : A taxa de dropout para as probabilidades de atenção em `LSHSelfAttention`.

lsh_num_chunks_before (`int`, *opcional*, padrão 1) : Número de blocos vizinhos anteriores para os quais a camada `LSHSelfAttention` deve prestar atenção a si mesma.

lsh_num_chunks_after (`int`, *opcional*, padrão 0) : Número de blocos vizinhos subsequentes para os quais a camada `LSHSelfAttention` deve prestar atenção a si mesma.

max_position_embeddings (`int`, *opcional*, padrão `4096`) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado.

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

num_buckets (`int` ou `list[int]`, *opcional*) : Número de buckets, nos quais os vetores de consulta de chave podem ser "hacheados" usando o esquema de hashing sensível à localidade. Cada vetor de chave de consulta é hacheadado em um hash em `1, ..., num_buckets`. O número de buckets também pode ser fatorado em uma lista para melhorar a complexidade de memória. Nesse caso, cada vetor de chave de consulta é hacheadado em um hash em `1-1, 1-2, ..., num_buckets[0]-1, ..., num_buckets[0]-num_buckets[1]` se `num_buckets` for fatorado em dois fatores. O número de buckets (ou o produto dos fatores) deve ser aproximadamente igual ao comprimento da sequência / lsh_chunk_length. Se `num_buckets` não for definido, um bom valor é calculado em tempo de execução.

num_hashes (`int`, *opcional*, padrão 1) : Número de rodadas de hash (por exemplo, número de rotações aleatórias) no esquema de Local Sensitive Hashing. Quanto maior o `num_hashes`, mais preciso o `LSHSelfAttention` se torna, mas também mais intensivo em memória e tempo o processo de hash se torna.

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

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

use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador.

classifier_dropout (`Union[float, int]`, *opcional*) : A taxa de dropout para o classificador.

bos_token_id (`int`, *opcional*) : ID do token usado para o início do fluxo no vocabulário.

pad_token_id (`int`, *opcional*, padrão `0`) : ID do token usado para preenchimento no vocabulário.

Esta é a classe de configuração para armazenar a configuração de um ReformerModel. Ela é usada para instanciar um modelo Reformer 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 [google/reformer-crime-and-punishment](https://huggingface.co/google/reformer-crime-and-punishment)

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 ReformerConfig, ReformerModel

>>> # Initializing a Reformer configuration
>>> configuration = ReformerConfig()

>>> # Initializing a Reformer model (with random weights)
>>> model = ReformerModel(configuration)

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

## ReformerTokenizer[[transformers.ReformerTokenizer]]

#### transformers.ReformerTokenizer[[transformers.ReformerTokenizer]]

```python
transformers.ReformerTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, eos_token: str = '</s>', unk_token: str = '<unk>', _spm_precompiled_charsmap: str | None = None, additional_special_tokens: list | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/tokenization_reformer.py#L31)

**Parâmetros:**

vocab_file (`str`) : arquivo [SentencePiece](https://github.com/google/sentencepiece) (geralmente com a extensão *.spm*) que contém o vocabulário necessário para instanciar um tokenizador.

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.

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

additional_special_tokens (`list[str]`, *opcional*) : Tokens especiais adicionais usados pelo tokenizer.

vocab (`str` ou `dict[str, int]`, *opcional*) : Dicionário de vocabulário personalizado. Se não for fornecido, o vocabulário é carregado a partir de `vocab_file`.

merges (`str` ou `list[str]`, *opcional*) : Lista de mesclagens personalizada. Se não for fornecida, as mesclagens são carregadas de `vocab_file`.

Construa um tokenizador Reformer (baseado na biblioteca tokenizers da HuggingFace). Baseado em [BPE](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=bpe#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.

#### save_vocabulary[[transformers.ReformerTokenizer.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)

## ReformerModel[[transformers.ReformerModel]]

#### transformers.ReformerModel[[transformers.ReformerModel]]

```python
transformers.ReformerModel(config: ReformerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L1931)

**Parâmetros:**

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

O modelo Reformer puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.ReformerModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, past_buckets_states: transformers.models.reformer.modeling_reformer.ReformerDynamicCache | None = None, use_cache: bool | None = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L1951)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Durante o treinamento, a sequence_length de input_ids deve ser um múltiplo dos comprimentos de chunk relevantes do modelo (lsh's, local's ou ambos). Durante a avaliação, os índices são automaticamente preenchidos (padded) para serem um múltiplo do comprimento do chunk. 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)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

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.

num_hashes (`int`, *opcional*) : O número de rodadas de hash que devem ser executadas durante o bucketing. Definir este argumento sobrescreve o padrão definido em `config.num_hashes`. Para mais informações, veja `num_hashes` em [ReformerConfig](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerConfig).

past_buckets_states (`ReformerDynamicCache`, *opcional*) : Lista de `tuple(torch.LongTensor, torch.Tensor` de comprimento `config.n_layers`, em que o primeiro elemento são os *buckets* anteriores de forma `(batch_size, num_heads, num_hashes, sequence_length)`) e o segundo são os *hidden_states* anteriores de forma `(batch_size, sequence_length, hidden_size)`). Contém hidden-states e buckets pré-computados (relevante apenas para LSH Self-Attention). Pode ser usado para acelerar a decodificação sequencial.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

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.

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.

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:** `ReformerModelOutput` ou `tuple(torch.Tensor)`

Um `ReformerModelOutput` 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 ([ReformerConfig](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerConfig)) e das entradas.

O método forward do [ReformerModel](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerModel) 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`.
- **past_buckets_states** (`list[tuple(torch.LongTensor, torch.Tensor)]`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Lista de `tuple(torch.LongTensor, torch.Tensor` de comprimento `config.n_layers`, com o primeiro elemento sendo os *buckets* anteriores de forma `(batch_size, num_heads, num_hashes, sequence_length)`) e o segundo sendo os *hidden_states* anteriores de forma `(batch_size, sequence_length, hidden_size)`).

  Contém buckets pré-computados e hidden-states que podem ser usados (veja a entrada `past_buckets_states`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

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

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

## ReformerModelWithLMHead[[transformers.ReformerModelWithLMHead]]

#### transformers.ReformerModelWithLMHead[[transformers.ReformerModelWithLMHead]]

```python
transformers.ReformerModelWithLMHead(config: ReformerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2150)

**Parâmetros:**

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

Modelo Reformer com uma cabeça de `language modeling` 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.ReformerModelWithLMHead.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, past_buckets_states: list[tuple[torch.Tensor]] | None = None, use_cache: bool | None = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, labels: typing.Optional[torch.Tensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2176)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Durante o treinamento, a sequence_length de input_ids deve ser um múltiplo dos comprimentos de chunk relevantes do modelo (lsh's, local's ou ambos). Durante a avaliação, os índices são automaticamente preenchidos (padded) para serem um múltiplo do comprimento do chunk. 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)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-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)

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.

num_hashes (`int`, *opcional*) : O número de rodadas de hash que devem ser executadas durante o bucketing. Definir este argumento sobrescreve o padrão definido em `config.num_hashes`. Para mais informações, veja `num_hashes` em [ReformerConfig](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerConfig).

past_buckets_states (`list[tuple(torch.LongTensor, torch.Tensor)]`, *opcional*) : Lista de `tuple(torch.LongTensor, torch.Tensor` de comprimento `config.n_layers`, em que o primeiro elemento são os *buckets* anteriores de forma `(batch_size, num_heads, num_hashes, sequence_length)`) e o segundo são os *hidden_states* anteriores de forma `(batch_size, sequence_length, hidden_size)`). Contém hidden-states e buckets pré-computados (relevante apenas para LSH Self-Attention). Pode ser usado para acelerar a decodificação sequencial.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

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.

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.

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.

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 `[-100, 0, ..., config.vocab_size - 1]`. Todos os rótulos definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os rótulos em `[0, ..., config.vocab_size]`

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

Um [CausalLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([ReformerConfig](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerConfig)) e das entradas.

O método forward do [ReformerModelWithLMHead](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerModelWithLMHead) 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, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

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

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

Exemplo:

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

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerModelWithLMHead.from_pretrained("google/reformer-crime-and-punishment")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## ReformerForMaskedLM[[transformers.ReformerForMaskedLM]]

#### transformers.ReformerForMaskedLM[[transformers.ReformerForMaskedLM]]

```python
transformers.ReformerForMaskedLM(config: ReformerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2287)

**Parâmetros:**

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

O Modelo Reformer com uma cabeça de `language modeling` 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.ReformerForMaskedLM.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2307)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Durante o treinamento, a sequence_length de input_ids deve ser um múltiplo dos comprimentos de chunk relevantes do modelo (lsh's, local's ou ambos). Durante a avaliação, os índices são automaticamente preenchidos (padded) para serem um múltiplo do comprimento do chunk. 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)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-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)

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.

num_hashes (`int`, *opcional*) : O número de rodadas de hash que devem ser executadas durante o bucketing. Definir este argumento sobrescreve o padrão definido em `config.num_hashes`. Para mais informações, veja `num_hashes` em [ReformerConfig](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerConfig).

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[-100, 0, ..., config.vocab_size]` (veja a docstring de `input_ids`) Tokens com índices definidos como `-100` são ignorados (mascarados), a perda é calculada apenas para os tokens com rótulos    Este exemplo usa um checkpoint falso, pois não temos nenhum modelo pré-treinado disponível para a tarefa de modelagem de linguagem mascarada com a arquitetura Reformer.

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.

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.

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

Um [MaskedLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 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 ([ReformerConfig](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerConfig)) e das entradas.

O método forward de [ReformerForMaskedLM](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerForMaskedLM) substitui o método especial `__call__`.

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem mascarada (MLM).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

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

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

Exemplo:

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

>>> tokenizer = AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-reformer")
>>> model = ReformerForMaskedLM.from_pretrained("hf-internal-testing/tiny-random-reformer")

>>> # add mask_token
>>> tokenizer.add_special_tokens({"mask_token": "[MASK]"})
>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

>>> # resize model's embedding matrix
>>> model.resize_token_embeddings(new_num_tokens=model.config.vocab_size + 1)
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> predicted_token = tokenizer.decode(predicted_token_id)
```

```python
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(
...     inputs.input_ids == tokenizer.mask_token_id, labels[:, : inputs["input_ids"].shape[-1]], -100
... )

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

## ReformerForSequenceClassification[[transformers.ReformerForSequenceClassification]]

#### transformers.ReformerForSequenceClassification[[transformers.ReformerForSequenceClassification]]

```python
transformers.ReformerForSequenceClassification(config: ReformerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2425)

**Parâmetros:**

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

Modelo Reformer transformer com uma cabeça de classificação/regressão de sequência no topo (uma camada linear no topo da saída agrupada), 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.ReformerForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2439)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Durante o treinamento, a sequence_length de input_ids deve ser um múltiplo dos comprimentos de chunk relevantes do modelo (lsh's, local's ou ambos). Durante a avaliação, os índices são automaticamente preenchidos (padded) para serem um múltiplo do comprimento do chunk. 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)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-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)

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.

num_hashes (`int`, *opcional*) : O número de rodadas de hash que devem ser executadas durante o bucketing. Definir este argumento sobrescreve o padrão definido em `config.num_hashes`. Para mais informações, veja `num_hashes` em [ReformerConfig](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerConfig).

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

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.

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.

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

Um [SequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([ReformerConfig](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerConfig)) e das entradas.

O método forward de [ReformerForSequenceClassification](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerForSequenceClassification) sobrescreve o método especial `__call__`.

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1).
- **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

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

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

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

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

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForSequenceClassification.from_pretrained("google/reformer-crime-and-punishment")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

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

>>> predicted_class_id = logits.argmax().item()
>>> label = model.config.id2label[predicted_class_id]
```

```python
>>> # 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 = ReformerForSequenceClassification.from_pretrained(
...     "google/reformer-crime-and-punishment", num_labels=num_labels
... )

>>> labels = torch.tensor(1)
>>> loss = model(**inputs, labels=labels).loss
```

## ReformerForQuestionAnswering[[transformers.ReformerForQuestionAnswering]]

#### transformers.ReformerForQuestionAnswering[[transformers.ReformerForQuestionAnswering]]

```python
transformers.ReformerForQuestionAnswering(config: ReformerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2572)

**Parâmetros:**

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

O Reformer transformer 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.ReformerForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2584)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Durante o treinamento, a sequence_length de input_ids deve ser um múltiplo dos comprimentos de chunk relevantes do modelo (lsh's, local's ou ambos). Durante a avaliação, os índices são automaticamente preenchidos (padded) para serem um múltiplo do comprimento do chunk. 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)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-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)

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.

num_hashes (`int`, *opcional*) : O número de rodadas de hash que devem ser executadas durante o bucketing. Definir este argumento sobrescreve o padrão definido em `config.num_hashes`. Para mais informações, veja `num_hashes` em [ReformerConfig](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerConfig).

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.

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.

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.

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

Um [QuestionAnsweringModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) 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 ([ReformerConfig](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerConfig)) e das entradas.

O método forward de [ReformerForQuestionAnswering](/docs/transformers/main/pt/model_doc/reformer#transformers.ReformerForQuestionAnswering) 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 span (antes do SoftMax).
- **end_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Pontuações de fim de span (antes do SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

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

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

Exemplo:

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

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForQuestionAnswering.from_pretrained("google/reformer-crime-and-punishment")

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