Transformers documentation

RAG

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

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

RAG

Retrieval-Augmented Generation (RAG) combina um modelo de linguagem pré-treinado (memória paramétrica) com acesso a uma fonte de dados externa (memória não paramétrica) por meio de um recuperador neural pré-treinado. O RAG busca trechos relevantes e condiciona sua geração a eles durante a inferência. Isso frequentemente torna as respostas mais factuais e permite atualizar o conhecimento alterando o índice, em vez de retreinar o modelo inteiro.

Você pode encontrar todos os checkpoints originais de RAG na organização AI at Meta.

Este modelo foi contribuído por ola13.

Clique nos modelos de RAG na barra lateral à direita para ver mais exemplos de como aplicar RAG a diferentes tarefas de linguagem.

Os exemplos abaixo demonstram como gerar texto com AutoModel.

AutoModel

A quantização reduz o uso de memória armazenando os pesos em menor precisão. Consulte a visão geral de Quantização para ver os backends suportados. O exemplo abaixo usa bitsandbytes para quantizar os pesos para 4 bits.

import torch

from transformers import BitsAndBytesConfig, RagRetriever, RagSequenceForGeneration, RagTokenizer


bnb = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16)

tokenizer = RagTokenizer.from_pretrained("facebook/rag-sequence-nq")
retriever = RagRetriever.from_pretrained(
    "facebook/rag-sequence-nq", dataset="wiki_dpr", index_name="compressed"
)

model = RagSequenceForGeneration.from_pretrained(
    "facebook/rag-sequence-nq",
    retriever=retriever,
    quantization_config=bnb,
    device_map="auto",
)
inputs = tokenizer("How many people live in Paris?", return_tensors="pt").to(model.device)
generated = model.generate(input_ids=inputs["input_ids"])
print(tokenizer.batch_decode(generated, skip_special_tokens=True)[0])

RagConfig

classe transformers.RagConfig

< source >

( 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 = 0id2label: 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 = Noneis_encoder_decoder: bool = Truequestion_encoder: transformers.configuration_utils.PreTrainedConfig | dict | None = Nonegenerator: transformers.configuration_utils.PreTrainedConfig | dict | None = Nonevocab_size: int | None = Noneprefix: str | None = Nonebos_token_id: int | None = Nonepad_token_id: int | None = Noneeos_token_id: int | list[int] | None = Nonedecoder_start_token_id: int | None = Nonetitle_sep: str = ' / 'doc_sep: str = ' // 'n_docs: int = 5max_combined_length: int = 300retrieval_vector_size: int = 768retrieval_batch_size: int = 8dataset: str = 'wiki_dpr'dataset_split: str = 'train'index_name: str = 'compressed'index_path: str | None = Nonepassages_path: str | None = Noneuse_dummy_dataset: bool = Falsereduce_loss: bool = Falselabel_smoothing: float = 0.0do_deduplication: bool = Trueexclude_bos_score: bool = Falsedo_marginalize: bool = Falseoutput_retrieved: bool = Falseuse_cache: bool = Truedataset_revision: str | None = None )

Parâmetros

is_encoder_decoder (bool, opcional, padrão True) — Indica se o modelo é usado como encoder/decoder ou não.
question_encoder (PreTrainedConfig | dict, opcional) — O objeto de configuração ou dicionário do backbone do codificador de perguntas
generator (PreTrainedConfig | dict, opcional) — O objeto de configuração ou dicionário do backbone do gerador de respostas
vocab_size (int, opcional) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
prefix (str, opcional) — Um prefixo de string adicionado ao início de cada entrada antes de ser passada ao modelo gerador.
bos_token_id (int, opcional) — ID do token usado para o início do fluxo no vocabulário.
pad_token_id (int, opcional) — ID do token usado para preenchimento no vocabulário.
eos_token_id (Union[int, list[int]], opcional) — ID do token usado para o fim do fluxo no vocabulário.
decoder_start_token_id (int, opcional) — Se um modelo encoder-decoder inicia a decodificação com um token diferente de bos, o id desse token.
title_sep (str, opcional, padrão " / ") — Separador inserido entre o título e o texto do documento recuperado ao chamar RagRetriever.
doc_sep (str, opcional, padrão " // ") — Separador inserido entre o texto do documento recuperado e a entrada original ao chamar RagRetriever.
n_docs (int, opcional, padrão 5) — Número de documentos a serem recuperados.
max_combined_length (int, opcional, padrão 300) — Comprimento máximo da entrada contextualizada retornada por __call__().
retrieval_vector_size (int, opcional, padrão 768) — Dimensão dos embeddings de documentos indexados pelo RagRetriever.
retrieval_batch_size (int, opcional, padrão 8) — Tamanho do lote de recuperação, definido como o número de consultas emitidas simultaneamente ao índice faiss encapsulado em RagRetriever.
dataset (str, opcional, padrão "wiki_dpr") — Um identificador de dataset do dataset indexado em HuggingFace Datasets (liste todos os datasets e ids disponíveis usando datasets.list_datasets()).
dataset_split (str, opcional, padrão "train") — Qual split do dataset carregar.
index_name (str, opcional, padrão "compressed") — O nome do índice do índice associado ao dataset. É possível escolher entre "legacy", "exact" e "compressed".
index_path (str, opcional) — O caminho para o índice faiss serializado no disco.
passages_path (str, opcional) — Um caminho para passagens de texto compatíveis com o índice faiss. Obrigatório ao usar LegacyIndex
use_dummy_dataset (bool, opcional, padrão False) — Se deve carregar uma variante “dummy” do dataset especificado por dataset.
reduce_loss (bool, opcional, padrão False) — Indica se a perda NLL deve ser reduzida usando a operação torch.Tensor.sum.
label_smoothing (float, opcional, padrão 0.0) — Relevante apenas se return_loss estiver definido como True. Controla o valor do parâmetro epsilon para o label smoothing no cálculo da perda. Se definido como 0, nenhum label smoothing é realizado.
do_deduplication (bool, opcional, padrão True) — Indica se as gerações de diferentes documentos de contexto devem ser deduplicadas para uma determinada entrada. Deve ser definido como False se for usado durante o treinamento com um backend distribuído.
exclude_bos_score (bool, opcional, padrão False) — Se deve ou não ignorar o token BOS ao calcular a perda.
do_marginalize (bool, opcional, padrão False) — Se True, os logits são marginalizados sobre todos os documentos, utilizando torch.nn.functional.log_softmax.
output_retrieved (bool, opcional, padrão False) — Se definido como True, retrieved_doc_embeds, retrieved_doc_ids, context_input_ids e context_attention_mask são retornados. Consulte os tensores retornados para mais detalhes.
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.
dataset_revision (str, opcional,) — A revisão (hash de commit, tag ou branch) do dataset do Hugging Face usado para recuperação.

