Hugging Face's logo

Transformers documentation

Reformer

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi publicado no HF papers em 2020-01-13 e contribuído para o Hugging Face Transformers em 2020-11-16.

Reformer

Visão geral

O modelo Reformer foi proposto no artigo Reformer: The Efficient Transformer, de Nikita Kitaev, Łukasz Kaiser e Anselm Levskaya.

O resumo do artigo é o seguinte:

Modelos 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. O código dos autores pode ser encontrado aqui.

Dicas de uso

  • O Reformer não funciona com torch.nn.DataParallel devido a um bug no PyTorch, veja issue #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 matriz de codificação de posição enorme (quando o comprimento da sequência é muito grande), fatorando-a 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 biblioteca trax 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 dd sendo config.hidden_size para cada posição $i, \ldots, n_s$, com nsn_s sendo config.max_embedding_size. Isso significa que ter um comprimento de sequência de ns=219≈0.5Mn_s = 2^{19} \approx 0.5M e um config.hidden_size de d=210≈1000d = 2^{10} \approx 1000 resultaria em uma matriz de encoding de posição: Xi,j, with i∈[1,…,d] and j∈[1,…,ns]X_{i,j}, \text{ with } i \in \left[1,\ldots, d\right] \text{ and } 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 Xi,jX_{i,j} em duas matrizes: Xi,j1, with i∈[1,…,d1] and j∈[1,…,ns1]X^{1}_{i,j}, \text{ with } i \in \left[1,\ldots, d^1\right] \text{ and } j \in \left[1,\ldots, n_s^1\right]

e Xi,j2, with i∈[1,…,d2] and j∈[1,…,ns2]X^{2}_{i,j}, \text{ with } i \in \left[1,\ldots, d^2\right] \text{ and } j \in \left[1,\ldots, n_s^2\right]

com: d=d1+d2 and ns=ns1×ns2.d = d^1 + d^2 \text{ and } n_s = n_s^1 \times n_s^2 .