Esta é a classe de configuração para armazenar a configuração de um RagModel. Ela é usada para instanciar um modelo Rag 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

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.

from_question_encoder_generator_configs

< source >

( question_encoder_config: PreTrainedConfiggenerator_config: PreTrainedConfig**kwargs ) → EncoderDecoderConfig

Retorna

EncoderDecoderConfig

Uma instância de um objeto de configuração

Instancie um EncoderDecoderConfig (ou uma classe derivada) a partir de uma configuração de modelo codificador pré-treinado e de uma configuração de modelo decodificador.

RagTokenizer

classe transformers.RagTokenizer

< source >

( question_encodergenerator )

Saídas específicas de Rag

classe transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput

< source >

( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonedoc_scores: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneretrieved_doc_embeds: typing.Optional[torch.Tensor] = Noneretrieved_doc_ids: typing.Optional[torch.LongTensor] = Nonecontext_input_ids: typing.Optional[torch.LongTensor] = Nonecontext_attention_mask: typing.Optional[torch.LongTensor] = Nonequestion_encoder_last_hidden_state: typing.Optional[torch.Tensor] = Nonequestion_enc_hidden_states: tuple[torch.Tensor, ...] | None = Nonequestion_enc_attentions: tuple[torch.Tensor, ...] | None = Nonegenerator_enc_last_hidden_state: typing.Optional[torch.Tensor] = Nonegenerator_enc_hidden_states: tuple[torch.Tensor, ...] | None = Nonegenerator_enc_attentions: tuple[torch.Tensor, ...] | None = Nonegenerator_dec_hidden_states: tuple[torch.Tensor, ...] | None = Nonegenerator_dec_attentions: tuple[torch.Tensor, ...] | None = Nonegenerator_cross_attentions: tuple[torch.Tensor, ...] | None = None )

Parâmetros

loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de modelagem de linguagem.
logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem. A pontuação pode ser marginalizada sobre todos os documentos para cada token do vocabulário.
doc_scores (torch.Tensor de forma (batch_size, config.n_docs)) — Pontuação entre cada embedding de documento recuperado (veja retrieved_doc_embeds) e question_encoder_last_hidden_state.
past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma Cache instância. Para mais detalhes, consulte nosso guia de cache de kv.
Contém estados ocultos pré-computados (chaves e valores nos blocos de atenção) do decodificador que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.
retrieved_doc_embeds (torch.Tensor de forma (batch_size, config.n_docs, hidden_size), opcional, retornado quando output_retrieved=True) — Documentos incorporados recuperados pelo recuperador. É usado com question_encoder_last_hidden_state para calcular os doc_scores.
retrieved_doc_ids (torch.LongTensor de forma (batch_size, config.n_docs), opcional, retornado quando output_retrieved=True) — Os índices dos documentos incorporados recuperados pelo retriever.
context_input_ids (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — IDs de entrada pós-processados a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador.
context_attention_mask (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — Máscara de atenção pós-processada a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador.
question_encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador da pergunta, saída agregada do modelo.
question_enc_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).
Estados ocultos do codificador da pergunta na saída de cada camada, além das saídas do embedding inicial.
question_enc_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 do codificador da pergunta, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
generator_enc_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do gerador do modelo.
generator_enc_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).
Estados ocultos do codificador do gerador na saída de cada camada, além das saídas do embedding inicial.
generator_enc_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 formato (batch_size, num_heads, sequence_length, sequence_length).
Pesos de atenção do codificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
generator_dec_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).
Estados ocultos do decodificador do gerador na saída de cada camada, mais as saídas do embedding inicial.
generator_dec_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 do decodificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
generator_cross_attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).
Pesos das cross-attentions do decodificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de cross-atenção.

Classe base para as saídas de modelos marginalizados com retrieval aumentado.

classe transformers.models.rag.modeling_rag.RetrievAugLMOutput

< source >

( logits: typing.Optional[torch.Tensor] = Nonedoc_scores: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneretrieved_doc_embeds: typing.Optional[torch.Tensor] = Noneretrieved_doc_ids: typing.Optional[torch.LongTensor] = Nonecontext_input_ids: typing.Optional[torch.LongTensor] = Nonecontext_attention_mask: typing.Optional[torch.LongTensor] = Nonequestion_encoder_last_hidden_state: typing.Optional[torch.Tensor] = Nonequestion_enc_hidden_states: tuple[torch.Tensor, ...] | None = Nonequestion_enc_attentions: tuple[torch.Tensor, ...] | None = Nonegenerator_enc_last_hidden_state: typing.Optional[torch.Tensor] = Nonegenerator_enc_hidden_states: tuple[torch.Tensor, ...] | None = Nonegenerator_enc_attentions: tuple[torch.Tensor, ...] | None = Nonegenerator_dec_hidden_states: tuple[torch.Tensor, ...] | None = Nonegenerator_dec_attentions: tuple[torch.Tensor, ...] | None = Nonegenerator_cross_attentions: tuple[torch.Tensor, ...] | None = None )

Parâmetros

logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem. A pontuação pode ser marginalizada sobre todos os documentos para cada token do vocabulário.
doc_scores (torch.Tensor de forma (batch_size, config.n_docs)) — Pontuação entre cada embedding de documento recuperado (veja retrieved_doc_embeds) e question_encoder_last_hidden_state.
past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma Cache instância. Para mais detalhes, consulte nosso guia de cache de kv.
Contém estados ocultos pré-computados (chaves e valores nos blocos de atenção) do decodificador que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.
retrieved_doc_embeds (torch.Tensor de forma (batch_size, config.n_docs, hidden_size), opcional, retornado quando output_retrieved=True) — Documentos incorporados recuperados pelo recuperador. É usado com question_encoder_last_hidden_state para calcular os doc_scores.
retrieved_doc_ids (torch.LongTensor de forma (batch_size, config.n_docs), opcional, retornado quando output_retrieved=True) — Os índices dos documentos incorporados recuperados pelo retriever.
context_input_ids (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — IDs de entrada pós-processados a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador.
context_attention_mask (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — Máscara de atenção pós-processada a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador.
question_encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador da pergunta, saída agregada do modelo.
question_enc_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).
Estados ocultos do codificador da pergunta na saída de cada camada, além das saídas do embedding inicial.
question_enc_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 do codificador da pergunta, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
generator_enc_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do gerador do modelo.
generator_enc_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).
Estados ocultos do codificador do gerador na saída de cada camada, além das saídas do embedding inicial.
generator_enc_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 formato (batch_size, num_heads, sequence_length, sequence_length).
Pesos de atenção do codificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
generator_dec_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).
Estados ocultos do decodificador do gerador na saída de cada camada, mais as saídas do embedding inicial.
generator_dec_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 do decodificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
generator_cross_attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).
Pesos das cross-attentions do decodificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de cross-atenção.

RagRetriever

classe transformers.RagRetriever

< source >

( configquestion_encoder_tokenizergenerator_tokenizerindex = Noneinit_retrieval = True )

Parâmetros

config (RagConfig) — A configuração do modelo RAG com o qual este Retriever é utilizado. Contém parâmetros que indicam qual Index deve ser construído. Você pode carregar seu próprio dataset personalizado com config.index_name="custom" ou usar um canônico (padrão) da biblioteca datasets, por exemplo, com config.index_name="wiki_dpr".
question_encoder_tokenizer (PreTrainedTokenizer) — O tokenizer usado para tokenizar a pergunta. Ele é usado para decodificar a pergunta e, em seguida, usar o generator_tokenizer.
generator_tokenizer (PreTrainedTokenizer) — O tokenizer usado para a parte geradora do RagModel.
index (Index, opcional, padrão é o definido pela configuração) — Se especificado, use este índice em vez do construído usando a configuração

Retriever usado para obter documentos a partir de consultas vetoriais. Ele recupera os embeddings dos documentos, bem como o conteúdo dos documentos, e os formata para uso com um RagModel.

Exemplos:

>>> # To load the default "wiki_dpr" dataset with 21M passages from wikipedia (index name is 'compressed' or 'exact')
>>> from transformers import RagRetriever

>>> retriever = RagRetriever.from_pretrained(
...     "facebook/rag-sequence-nq", dataset="wiki_dpr", index_name="compressed"
... )

>>> # To load your own indexed dataset built with the datasets library.
>>> from transformers import RagRetriever

>>> dataset = (
...     ...
... )  # dataset must be a datasets.Datasets object with columns "title", "text" and "embeddings", and it must have a supported index (e.g., Faiss or other index types depending on your setup)
>>> retriever = RagRetriever.from_pretrained("facebook/rag-sequence-nq", indexed_dataset=dataset)

>>> # To load your own indexed dataset built with the datasets library that was saved on disk.
>>> from transformers import RagRetriever

>>> dataset_path = "path/to/my/dataset"  # dataset saved via *dataset.save_to_disk(...)*
>>> index_path = "path/to/my/index"  # index saved via *dataset.get_index("embeddings").save(...)*
>>> retriever = RagRetriever.from_pretrained(
...     "facebook/rag-sequence-nq",
...     index_name="custom",
...     passages_path=dataset_path,
...     index_path=index_path,
... )

>>> # To load the legacy index built originally for Rag's paper
>>> from transformers import RagRetriever

>>> retriever = RagRetriever.from_pretrained("facebook/rag-sequence-nq", index_name="legacy")

init_retrieval

< source >

( )

Função de inicialização do Retriever. Ela carrega o índice na memória.

postprocess_docs

< source >

( docsinput_stringsprefixn_docsreturn_tensors = None ) → tuple(tensors)

Parâmetros

docs (dict) — Documentos recuperados.
input_strings (str) — Strings de entrada decodificadas por preprocess_query.
prefix (str) — Prefixo adicionado no início de cada entrada, geralmente usado com modelos baseados em T5.

Retorna

tuple(tensors)

uma tupla consistindo de dois elementos: input_ids contextualizados e uma attention_mask compatível.

Pós-processamento dos docs recuperados e combinação com input_strings.

recuperar

< source >

( question_hidden_states: ndarrayn_docs: int ) → tuple[np.ndarray, np.ndarray, list[dict]]