Portanto, o seguinte vale: Xi,j={Xi,k1,if  i<d1 with k=jmod  ns1Xi−d1,l2,if i≥d1 with l=⌊jns1⌋X_{i,j} = \begin{cases} X^{1}_{i, k}, & \text{if }\ i < d^1 \text{ with } k = j \mod n_s^1 \\ X^{2}_{i - d^1, l}, & \text{if } i \ge d^1 \text{ with } l = \lfloor\frac{j}{n_s^1}\rfloor \end{cases}

Intuitivamente, isso significa que um vetor de incorporação de posição xj∈Rdx_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 config.max_embedding_size é fatorada em $k \text{ e } l$. Esse design garante que cada vetor de incorporação de posição jj seja único. xjx_j

Usando novamente o exemplo acima, a codificação de posição axial com d1=29,d2=29,ns1=29,ns2=210d^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 218+219≈7800002^{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 (d1,d2)(d^1, d^2) cuja soma deve ser igual a config.hidden_size e config.axial_pos_shape é definido como uma tupla (ns1,ns2)(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 hash 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 das consultas também são compartilhados. A autoatenção LSH utiliza o mecanismo de hash sensível à localidade proposto em Practical and Optimal LSH for Angular Distance 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 (em termos de similaridade de cosseno) entre si, 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 completa “normal”. Os buckets são então ordenados e divididos em blocos de vetores de incorporação de consulta e 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 seguintes.

Para mais informações, consulte o artigo original ou este ótimo post de blog.

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 dos $(1,\ldots, n{\text{buckets}})$, eles são atribuídos a um dos $(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 autoatenção LSH, a complexidade de memória e tempo da operação de produto matricial query-key pode ser reduzida de O(ns×ns)\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, com nsn_s sendo 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 do próprio 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 autoatenção local, a complexidade de memória e tempo da operação de produto matricial query-key pode ser reduzida de O(ns×ns)\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, com nsn_s sendo 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 estejam corretamente definidos, conforme descrito acima. O Reformer é muito eficiente em termos de memória, de modo que o modelo pode ser treinado facilmente em sequências com até 64000 tokens.

Para o treinamento, o ReformerModelWithLMHead deve ser usado da seguinte forma:

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

ReformerConfig

classe transformers.ReformerConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneattention_head_size: int = 64attn_layers: list[str] | tuple[str, ...] = ('local', 'lsh', 'local', 'lsh', 'local', 'lsh')axial_norm_std: float = 1.0axial_pos_embds: bool = Trueaxial_pos_shape: list[int] | tuple[int, ...] = (64, 64)axial_pos_embds_dim: list[int] | tuple[int, ...] = (64, 192)chunk_size_lm_head: int = 0eos_token_id: int | list[int] | None = 2feed_forward_size: int = 512hash_seed: int | None = Nonehidden_act: str = 'relu'hidden_dropout_prob: float | int = 0.05hidden_size: int = 256initializer_range: float = 0.02is_decoder: bool = Falselayer_norm_eps: float = 1e-12local_num_chunks_before: int = 1local_num_chunks_after: int = 0local_attention_probs_dropout_prob: float | int = 0.05local_attn_chunk_length: int = 64lsh_attn_chunk_length: int | None = 64lsh_attention_probs_dropout_prob: float | None = 0.0lsh_num_chunks_before: int | None = 1lsh_num_chunks_after: int | None = 0max_position_embeddings: int = 4096num_attention_heads: int = 12num_buckets: int | list[int] | None = Nonenum_hashes: int = 1vocab_size: int = 320tie_word_embeddings: bool = Falseuse_cache: bool = Trueclassifier_dropout: float | int | None = Nonebos_token_id: int | None = Nonepad_token_id: int | None = 0 )

Parâmetros

  • attention_head_size (int, opcional, padrão 64) — Dimensão 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 crescente. Pode ser escolhida entre uma camada LSHSelfAttention ("lsh") e uma camada LocalSelfAttention ("local"). Para mais informações sobre a camada LSHSelfAttention, consulte LSH Self Attention. Para mais informações sobre a camada LocalSelfAttention, consulte 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) — Indica se deve ou não usar embeddings de posição axial. Para mais informações sobre como os embeddings de posição axial funcionam, consulte Axial Position 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 funcionam os embeddings de posição axial, consulte Axial Position Encodings.
  • axial_pos_embds_dim (list[int], opcional, padrão [64, 192]) — As dimensões dos embeddings das codificações de posição axial. A soma das dimensões dos embeddings deve ser igual ao tamanho oculto (hidden size). Para mais informações sobre como funcionam os embeddings de posição axial, consulte Axial Position Encodings.
  • chunk_size_lm_head (int, opcional, padrão 0) — O tamanho do bloco da camada final de feed forward da cabeça 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 por vez. Para mais informações sobre a divisão em blocos de feed forward, consulte Como funciona a divisão em blocos de Feed Forward?.
  • 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) — Dimensão 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 encoder 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.
  • 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 em relação aos 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 chave de consulta 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 a 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 valor de num_hashes, mais precisa a 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) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas se config.is_decoder=True ou quando o modelo for um modelo generativo somente 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

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplos:

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

classe transformers.ReformerTokenizer

< >

( vocab: str | dict[str, int] | None = Nonemerges: str | list[str] | None = Noneeos_token: str = '</s>'unk_token: str = '<unk>'_spm_precompiled_charsmap: str | None = Noneadditional_special_tokens: list | None = None**kwargs )

Parâmetros

  • vocab_file (str) — arquivo 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 usado para o fim da sequência. O token utilizado é o sep_token.

    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, a vocabulário é carregada 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.

Este tokenizador herda de 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

< >

( save_directory: strfilename_prefix: str | None = None )

ReformerModel

classe transformers.ReformerModel

< >

( config: ReformerConfig )

Parâmetros

  • config (ReformerConfig) — 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() 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. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonepast_buckets_states: transformers.models.reformer.modeling_reformer.ReformerDynamicCache | None = Noneuse_cache: bool | None = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → ReformerModelOutput or tuple(torch.Tensor)

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, o sequence_length de input_ids deve ser um múltiplo dos comprimentos de chunk relevantes do modelo (lsh, local ou ambos). Durante a avaliação, os índices são automaticamente preenchidos para serem um múltiplo do comprimento do chunk.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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?

  • 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?

  • 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, consulte num_hashes em ReformerConfig.

  • past_buckets_states (ReformerDynamicCache, opcional) — Lista de tuple(torch.LongTensor, torch.Tensor com comprimento config.n_layers, em que o primeiro elemento são os buckets de forma (batch_size, num_heads, num_hashes, sequence_length)) e o segundo são os hidden_states de forma (batch_size, sequence_length, hidden_size)).

    Contém estados ocultos pré-computados e buckets (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 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 as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors 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) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