Parâmetros

question_hidden_states (np.ndarray de forma (batch_size, vector_size)) — Um lote de vetores de consulta para recuperação.
n_docs (int) — O número de documentos recuperados por consulta.

Retorna

tuple[np.ndarray, np.ndarray, list[dict]]

Uma tupla com os seguintes objetos:

retrieved_doc_embeds (np.ndarray de forma (batch_size, n_docs, dim)) — Os embeddings de recuperação dos documentos recuperados por consulta.
doc_ids (np.ndarray de forma (batch_size, n_docs)) — Os ids dos documentos no índice
doc_dicts (list[dict]): Os exemplos de retrieved_doc_embeds por consulta.

Recupera documentos para os question_hidden_states especificados.

RagModel

classe transformers.RagModel

< source >

( config: transformers.configuration_utils.PreTrainedConfig | None = Nonequestion_encoder: transformers.modeling_utils.PreTrainedModel | None = Nonegenerator: transformers.modeling_utils.PreTrainedModel | None = Noneretriever: transformers.models.rag.retrieval_rag.RagRetriever | None = None**kwargs )

Parâmetros

config (PreTrainedConfig, opcional) — 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.
question_encoder (PreTrainedModel, opcional) — O modelo responsável por codificar a pergunta em estados ocultos para a recuperação.
generator (PreTrainedModel, opcional) — O modelo responsável por gerar texto com base nos documentos recuperados.
retriever (RagRetriever, opcional) — O componente responsável por recuperar documentos de uma base de conhecimento com base na pergunta codificada.

O modelo Rag puro que produz estados ocultos brutos, sem nenhum head 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

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedoc_scores: typing.Optional[torch.Tensor] = Nonecontext_input_ids: typing.Optional[torch.LongTensor] = Nonecontext_attention_mask: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Noneoutput_retrieved: bool | None = Nonen_docs: int | None = None**kwargs ) → RetrievAugLMOutput 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. RagConfig, usado para inicializar o modelo, especifica qual gerador usar e também especifica um tokenizer de gerador compatível. Use a classe desse tokenizer para obter os índices.
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?
encoder_outputs (tuple(tuple(torch.Tensor), opcional) — A tupla consiste em (generator_enc_last_hidden_state, opcional: generator_enc_hidden_states, opcional: generator_enc_attentions). generator_enc_last_hidden_state de forma (batch_size, n_docs * sequence_length, hidden_size) é uma sequência de hidden-states na saída da última camada do encoder do gerador.
Usado pelo modelo (RagModel) durante a decodificação.
decoder_input_ids (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Forneça para tarefas de geração. None por padrão, construa conforme as instruções do modelo gerador que você está usando com sua instância de RAG.
decoder_input_ids (torch.LongTensor de formato (batch_size, target_sequence_length), opcional) — Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada do decodificador?
Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

O que são IDs de entrada do decodificador?
decoder_attention_mask (torch.BoolTensor de forma (batch_size, target_sequence_length), opcional) — Comportamento padrão: gera um tensor que ignora tokens de preenchimento em decoder_input_ids. A máscara causal também será usada por padrão.
past_key_values (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.
Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

O modelo sairá no mesmo formato de cache que é fornecido como entrada.

Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).
doc_scores (torch.Tensor de forma (batch_size, config.n_docs)) — Pontuação entre cada embedding de documento recuperado (veja retrieved_doc_embeds) e question_encoder_last_hidden_state. Se o modelo não foi inicializado com um retriever, doc_scores deve ser fornecido para a passagem direta. doc_scores pode ser calculado via question_encoder_last_hidden_state e retrieved_doc_embeds; veja os exemplos para mais informações.
context_input_ids (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — IDs de entrada pós-processados a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador. Se o modelo não foi inicializado com um retriever, `context_input_ids` deve ser fornecido para a passagem direta. context_input_ids são retornados por __call__().
context_attention_mask (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length),opcional, retornado quando output_retrieved=True) — Máscara de atenção pós-processada a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo retriever. Se o modelo não foi inicializado com um retriever, o context_attention_mask deve ser fornecido para a forward pass. O context_attention_mask é retornado por __call__().
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_attentions (bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte attentions nos tensores retornados para mais detalhes.
output_hidden_states (bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors retornados para mais detalhes.
output_retrieved (bool, opcional) — Indica se os tensores retrieved_doc_embeds, retrieved_doc_ids, context_input_ids e context_attention_mask devem ser retornados. Consulte os tensores retornados para mais detalhes.
n_docs (int, opcional) — O número de documentos a serem recuperados.

Retorna

RetrievAugLMOutput ou tuple(torch.Tensor)

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

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

logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem. A pontuação pode ser marginalizada sobre todos os documentos para cada token do vocabulário.
doc_scores (torch.Tensor de forma (batch_size, config.n_docs)) — Pontuação entre cada embedding de documento recuperado (veja retrieved_doc_embeds) e question_encoder_last_hidden_state.
past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

Contém estados ocultos pré-computados (chaves e valores nos blocos de atenção) do decodificador que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.
retrieved_doc_embeds (torch.Tensor de forma (batch_size, config.n_docs, hidden_size), opcional, retornado quando output_retrieved=True) — Documentos incorporados recuperados pelo recuperador. É usado com question_encoder_last_hidden_state para calcular os doc_scores.
retrieved_doc_ids (torch.LongTensor de forma (batch_size, config.n_docs), opcional, retornado quando output_retrieved=True) — Os índices dos documentos incorporados recuperados pelo retriever.
context_input_ids (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — IDs de entrada processados a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador.
context_attention_mask (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — Máscara de atenção pós-processada a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador.
question_encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador da pergunta, saída agregada do modelo.
question_enc_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do codificador da pergunta na saída de cada camada, além das saídas do embedding inicial.
question_enc_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 do codificador da pergunta, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
generator_enc_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do gerador do modelo.
generator_enc_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do codificador do gerador na saída de cada camada, além das saídas do embedding inicial.
generator_enc_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 do codificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
generator_dec_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do decodificador do gerador na saída de cada camada, mais as saídas do embedding inicial.
generator_dec_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 do decodificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
generator_cross_attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos das cross-attentions do decodificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de cross-atenção.

Exemplo:

>>> from transformers import AutoTokenizer, RagRetriever, RagModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/rag-token-base")
>>> retriever = RagRetriever.from_pretrained(
...     "facebook/rag-token-base", index_name="exact", use_dummy_dataset=True
... )
>>> # initialize with RagRetriever to do everything in one forward call
>>> model = RagModel.from_pretrained("facebook/rag-token-base", retriever=retriever)

>>> inputs = tokenizer("How many people live in Paris?", return_tensors="pt")
>>> outputs = model(input_ids=inputs["input_ids"])

RagSequenceForGeneration

classe transformers.RagSequenceForGeneration

< source >

Parâmetros

config (PreTrainedConfig, opcional) — 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.
question_encoder (PreTrainedModel, opcional) — O modelo responsável por codificar a pergunta em estados ocultos para a recuperação.
generator (PreTrainedModel, opcional) — O modelo responsável por gerar texto com base nos documentos recuperados.
retriever (RagRetriever, opcional) — O componente responsável por recuperar documentos de uma base de conhecimento com base na pergunta codificada.

Uma implementação de modelo RAG-sequence. Ele executa a marginalização específica do RAG-sequence na passagem direta.

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonecontext_input_ids: typing.Optional[torch.LongTensor] = Nonecontext_attention_mask: typing.Optional[torch.LongTensor] = Nonedoc_scores: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Noneoutput_retrieved: bool | None = Noneexclude_bos_score: bool | None = Nonereduce_loss: bool | None = Nonelabels: typing.Optional[torch.LongTensor] = Nonen_docs: int | None = None**kwargs ) → RetrievAugLMMarginOutput 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. RagConfig, usado para inicializar o modelo, especifica qual gerador usar e também especifica um tokenizer de gerador compatível. Use a classe desse tokenizer para obter os índices.
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?
encoder_outputs (tuple(tuple(torch.Tensor), opcional) — A tupla consiste em (generator_enc_last_hidden_state, opcional: generator_enc_hidden_states, opcional: generator_enc_attentions). generator_enc_last_hidden_state de forma (batch_size, n_docs * sequence_length, hidden_size) é uma sequência de hidden-states na saída da última camada do encoder do gerador.
Usado pelo modelo (RagModel) durante a decodificação.
decoder_input_ids (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Forneça para tarefas de geração. None por padrão, construa conforme as instruções do modelo gerador que você está usando com sua instância de RAG.
decoder_input_ids (torch.LongTensor de formato (batch_size, target_sequence_length), opcional) — Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada do decodificador?
Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

O que são IDs de entrada do decodificador?
decoder_attention_mask (torch.BoolTensor de forma (batch_size, target_sequence_length), opcional) — Comportamento padrão: gera um tensor que ignora tokens de preenchimento em decoder_input_ids. A máscara causal também será usada por padrão.
past_key_values (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.
Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

O modelo sairá no mesmo formato de cache que é fornecido como entrada.

Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).
context_input_ids (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — IDs de entrada pós-processados a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador. Se o modelo não foi inicializado com um retriever, `context_input_ids` deve ser fornecido para a passagem direta. context_input_ids são retornados por __call__().
context_attention_mask (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length),opcional, retornado quando output_retrieved=True) — Máscara de atenção pós-processada a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo retriever. Se o modelo não foi inicializado com um retriever, o context_attention_mask deve ser fornecido para a forward pass. O context_attention_mask é retornado por __call__().
doc_scores (torch.Tensor de forma (batch_size, config.n_docs)) — Pontuação entre cada embedding de documento recuperado (veja retrieved_doc_embeds) e question_encoder_last_hidden_state. Se o modelo não foi inicializado com um retriever, doc_scores deve ser fornecido para a passagem direta. doc_scores pode ser calculado via question_encoder_last_hidden_state e retrieved_doc_embeds; veja os exemplos para mais informações.
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_attentions (bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte attentions nos tensores retornados para mais detalhes.
output_hidden_states (bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors retornados para mais detalhes.
output_retrieved (bool, opcional) — Indica se os tensores retrieved_doc_embeds, retrieved_doc_ids, context_input_ids e context_attention_mask devem ser retornados. Consulte os tensores retornados para mais detalhes.
exclude_bos_score (bool, opcional) — Relevante apenas se labels for passado. Se True, a pontuação do token BOS é ignorada ao calcular a perda.
reduce_loss (bool, opcional) — Relevante apenas se labels for passado. Se True, a perda NLL é reduzida usando a operação torch.Tensor.sum.
labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em [0, ..., config.vocab_size] ou ser -100 (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 em [0, ..., config.vocab_size].
n_docs (int, opcional) — O número de documentos a serem recuperados.

Retorna

RetrievAugLMMarginOutput ou tuple(torch.Tensor)

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

O método forward da RagSequenceForGeneration 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.
logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem. A pontuação pode ser marginalizada sobre todos os documentos para cada token do vocabulário.
doc_scores (torch.Tensor de forma (batch_size, config.n_docs)) — Pontuação entre cada embedding de documento recuperado (veja retrieved_doc_embeds) e question_encoder_last_hidden_state.
past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

Contém estados ocultos pré-computados (chaves e valores nos blocos de atenção) do decodificador que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.
retrieved_doc_embeds (torch.Tensor de forma (batch_size, config.n_docs, hidden_size), opcional, retornado quando output_retrieved=True) — Documentos incorporados recuperados pelo recuperador. É usado com question_encoder_last_hidden_state para calcular os doc_scores.
retrieved_doc_ids (torch.LongTensor de forma (batch_size, config.n_docs), opcional, retornado quando output_retrieved=True) — Os índices dos documentos incorporados recuperados pelo retriever.
context_input_ids (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — IDs de entrada processados a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador.
context_attention_mask (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — Máscara de atenção pós-processada a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador.
question_encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador da pergunta, saída agregada do modelo.
question_enc_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do codificador da pergunta na saída de cada camada, além das saídas do embedding inicial.
question_enc_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 do codificador da pergunta, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
generator_enc_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do gerador do modelo.
generator_enc_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do codificador do gerador na saída de cada camada, além das saídas do embedding inicial.
generator_enc_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 do codificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
generator_dec_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do decodificador do gerador na saída de cada camada, mais as saídas do embedding inicial.
generator_dec_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 do decodificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
generator_cross_attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos das cross-attentions do decodificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de cross-atenção.

Exemplo:

>>> from transformers import AutoTokenizer, RagRetriever, RagSequenceForGeneration
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/rag-sequence-nq")
>>> retriever = RagRetriever.from_pretrained(
...     "facebook/rag-sequence-nq", index_name="exact", use_dummy_dataset=True
... )
>>> # initialize with RagRetriever to do everything in one forward call
>>> model = RagSequenceForGeneration.from_pretrained("facebook/rag-token-nq", retriever=retriever)

>>> inputs = tokenizer("How many people live in Paris?", return_tensors="pt")
>>> targets = tokenizer(text_target="In Paris, there are 10 million people.", return_tensors="pt")
>>> input_ids = inputs["input_ids"]
>>> labels = targets["input_ids"]
>>> outputs = model(input_ids=input_ids, labels=labels)

>>> # or use retriever separately
>>> model = RagSequenceForGeneration.from_pretrained("facebook/rag-sequence-nq", use_dummy_dataset=True)
>>> # 1. Encode
>>> question_hidden_states = model.question_encoder(input_ids)[0]
>>> # 2. Retrieve
>>> docs_dict = retriever(input_ids.numpy(), question_hidden_states.detach().numpy(), return_tensors="pt")
>>> doc_scores = torch.bmm(
...     question_hidden_states.unsqueeze(1), docs_dict["retrieved_doc_embeds"].float().transpose(1, 2)
... ).squeeze(1)
>>> # 3. Forward to generator
>>> outputs = model(
...     context_input_ids=docs_dict["context_input_ids"],
...     context_attention_mask=docs_dict["context_attention_mask"],
...     doc_scores=doc_scores,
...     decoder_input_ids=labels,
... )

generate

< source >

Parâmetros

input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — A sequência usada como prompt para a geração. Se input_ids não for fornecida, context_input_ids deve ser fornecida.
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?
context_input_ids (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — IDs de entrada pós-processados a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador.
context_attention_mask (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — Máscara de atenção pós-processada a partir dos documentos recuperados e do codificador da pergunta input_ids pelo recuperador.
Se o modelo não for inicializado com um retriever ou input_ids não for fornecido, context_input_ids e context_attention_mask devem ser fornecidos para a passagem direta. Eles são retornados por __call__().
doc_scores (torch.Tensor de forma (batch_size, config.n_docs)) — Pontuação entre cada embedding de documento recuperado (veja retrieved_doc_embeds) e question_encoder_last_hidden_state.
Se o modelo não for inicializado com um retriever ou input_ids não for fornecido, doc_scores deve ser fornecido para a forward pass. doc_scores são retornados por __call__().
do_deduplication (bool, opcional) — Indica se as gerações de diferentes documentos de contexto devem ser deduplicadas para uma determinada entrada. Deve ser definido como False se for usado durante o treinamento com um backend distribuído.
num_return_sequences(int, opcional, padrão 1) — O número de sequências retornadas, calculadas de forma independente, para cada elemento do lote. Observe que este não é o valor que passamos para a função [generate()](/docs/transformers/main/en/main_classes/text_generation#transformers.GenerationMixin.generate) do generator, onde definimos num_return_sequences como num_beams.
num_beams (int, opcional, padrão 1) — Número de feixes para a busca por feixes. 1 significa que não há busca por feixes.
n_docs (int, opcional, padrão config.n_docs) — Número de documentos a recuperar e/ou número de documentos para os quais gerar uma resposta.
kwargs (dict[str, Any], opcional) — Kwargs adicionais serão passados para generate().

Retorna

torch.LongTensor de forma (batch_size * num_return_sequences, sequence_length)

As sequências geradas. A segunda dimensão (comprimento da sequência) é igual a max_length ou mais curta, caso todos os lotes tenham terminado antecipadamente devido ao eos_token_id.

Implementa a decodificação “thorough” de sequência RAG. Leia a documentação de generate()` para obter mais informações sobre como definir outros parâmetros de entrada de generate.

RagTokenForGeneration

classe transformers.RagTokenForGeneration

< source >

Parâmetros

config (PreTrainedConfig, opcional) — 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.
question_encoder (PreTrainedModel, opcional) — O modelo responsável por codificar a pergunta em estados ocultos para a recuperação.
generator (PreTrainedModel, opcional) — O modelo responsável por gerar texto com base nos documentos recuperados.
retriever (RagRetriever, opcional) — O componente responsável por recuperar documentos de uma base de conhecimento com base na pergunta codificada.

Uma implementação de modelo RAG-token. Ele realiza a marginalização específica de RAG-token na passagem direta.

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonecontext_input_ids: typing.Optional[torch.LongTensor] = Nonecontext_attention_mask: typing.Optional[torch.LongTensor] = Nonedoc_scores: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Noneoutput_retrieved: bool | None = Nonedo_marginalize: bool | None = Nonereduce_loss: bool | None = Nonelabels: typing.Optional[torch.LongTensor] = Nonen_docs: int | None = None**kwargs ) → RetrievAugLMMarginOutput 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. RagConfig, usado para inicializar o modelo, especifica qual gerador usar e também especifica um tokenizer de gerador compatível. Use a classe desse tokenizer para obter os índices.
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?
encoder_outputs (tuple(tuple(torch.Tensor), opcional) — A tupla consiste em (generator_enc_last_hidden_state, opcional: generator_enc_hidden_states, opcional: generator_enc_attentions). generator_enc_last_hidden_state de forma (batch_size, n_docs * sequence_length, hidden_size) é uma sequência de hidden-states na saída da última camada do encoder do gerador.
Usado pelo modelo (RagModel) durante a decodificação.
decoder_input_ids (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Forneça para tarefas de geração. None por padrão, construa conforme as instruções do modelo gerador que você está usando com sua instância de RAG.
decoder_input_ids (torch.LongTensor de formato (batch_size, target_sequence_length), opcional) — Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada do decodificador?
Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

O que são IDs de entrada do decodificador?
decoder_attention_mask (torch.BoolTensor de forma (batch_size, target_sequence_length), opcional) — Comportamento padrão: gera um tensor que ignora tokens de preenchimento em decoder_input_ids. A máscara causal também será usada por padrão.
past_key_values (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.
Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

O modelo sairá no mesmo formato de cache que é fornecido como entrada.

Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).
context_input_ids (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — IDs de entrada pós-processados a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador. Se o modelo não foi inicializado com um retriever, `context_input_ids` deve ser fornecido para a passagem direta. context_input_ids são retornados por __call__().
context_attention_mask (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length),opcional, retornado quando output_retrieved=True) — Máscara de atenção pós-processada a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo retriever. Se o modelo não foi inicializado com um retriever, o context_attention_mask deve ser fornecido para a forward pass. O context_attention_mask é retornado por __call__().
doc_scores (torch.Tensor de forma (batch_size, config.n_docs)) — Pontuação entre cada embedding de documento recuperado (veja retrieved_doc_embeds) e question_encoder_last_hidden_state. Se o modelo não foi inicializado com um retriever, doc_scores deve ser fornecido para a passagem direta. doc_scores pode ser calculado via question_encoder_last_hidden_state e retrieved_doc_embeds; veja os exemplos para mais informações.
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_attentions (bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte attentions nos tensores retornados para mais detalhes.
output_hidden_states (bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors retornados para mais detalhes.
output_retrieved (bool, opcional) — Indica se os tensores retrieved_doc_embeds, retrieved_doc_ids, context_input_ids e context_attention_mask devem ser retornados. Consulte os tensores retornados para mais detalhes.
do_marginalize (bool, opcional) — Se True, os logits são marginalizados sobre todos os documentos, utilizando torch.nn.functional.log_softmax.
reduce_loss (bool, opcional) — Relevante apenas se labels for passado. Se True, a perda NLL é reduzida usando a operação torch.Tensor.sum.
labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em [0, ..., config.vocab_size] ou ser -100 (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 em [0, ..., config.vocab_size].
n_docs (int, opcional) — O número de documentos a serem recuperados.

Retorna

RetrievAugLMMarginOutput ou tuple(torch.Tensor)

O método forward de RagTokenForGeneration 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.
logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem. A pontuação pode ser marginalizada sobre todos os documentos para cada token do vocabulário.
doc_scores (torch.Tensor de forma (batch_size, config.n_docs)) — Pontuação entre cada embedding de documento recuperado (veja retrieved_doc_embeds) e question_encoder_last_hidden_state.
past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

Contém estados ocultos pré-computados (chaves e valores nos blocos de atenção) do decodificador que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.
retrieved_doc_embeds (torch.Tensor de forma (batch_size, config.n_docs, hidden_size), opcional, retornado quando output_retrieved=True) — Documentos incorporados recuperados pelo recuperador. É usado com question_encoder_last_hidden_state para calcular os doc_scores.
retrieved_doc_ids (torch.LongTensor de forma (batch_size, config.n_docs), opcional, retornado quando output_retrieved=True) — Os índices dos documentos incorporados recuperados pelo retriever.
context_input_ids (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — IDs de entrada processados a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador.
context_attention_mask (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — Máscara de atenção pós-processada a partir dos documentos recuperados e dos input_ids do codificador da pergunta pelo recuperador.
question_encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador da pergunta, saída agregada do modelo.
question_enc_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do codificador da pergunta na saída de cada camada, além das saídas do embedding inicial.
question_enc_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 do codificador da pergunta, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
generator_enc_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do gerador do modelo.
generator_enc_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do codificador do gerador na saída de cada camada, além das saídas do embedding inicial.
generator_enc_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 do codificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
generator_dec_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 e um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do decodificador do gerador na saída de cada camada, mais as saídas do embedding inicial.
generator_dec_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 do decodificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
generator_cross_attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos das cross-attentions do decodificador do gerador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de cross-atenção.

Exemplo:

>>> from transformers import AutoTokenizer, RagRetriever, RagTokenForGeneration
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/rag-token-nq")
>>> retriever = RagRetriever.from_pretrained(
...     "facebook/rag-token-nq", index_name="exact", use_dummy_dataset=True
... )
>>> # initialize with RagRetriever to do everything in one forward call
>>> model = RagTokenForGeneration.from_pretrained("facebook/rag-token-nq", retriever=retriever)

>>> inputs = tokenizer("How many people live in Paris?", return_tensors="pt")
>>> targets = tokenizer(text_target="In Paris, there are 10 million people.", return_tensors="pt")
>>> input_ids = inputs["input_ids"]
>>> labels = targets["input_ids"]
>>> outputs = model(input_ids=input_ids, labels=labels)

>>> # or use retriever separately
>>> model = RagTokenForGeneration.from_pretrained("facebook/rag-token-nq", use_dummy_dataset=True)
>>> # 1. Encode
>>> question_hidden_states = model.question_encoder(input_ids)[0]
>>> # 2. Retrieve
>>> docs_dict = retriever(input_ids.numpy(), question_hidden_states.detach().numpy(), return_tensors="pt")
>>> doc_scores = torch.bmm(
...     question_hidden_states.unsqueeze(1), docs_dict["retrieved_doc_embeds"].float().transpose(1, 2)
... ).squeeze(1)
>>> # 3. Forward to generator
>>> outputs = model(
...     context_input_ids=docs_dict["context_input_ids"],
...     context_attention_mask=docs_dict["context_attention_mask"],
...     doc_scores=doc_scores,
...     decoder_input_ids=labels,
... )

>>> # or directly generate
>>> generated = model.generate(
...     context_input_ids=docs_dict["context_input_ids"],
...     context_attention_mask=docs_dict["context_attention_mask"],
...     doc_scores=doc_scores,
... )
>>> generated_string = tokenizer.batch_decode(generated, skip_special_tokens=True)

generate

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonecontext_input_ids: typing.Optional[torch.LongTensor] = Nonecontext_attention_mask: typing.Optional[torch.LongTensor] = Nonedoc_scores: typing.Optional[torch.Tensor] = Nonen_docs: int | None = Nonegeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = Noneprefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = Nonelogits_processor: transformers.generation.logits_process.LogitsProcessorList | None = []stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = []**kwargs ) → torch.LongTensor of shape (batch_size * num_return_sequences, sequence_length)

Parâmetros

input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — A sequência usada como prompt para a geração. Se input_ids não for fornecida, context_input_ids deve ser fornecida.
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?
context_input_ids (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — IDs de entrada pós-processados a partir dos documentos recuperados e do codificador da pergunta input_ids pelo recuperador.
Se o modelo não for inicializado com um retriever, context_input_ids precisa ser fornecido para a passada de frente. context_input_ids são retornados por __call__().
context_attention_mask (torch.LongTensor de forma (batch_size * config.n_docs, config.max_combined_length), opcional, retornado quando output_retrieved=True) — Máscara de atenção pós-processada a partir dos documentos recuperados e do codificador da pergunta input_ids pelo retriever.
Se o modelo não for inicializado com um retriever, context_input_ids precisa ser fornecido para a passada de frente. context_input_ids são retornados por __call__().
doc_scores (torch.Tensor de forma (batch_size, config.n_docs)) — Pontuação entre cada embedding de documento recuperado (veja retrieved_doc_embeds) e question_encoder_last_hidden_state.
Se o modelo não for inicializado com um retriever, context_input_ids precisa ser fornecido para a passada de frente. context_input_ids são retornados por __call__().
n_docs (int, opcional, padrão config.n_docs) — Número de documentos a recuperar e/ou número de documentos para os quais gerar uma resposta.
generation_config (~generation.GenerationConfig, opcional) — A configuração de geração a ser usada como parametrização base para a chamada de geração. Os **kwargs passados para generate que correspondam aos atributos de generation_config os sobrescreverão. Se generation_config não for fornecido, o padrão será usado, que tem a seguinte prioridade de carregamento: 1) do arquivo de modelo generation_config.json, se existir; 2) da configuração do modelo. Observe que os parâmetros não especificados herdarão os valores padrão de GenerationConfig, cuja documentação deve ser consultada para parametrizar a geração.
prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], list[int]], opcional) — Se fornecida, esta função restringe a busca por feixe apenas aos tokens permitidos em cada etapa. Se não for fornecida, nenhuma restrição é aplicada. Esta função recebe 2 argumentos inputs_ids e o ID do lote batch_id. Ela deve retornar uma lista com os tokens permitidos para a próxima etapa de geração, condicionada aos tokens gerados anteriormente inputs_ids e ao ID do lote batch_id. Este argumento é útil para geração condicionada ao prefixo, conforme descrito em Autoregressive Entity Retrieval.
logits_processor (LogitsProcessorList, opcional) — Processadores de logits personalizados que complementam os processadores de logits padrão criados a partir dos argumentos e da configuração de um modelo. Se um processador de logits for passado que já foi criado com os argumentos ou com a configuração de um modelo, um erro será lançado.
stopping_criteria (StoppingCriteriaList, opcional) — Critérios de parada personalizados que complementam os critérios de parada padrão construídos a partir dos argumentos e da configuração de um modelo. Se um critério de parada for passado que já foi criado com os argumentos ou com a configuração de um modelo, um erro será lançado.
kwargs (dict[str, Any], opcional) — Parametrização ad hoc de generate_config e/ou kwargs específicos do modelo adicionais que serão encaminhados para a função forward do modelo.

Retorna

torch.LongTensor de forma (batch_size * num_return_sequences, sequence_length)

As sequências geradas. A segunda dimensão (sequence_length) é igual a max_length ou mais curta, caso todos os lotes tenham terminado antecipadamente devido ao eos_token_id.

Implementa a decodificação de tokens RAG.

Update on GitHub

←Qwen4-Exp RecurrentGemma→