ReformerModelOutput ou tuple(torch.Tensor)

Uma 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) e das entradas.

O método forward do 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 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.

  • 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, em que o primeiro elemento é o buckets anterior de forma (batch_size, num_heads, num_hashes, sequence_length)) e o segundo é o hidden_states anterior 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 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.

ReformerModelWithLMHead

classe transformers.ReformerModelWithLMHead

< >

( config: ReformerConfig )

Parâmetros

  • config (ReformerConfig) — 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() para carregar os pesos do modelo.

Modelo Reformer com uma cabeça de language modeling no topo.

Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonepast_buckets_states: list[tuple[torch.Tensor]] | None = Noneuse_cache: bool | None = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs ) → CausalLMOutput or tuple(torch.Tensor)

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, o sequence_length de input_ids deve ser um múltiplo dos comprimentos de chunk relevantes do modelo (lsh, local ou ambos). Durante a avaliação, os índices são automaticamente preenchidos para serem um múltiplo do comprimento do chunk.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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?

  • 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?

  • 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, consulte num_hashes em ReformerConfig.

  • past_buckets_states (list[tuple(torch.LongTensor, torch.Tensor)], opcional) — Lista de tuple(torch.LongTensor, torch.Tensor com comprimento config.n_layers, em que o primeiro elemento é os buckets de forma (batch_size, num_heads, num_hashes, sequence_length)) e o segundo é os hidden_states de forma (batch_size, sequence_length, hidden_size)).

    Contém estados ocultos pré-computados e buckets (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 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 as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors 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) — Indica se deve retornar um 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 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 ou tuple(torch.Tensor)

Um 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) e das entradas.

O método forward do 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) 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 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.

Exemplo:

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

classe transformers.ReformerForMaskedLM

< >

( config: ReformerConfig )

Parâmetros

  • config (ReformerConfig) — 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() para carregar os pesos do modelo.

O Modelo Reformer com uma cabeça de language modeling no topo.”

Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → MaskedLMOutput or tuple(torch.Tensor)

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, o sequence_length de input_ids deve ser um múltiplo dos comprimentos de chunk relevantes do modelo (lsh, local ou ambos). Durante a avaliação, os índices são automaticamente preenchidos para serem um múltiplo do comprimento do chunk.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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?

  • 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?

  • 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, consulte num_hashes em 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 input_ids docstring) 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 as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors 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) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

MaskedLMOutput ou tuple(torch.Tensor)

Um 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) e das entradas.

O método forward de 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) 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 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.

Exemplo:

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

classe transformers.ReformerForSequenceClassification

< >

( config: ReformerConfig )

Parâmetros

  • config (ReformerConfig) — 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() 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 agregada), por exemplo, para tarefas GLUE.

Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → SequenceClassifierOutput or tuple(torch.Tensor)

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, o sequence_length de input_ids deve ser um múltiplo dos comprimentos de chunk relevantes do modelo (lsh, local ou ambos). Durante a avaliação, os índices são automaticamente preenchidos para serem um múltiplo do comprimento do chunk.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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?

  • 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?

  • 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, consulte num_hashes em 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 as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors 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) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

SequenceClassifierOutput ou tuple(torch.Tensor)

Um 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) e das entradas.

O método forward de 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 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) 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 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.

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

>>> 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]
>>> # 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

classe transformers.ReformerForQuestionAnswering

< >

( config: ReformerConfig )

Parâmetros

  • config (ReformerConfig) — 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() para carregar os pesos do modelo.

O Reformer transformer com uma cabeça de classificação de span no topo para tarefas de resposta a perguntas extrativas, 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. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → QuestionAnsweringModelOutput or tuple(torch.Tensor)

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, o sequence_length de input_ids deve ser um múltiplo dos comprimentos de chunk relevantes do modelo (lsh, local ou ambos). Durante a avaliação, os índices são automaticamente preenchidos para serem um múltiplo do comprimento do chunk.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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?

  • 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?

  • 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, consulte num_hashes em 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 fim 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 as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors 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) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

QuestionAnsweringModelOutput ou tuple(torch.Tensor)

Um 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) e das entradas.

O método forward de 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 é fornecido) — A perda total de extração de span é 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).

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

Exemplo:

>>> 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)
...
Update on GitHub

←RecurrentGemma RemBERT→