# RAG

  
    
  

[Generación aumentada por recuperación (RAG)](https://huggingface.co/papers/2005.11401) combina un modelo de lenguaje preentrenado (memoria paramétrica) con el acceso a una fuente de datos externa (memoria no paramétrica) mediante un recuperador neuronal preentrenado. RAG recupera pasajes relevantes y condiciona su generación en ellos durante la inferencia. Esto suele hacer que las respuestas sean más factuales y permite actualizar el conocimiento cambiando el índice en lugar de reentrenar todo el modelo.

Puedes encontrar todos los puntos de control originales de RAG bajo la organización [AI at Meta](https://huggingface.co/facebook/models?search=rag).

> [!TIP]
> Este modelo fue aportado por [ola13](https://huggingface.co/ola13).
>
> Haz clic en los modelos de RAG en la barra lateral derecha para ver más ejemplos de cómo aplicar RAG a diferentes tareas de lenguaje.

Los ejemplos a continuación demuestran cómo generar texto con [AutoModel](/docs/transformers/main/es/model_doc/auto#transformers.AutoModel).

```python
from transformers import RagRetriever, RagSequenceForGeneration, RagTokenizer

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,
    attn_implementation="flash_attention_2",
    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])
```

La cuantización reduce la memoria almacenando los pesos con menor precisión. Consulte el resumen de [Cuantización](../quantization/overview) para conocer los backends compatibles. El siguiente ejemplo utiliza [bitsandbytes](../quantization/bitsandbytes) para cuantizar los pesos a 4 bits.

```python
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[[transformers.RagConfig]]

#### transformers.RagConfig[[transformers.RagConfig]]

```python
transformers.RagConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, question_encoder: transformers.configuration_utils.PreTrainedConfig | dict | None = None, generator: transformers.configuration_utils.PreTrainedConfig | dict | None = None, vocab_size: int | None = None, prefix: str | None = None, bos_token_id: int | None = None, pad_token_id: int | None = None, eos_token_id: int | list[int] | None = None, decoder_start_token_id: int | None = None, title_sep: str = ' / ', doc_sep: str = ' // ', n_docs: int = 5, max_combined_length: int = 300, retrieval_vector_size: int = 768, retrieval_batch_size: int = 8, dataset: str = 'wiki_dpr', dataset_split: str = 'train', index_name: str = 'compressed', index_path: str | None = None, passages_path: str | None = None, use_dummy_dataset: bool = False, reduce_loss: bool = False, label_smoothing: float = 0.0, do_deduplication: bool = True, exclude_bos_score: bool = False, do_marginalize: bool = False, output_retrieved: bool = False, use_cache: bool = True, dataset_revision: str | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/configuration_rag.py#L25)

**Parámetros:**

is_encoder_decoder (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo se utiliza como codificador/decodificador o no.

question_encoder (`PreTrainedConfig | dict`, *opcional*) : El objeto de configuración o diccionario del backbone del codificador de preguntas

generator (`PreTrainedConfig | dict`, *opcional*) : El objeto de configuración o diccionario del backbone del generador de respuestas

vocab_size (`int`, *opcional*) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

prefix (`str`, *opcional*) : Un prefijo de cadena que se antepone a cada entrada antes de pasarla al modelo generador.

bos_token_id (`int`, *opcional*) : Id de token utilizado para el inicio de la secuencia en el vocabulario.

pad_token_id (`int`, *opcional*) : Id de token utilizado para el relleno en el vocabulario.

eos_token_id (`Union[int, list[int]]`, *opcional*) : Id de token utilizado para el fin de la secuencia en el vocabulario.

decoder_start_token_id (`int`, *opcional*) : Si un modelo encoder-decoder comienza a decodificar con un token diferente de `bos`, el id de ese token.

title_sep (`str`, *opcional*, valor predeterminado  `" / "`) : Separador insertado entre el título y el texto del documento recuperado al llamar a [RagRetriever](/docs/transformers/main/es/model_doc/rag#transformers.RagRetriever).

doc_sep (`str`, *opcional*, valor predeterminado  `" // "`) : Separador insertado entre el texto del documento recuperado y la entrada original al llamar a [RagRetriever](/docs/transformers/main/es/model_doc/rag#transformers.RagRetriever).

n_docs (`int`, *opcional*, valor predeterminado 5) : Número de documentos a recuperar.

max_combined_length (`int`, *opcional*, valor predeterminado 300) : Longitud máxima de la entrada contextualizada devuelta por `__call__()`.

retrieval_vector_size (`int`, *opcional*, valor predeterminado 768) : Dimensionalidad de las incrustaciones de documentos indexadas por [RagRetriever](/docs/transformers/main/es/model_doc/rag#transformers.RagRetriever).

retrieval_batch_size (`int`, *opcional*, valor predeterminado: 8) : Tamaño del lote de recuperación, definido como el número de consultas emitidas de forma concurrente al índice faiss encapsulado en [RagRetriever](/docs/transformers/main/es/model_doc/rag#transformers.RagRetriever).

dataset (`str`, *opcional*, valor predeterminado `"wiki_dpr"`) : Un identificador de conjunto de datos del conjunto de datos indexado en HuggingFace Datasets (muestre todos los conjuntos de datos e ids disponibles usando `datasets.list_datasets()`).

dataset_split (`str`, *opcional*, valor predeterminado `"train"`) : Qué división del `dataset` cargar.

index_name (`str`, *opcional*, valor predeterminado `"compressed"`) : El nombre del índice del índice asociado con el `dataset`. Se puede elegir entre `"legacy"`, `"exact"` y `"compressed"`.

index_path (`str`, *opcional*) : La ruta al índice faiss serializado en el disco.

passages_path (`str`, *opcional*) : Una ruta a pasajes de texto compatibles con el índice faiss. Obligatorio si se usa `LegacyIndex`

use_dummy_dataset (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe cargar una variante "dummy" del conjunto de datos especificado por `dataset`.

reduce_loss (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe reducir la pérdida NLL utilizando la operación `torch.Tensor.sum`.

label_smoothing (`float`, *opcional*, valor predeterminado 0.0) : Solo es relevante si `return_loss` se establece en `True`. Controla el valor del parámetro `epsilon` para el suavizado de etiquetas en el cálculo de la pérdida. Si se establece en 0, no se realiza suavizado de etiquetas.

do_deduplication (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben deduplicar las generaciones de diferentes documentos de contexto para una entrada dada. Debe establecerse en `False` si se utiliza durante el entrenamiento con un backend distribuido.

exclude_bos_score (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe ignorar el token BOS al calcular la pérdida.

do_marginalize (`bool`, *opcional*, valor predeterminado `False`) : Si `True`, los logits se marginalizan sobre todos los documentos mediante el uso de `torch.nn.functional.log_softmax`.

output_retrieved (`bool`, *opcional*, valor predeterminado `False`) : Si se establece en `True`, se devuelven `retrieved_doc_embeds`, `retrieved_doc_ids`, `context_input_ids` y `context_attention_mask`. Consulte los tensores devueltos para obtener más detalles.

use_cache (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo debe devolver las últimas atenciones de claves/valores (no se utiliza en todos los modelos). Solo es relevante si `config.is_decoder=True` o cuando el modelo es un modelo generativo solo de decodificador.

dataset_revision (`str`, *opcional*,) : La revisión (hash de commit, etiqueta o rama) del conjunto de datos de Hugging Face utilizado para la recuperación.

Esta es la clase de configuración para almacenar la configuración de un RagModel. Se utiliza para instanciar un modelo Rag según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [](https://huggingface.co/)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

#### from_question_encoder_generator_configs[[transformers.RagConfig.from_question_encoder_generator_configs]]

```python
from_question_encoder_generator_configs(question_encoder_config: PreTrainedConfig, generator_config: PreTrainedConfig, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/configuration_rag.py#L129)

**Devuelve:** [EncoderDecoderConfig](/docs/transformers/main/es/model_doc/encoder-decoder#transformers.EncoderDecoderConfig)

Una instancia de un objeto de configuración

Instanciar un [EncoderDecoderConfig](/docs/transformers/main/es/model_doc/encoder-decoder#transformers.EncoderDecoderConfig) (o una clase derivada) a partir de la configuración de un modelo codificador preentrenado y la configuración de un modelo decodificador.

## RagTokenizer[[transformers.RagTokenizer]]

#### transformers.RagTokenizer[[transformers.RagTokenizer]]

```python
transformers.RagTokenizer(question_encoder, generator)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/tokenization_rag.py#L25)

## Salidas específicas de Rag[[transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput]]

#### transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput[[transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput]]

```python
transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, doc_scores: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, retrieved_doc_embeds: typing.Optional[torch.Tensor] = None, retrieved_doc_ids: typing.Optional[torch.LongTensor] = None, context_input_ids: typing.Optional[torch.LongTensor] = None, context_attention_mask: typing.Optional[torch.LongTensor] = None, question_encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, question_enc_hidden_states: tuple[torch.Tensor, ...] | None = None, question_enc_attentions: tuple[torch.Tensor, ...] | None = None, generator_enc_last_hidden_state: typing.Optional[torch.Tensor] = None, generator_enc_hidden_states: tuple[torch.Tensor, ...] | None = None, generator_enc_attentions: tuple[torch.Tensor, ...] | None = None, generator_dec_hidden_states: tuple[torch.Tensor, ...] | None = None, generator_dec_attentions: tuple[torch.Tensor, ...] | None = None, generator_cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/modeling_rag.py#L42)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de modelado de lenguaje.

logits (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) : Puntuaciones de predicción de la cabeza de modelado de lenguaje. La puntuación puede estar marginalizada sobre todos los documentos para cada token del vocabulario.

doc_scores (`torch.Tensor` de forma `(batch_size, config.n_docs)`) : Puntuación entre cada embedding de documento recuperado (ver `retrieved_doc_embeds`) y `question_encoder_last_hidden_state`.

past_key_values (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que pueden usarse (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

retrieved_doc_embeds (`torch.Tensor` de forma `(batch_size, config.n_docs, hidden_size)`, *opcional*, devuelto cuando *output_retrieved=True*) : Documentos incrustados recuperados por el recuperador. Se utiliza junto con `question_encoder_last_hidden_state` para calcular `doc_scores`.

retrieved_doc_ids (`torch.LongTensor` de forma `(batch_size, config.n_docs)`, *opcional*, devuelto cuando *output_retrieved=True*) : Los índices de los documentos incrustados recuperados por el recuperador.

context_input_ids (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, devuelto cuando *output_retrieved=True*) : ids de entrada procesados por el recuperador a partir de los documentos recuperados y de los input_ids del codificador de la pregunta.

context_attention_mask (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, devuelto cuando *output_retrieved=True*) : Máscara de atención procesada a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta por el recuperador.

question_encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Secuencia de estados ocultos en la salida de la última capa de la salida agrupada del codificador de preguntas del modelo.

question_enc_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings y uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador de la pregunta en la salida de cada capa más las salidas de los embeddings iniciales.

question_enc_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del codificador de la pregunta, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

generator_enc_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Secuencia de estados ocultos en la salida de la última capa del codificador del generador del modelo.

generator_enc_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings y uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador del generador en la salida de cada capa más las salidas de los embeddings iniciales.

generator_enc_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del codificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

generator_dec_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings y uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del decodificador del generador en la salida de cada capa más las salidas de los embeddings iniciales.

generator_dec_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del decodificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

generator_cross_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de las atenciones cruzadas del decodificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

Clase base para las salidas de modelos marginalizados aumentados con recuperadores.

#### transformers.models.rag.modeling_rag.RetrievAugLMOutput[[transformers.models.rag.modeling_rag.RetrievAugLMOutput]]

```python
transformers.models.rag.modeling_rag.RetrievAugLMOutput(logits: typing.Optional[torch.Tensor] = None, doc_scores: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, retrieved_doc_embeds: typing.Optional[torch.Tensor] = None, retrieved_doc_ids: typing.Optional[torch.LongTensor] = None, context_input_ids: typing.Optional[torch.LongTensor] = None, context_attention_mask: typing.Optional[torch.LongTensor] = None, question_encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, question_enc_hidden_states: tuple[torch.Tensor, ...] | None = None, question_enc_attentions: tuple[torch.Tensor, ...] | None = None, generator_enc_last_hidden_state: typing.Optional[torch.Tensor] = None, generator_enc_hidden_states: tuple[torch.Tensor, ...] | None = None, generator_enc_attentions: tuple[torch.Tensor, ...] | None = None, generator_dec_hidden_states: tuple[torch.Tensor, ...] | None = None, generator_dec_attentions: tuple[torch.Tensor, ...] | None = None, generator_cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/modeling_rag.py#L134)

**Parámetros:**

logits (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) : Puntuaciones de predicción de la cabeza de modelado de lenguaje. La puntuación puede estar marginalizada sobre todos los documentos para cada token del vocabulario.

doc_scores (`torch.Tensor` de forma `(batch_size, config.n_docs)`) : Puntuación entre cada embedding de documento recuperado (ver `retrieved_doc_embeds`) y `question_encoder_last_hidden_state`.

past_key_values (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que pueden usarse (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

retrieved_doc_embeds (`torch.Tensor` de forma `(batch_size, config.n_docs, hidden_size)`, *opcional*, devuelto cuando *output_retrieved=True*) : Documentos incrustados recuperados por el recuperador. Se utiliza junto con `question_encoder_last_hidden_state` para calcular `doc_scores`.

retrieved_doc_ids (`torch.LongTensor` de forma `(batch_size, config.n_docs)`, *opcional*, devuelto cuando *output_retrieved=True*) : Los índices de los documentos incrustados recuperados por el recuperador.

context_input_ids (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, devuelto cuando *output_retrieved=True*) : ids de entrada procesados por el recuperador a partir de los documentos recuperados y de los input_ids del codificador de la pregunta.

context_attention_mask (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, devuelto cuando *output_retrieved=True*) : Máscara de atención procesada a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta por el recuperador.

question_encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Secuencia de estados ocultos en la salida de la última capa de la salida agrupada del codificador de preguntas del modelo.

question_enc_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings y uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador de la pregunta en la salida de cada capa más las salidas de los embeddings iniciales.

question_enc_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del codificador de la pregunta, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

generator_enc_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Secuencia de estados ocultos en la salida de la última capa del codificador del generador del modelo.

generator_enc_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings y uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador del generador en la salida de cada capa más las salidas de los embeddings iniciales.

generator_enc_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del codificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

generator_dec_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings y uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del decodificador del generador en la salida de cada capa más las salidas de los embeddings iniciales.

generator_dec_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del decodificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

generator_cross_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de las atenciones cruzadas del decodificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

## RagRetriever[[transformers.RagRetriever]]

#### transformers.RagRetriever[[transformers.RagRetriever]]

```python
transformers.RagRetriever(config, question_encoder_tokenizer, generator_tokenizer, index = None, init_retrieval = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/retrieval_rag.py#L347)

**Parámetros:**

config ([RagConfig](/docs/transformers/main/es/model_doc/rag#transformers.RagConfig)) : La configuración del modelo RAG con el que se utiliza este Retriever. Contiene parámetros que indican qué `Index` construir. Puede cargar su propio conjunto de datos personalizado con `config.index_name="custom"` o utilizar uno canónico (predeterminado) de la biblioteca datasets, por ejemplo, con `config.index_name="wiki_dpr"`.

question_encoder_tokenizer ([PreTrainedTokenizer](/docs/transformers/main/es/main_classes/tokenizer#transformers.PythonBackend)) : El tokenizer que se utilizó para tokenizar la pregunta. Se usa para decodificar la pregunta y luego emplear el generator_tokenizer.

generator_tokenizer ([PreTrainedTokenizer](/docs/transformers/main/es/main_classes/tokenizer#transformers.PythonBackend)) : El tokenizador utilizado para la parte generadora del RagModel.

index (`Index`, opcional, predeterminado al definido por la configuración): Si se especifica, use este índice en lugar del construido con la configuración

Recuperador utilizado para obtener documentos a partir de consultas vectoriales. Recupera los embeddings de los documentos, así como el contenido de los documentos, y los formatea para ser utilizados con un RagModel.

Ejemplos:

```python
>>> # 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[[transformers.RagRetriever.init_retrieval]]

```python
init_retrieval()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/retrieval_rag.py#L482)

Función de inicialización del recuperador. Carga el índice en memoria.

#### postprocess_docs[[transformers.RagRetriever.postprocess_docs]]

```python
postprocess_docs(docs, input_strings, prefix, n_docs, return_tensors = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/retrieval_rag.py#L490)

**Parámetros:**

docs (`dict`): Documentos recuperados.

input_strings (`str`) : Cadenas de entrada decodificadas por `preprocess_query`.

prefix (`str`) : Prefijo que se añade al inicio de cada entrada, utilizado típicamente con modelos basados en T5.

**Devuelve:** `tuple(tensors)`

una tupla que consiste en dos elementos: `input_ids` contextualizados y una `attention_mask` compatible.

Postprocesamiento de los `docs` recuperados y combinación con `input_strings`.

#### recuperar[[transformers.RagRetriever.retrieve]]

```python
retrieve(question_hidden_states: ndarray, n_docs: int)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/retrieval_rag.py#L559)

**Parámetros:**

question_hidden_states (`np.ndarray` de forma `(batch_size, vector_size)`) : Un lote de vectores de consulta para la recuperación.

n_docs (`int`) : El número de documentos recuperados por consulta.

**Devuelve:** `tuple[np.ndarray, np.ndarray, list[dict]]`

Una tupla con los siguientes objetos:

- **retrieved_doc_embeds** (`np.ndarray` de forma `(batch_size, n_docs, dim)`) -- Las incrustaciones de recuperación de los documentos recuperados por consulta.
- **doc_ids** (`np.ndarray` de forma `(batch_size, n_docs)`) -- Los ids de los documentos en el índice
- **doc_dicts** (`list[dict]`): Los ejemplos de `retrieved_doc_embeds` por consulta.

Recupera documentos para los `question_hidden_states` especificados.

## RagModel[[transformers.RagModel]]

#### transformers.RagModel[[transformers.RagModel]]

```python
transformers.RagModel(config: transformers.configuration_utils.PreTrainedConfig | None = None, question_encoder: transformers.modeling_utils.PreTrainedModel | None = None, generator: transformers.modeling_utils.PreTrainedModel | None = None, retriever: transformers.models.rag.retrieval_rag.RagRetriever | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/modeling_rag.py#L372)

**Parámetros:**

config ([PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig), *opcional*) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

question_encoder (`PreTrainedModel`, *opcional*) : El modelo encargado de codificar la pregunta en estados ocultos para la recuperación.

generator (`PreTrainedModel`, *opcional*) : El modelo responsable de generar texto a partir de los documentos recuperados.

retriever (`RagRetriever`, *opcional*) : El componente responsable de recuperar documentos de una base de conocimientos a partir de la pregunta codificada.

El modelo Rag básico que emite estados ocultos sin ninguna cabeza específica en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.RagModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, doc_scores: typing.Optional[torch.Tensor] = None, context_input_ids: typing.Optional[torch.LongTensor] = None, context_attention_mask: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, output_retrieved: bool | None = None, n_docs: int | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/modeling_rag.py#L425)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [RagConfig](/docs/transformers/main/es/model_doc/rag#transformers.RagConfig), utilizado para inicializar el modelo, especifica qué generador se debe usar y también especifica un tokenizador de generador compatible. Utilice esa clase de tokenizador para obtener los índices. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

encoder_outputs (`tuple(tuple(torch.Tensor)`, *optional*) : La tupla consiste en (`generator_enc_last_hidden_state`, *optional*: `generator_enc_hidden_states`, *optional*: `generator_enc_attentions`). `generator_enc_last_hidden_state` de forma `(batch_size, n_docs * sequence_length, hidden_size)` es una secuencia de hidden-states en la salida de la última capa del codificador del generador. Se utiliza por el modelo ([RagModel](/docs/transformers/main/es/model_doc/rag#transformers.RagModel)) durante la decodificación.

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Se proporciona para tareas de generación. `None` por defecto; constrúyase según las instrucciones del modelo generador que se esté utilizando con la instancia de RAG.

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los IDs de entrada del decodificador?](../glossary#decoder-input-ids)

decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size,  target_sequence_length)`, *opcional*) : Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en `decoder_input_ids`. También se usará una máscara causal de forma predeterminada.

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

doc_scores (`torch.Tensor` de forma `(batch_size, config.n_docs)`) : Puntuación entre cada embedding de documento recuperado (ver `retrieved_doc_embeds`) y `question_encoder_last_hidden_state`. Si el modelo no se ha inicializado con un `retriever`, `doc_scores` debe proporcionarse en la pasada hacia adelante. `doc_scores` se puede calcular mediante `question_encoder_last_hidden_state` y `retrieved_doc_embeds`; consulte los ejemplos para obtener más información.

context_input_ids (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, devuelto cuando *output_retrieved=True*) : IDs de entrada procesados a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta por el recuperador. Si el modelo no se inicializó con un `retriever`, ``context_input_ids` debe proporcionarse en la pasada hacia adelante. `context_input_ids` se devuelve mediante `__call__()`.

context_attention_mask (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`,*opcional*, devuelto cuando *output_retrieved=True*) : Máscara de atención procesada a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta por el recuperador. Si el modelo no está inicializado con un `retriever`, se debe proporcionar `context_attention_mask` en la pasada hacia adelante. `context_attention_mask` es devuelto por `__call__()`.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

output_retrieved (`bool`, *opcional*) : Indica si se deben devolver o no `retrieved_doc_embeds`, `retrieved_doc_ids`, `context_input_ids` y `context_attention_mask`. Consulte los tensores devueltos para más detalles.

n_docs (`int`, *opcional*) : El número de documentos a recuperar.

**Devuelve:** [RetrievAugLMOutput](/docs/transformers/main/es/model_doc/rag#transformers.models.rag.modeling_rag.RetrievAugLMOutput) o `tuple(torch.Tensor)`

Un [RetrievAugLMOutput](/docs/transformers/main/es/model_doc/rag#transformers.models.rag.modeling_rag.RetrievAugLMOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([RagConfig](/docs/transformers/main/es/model_doc/rag#transformers.RagConfig)) y las entradas.

El método forward de [RagModel](/docs/transformers/main/es/model_doc/rag#transformers.RagModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje. La puntuación puede estar marginalizada sobre todos los documentos para cada token del vocabulario.
- **doc_scores** (`torch.Tensor` de forma `(batch_size, config.n_docs)`) -- Puntuación entre cada embedding de documento recuperado (ver `retrieved_doc_embeds`) y `question_encoder_last_hidden_state`.
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **retrieved_doc_embeds** (`torch.Tensor` de forma `(batch_size, config.n_docs, hidden_size)`, *opcional*, devuelto cuando *output_retrieved=True*) -- Documentos incrustados recuperados por el recuperador. Se utiliza junto con `question_encoder_last_hidden_state` para calcular `doc_scores`.
- **retrieved_doc_ids** (`torch.LongTensor` de forma `(batch_size, config.n_docs)`, *opcional*, se devuelve cuando *output_retrieved=True*) -- Los índices de los documentos incrustados recuperados por el recuperador.
- **context_input_ids** (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, se devuelve cuando *output_retrieved=True*) -- ids de entrada procesados a partir de los documentos recuperados y de los input_ids del codificador de la pregunta, por el recuperador.
- **context_attention_mask** (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, se devuelve cuando *output_retrieved=True*) -- Máscara de atención procesada a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta, por el recuperador.
- **question_encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador de preguntas, salida agrupada del modelo.
- **question_enc_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones y una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del codificador de la pregunta en la salida de cada capa más las salidas de la incrustación inicial.
- **question_enc_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención del codificador de la pregunta, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **generator_enc_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del generador del modelo.
- **generator_enc_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings y una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del codificador del generador en la salida de cada capa más las salidas de la incrustación inicial.
- **generator_enc_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención del codificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **generator_dec_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings y una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del decodificador del generador en la salida de cada capa más las salidas de la incrustación inicial.
- **generator_dec_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención del decodificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **generator_cross_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de las cross-attentions del decodificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de cross-attention.

Ejemplo:

```python
>>> 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[[transformers.RagSequenceForGeneration]]

#### transformers.RagSequenceForGeneration[[transformers.RagSequenceForGeneration]]

```python
transformers.RagSequenceForGeneration(config: transformers.configuration_utils.PreTrainedConfig | None = None, question_encoder: transformers.modeling_utils.PreTrainedModel | None = None, generator: transformers.modeling_utils.PreTrainedModel | None = None, retriever: transformers.models.rag.retrieval_rag.RagRetriever | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/modeling_rag.py#L663)

**Parámetros:**

config ([PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig), *opcional*) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

question_encoder (`PreTrainedModel`, *opcional*) : El modelo encargado de codificar la pregunta en estados ocultos para la recuperación.

generator (`PreTrainedModel`, *opcional*) : El modelo responsable de generar texto a partir de los documentos recuperados.

retriever (`RagRetriever`, *opcional*) : El componente responsable de recuperar documentos de una base de conocimientos a partir de la pregunta codificada.

Implementación de un modelo de secuencia RAG. Realiza la marginalización específica de RAG-sequence en la pasada hacia adelante.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.RagSequenceForGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, context_input_ids: typing.Optional[torch.LongTensor] = None, context_attention_mask: typing.Optional[torch.LongTensor] = None, doc_scores: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, output_retrieved: bool | None = None, exclude_bos_score: bool | None = None, reduce_loss: bool | None = None, labels: typing.Optional[torch.LongTensor] = None, n_docs: int | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/modeling_rag.py#L702)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [RagConfig](/docs/transformers/main/es/model_doc/rag#transformers.RagConfig), utilizado para inicializar el modelo, especifica qué generador se debe usar y también especifica un tokenizador de generador compatible. Utilice esa clase de tokenizador para obtener los índices. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

encoder_outputs (`tuple(tuple(torch.Tensor)`, *optional*) : La tupla consiste en (`generator_enc_last_hidden_state`, *optional*: `generator_enc_hidden_states`, *optional*: `generator_enc_attentions`). `generator_enc_last_hidden_state` de forma `(batch_size, n_docs * sequence_length, hidden_size)` es una secuencia de hidden-states en la salida de la última capa del codificador del generador. Se utiliza por el modelo ([RagModel](/docs/transformers/main/es/model_doc/rag#transformers.RagModel)) durante la decodificación.

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Se proporciona para tareas de generación. `None` por defecto; constrúyase según las instrucciones del modelo generador que se esté utilizando con la instancia de RAG.

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los IDs de entrada del decodificador?](../glossary#decoder-input-ids)

decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size,  target_sequence_length)`, *opcional*) : Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en `decoder_input_ids`. También se usará una máscara causal de forma predeterminada.

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

context_input_ids (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, devuelto cuando *output_retrieved=True*) : IDs de entrada procesados a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta por el recuperador. Si el modelo no se inicializó con un `retriever`, ``context_input_ids` debe proporcionarse en la pasada hacia adelante. `context_input_ids` se devuelve mediante `__call__()`.

context_attention_mask (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`,*opcional*, devuelto cuando *output_retrieved=True*) : Máscara de atención procesada a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta por el recuperador. Si el modelo no está inicializado con un `retriever`, se debe proporcionar `context_attention_mask` en la pasada hacia adelante. `context_attention_mask` es devuelto por `__call__()`.

doc_scores (`torch.Tensor` de forma `(batch_size, config.n_docs)`) : Puntuación entre cada embedding de documento recuperado (ver `retrieved_doc_embeds`) y `question_encoder_last_hidden_state`. Si el modelo no se ha inicializado con un `retriever`, `doc_scores` debe proporcionarse en la pasada hacia adelante. `doc_scores` se puede calcular mediante `question_encoder_last_hidden_state` y `retrieved_doc_embeds`; consulte los ejemplos para obtener más información.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

output_retrieved (`bool`, *opcional*) : Indica si se deben devolver o no `retrieved_doc_embeds`, `retrieved_doc_ids`, `context_input_ids` y `context_attention_mask`. Consulte los tensores devueltos para más detalles.

exclude_bos_score (`bool`, *opcional*) : Solo es relevante si se pasa `labels`. Si es `True`, la puntuación del token BOS se descarta al calcular la pérdida.

reduce_loss (`bool`, *opcional*) : Solo es relevante si se pasa `labels`. Si es `True`, la pérdida NLL se reduce usando la operación `torch.Tensor.sum`.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

n_docs (`int`, *opcional*) : El número de documentos a recuperar.

**Devuelve:** [RetrievAugLMMarginOutput](/docs/transformers/main/es/model_doc/rag#transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput) o `tuple(torch.Tensor)`

Un [RetrievAugLMMarginOutput](/docs/transformers/main/es/model_doc/rag#transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([RagConfig](/docs/transformers/main/es/model_doc/rag#transformers.RagConfig)) y las entradas.

El método forward de [RagSequenceForGeneration](/docs/transformers/main/es/model_doc/rag#transformers.RagSequenceForGeneration) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje. La puntuación puede estar marginalizada sobre todos los documentos para cada token del vocabulario.
- **doc_scores** (`torch.Tensor` de forma `(batch_size, config.n_docs)`) -- Puntuación entre cada embedding de documento recuperado (ver `retrieved_doc_embeds`) y `question_encoder_last_hidden_state`.
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **retrieved_doc_embeds** (`torch.Tensor` de forma `(batch_size, config.n_docs, hidden_size)`, *opcional*, devuelto cuando *output_retrieved=True*) -- Documentos incrustados recuperados por el recuperador. Se utiliza junto con `question_encoder_last_hidden_state` para calcular `doc_scores`.
- **retrieved_doc_ids** (`torch.LongTensor` de forma `(batch_size, config.n_docs)`, *opcional*, se devuelve cuando *output_retrieved=True*) -- Los índices de los documentos incrustados recuperados por el recuperador.
- **context_input_ids** (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, se devuelve cuando *output_retrieved=True*) -- ids de entrada procesados a partir de los documentos recuperados y de los input_ids del codificador de la pregunta, por el recuperador.
- **context_attention_mask** (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, se devuelve cuando *output_retrieved=True*) -- Máscara de atención procesada a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta, por el recuperador.
- **question_encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador de preguntas, salida agrupada del modelo.
- **question_enc_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones y una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del codificador de la pregunta en la salida de cada capa más las salidas de la incrustación inicial.
- **question_enc_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención del codificador de la pregunta, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **generator_enc_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del generador del modelo.
- **generator_enc_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings y una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del codificador del generador en la salida de cada capa más las salidas de la incrustación inicial.
- **generator_enc_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención del codificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **generator_dec_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings y una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del decodificador del generador en la salida de cada capa más las salidas de la incrustación inicial.
- **generator_dec_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención del decodificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **generator_cross_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de las cross-attentions del decodificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de cross-attention.

Ejemplo:

```python
>>> 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[[transformers.RagSequenceForGeneration.generate]]

```python
generate(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, context_input_ids: typing.Optional[torch.LongTensor] = None, context_attention_mask: typing.Optional[torch.LongTensor] = None, doc_scores: typing.Optional[torch.Tensor] = None, do_deduplication: bool | None = None, num_return_sequences: int | None = None, num_beams: int | None = None, n_docs: int | None = None, **model_kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/modeling_rag.py#L875)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : La secuencia utilizada como indicación para la generación. Si no se pasa `input_ids`, se debe proporcionar `context_input_ids`.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

context_input_ids (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, devuelto cuando *output_retrieved=True*) : IDs de entrada procesados por el recuperador a partir de los documentos recuperados y de los input_ids del codificador de la pregunta.

context_attention_mask (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, devuelto cuando *output_retrieved=True*) : Máscara de atención procesada a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta por el recuperador. Si el modelo no se inicializa con un `retriever` o no se proporciona `input_ids`, se deben proporcionar `context_input_ids` y `context_attention_mask` a la pasada hacia adelante. Son devueltos por `__call__()`.

doc_scores (`torch.Tensor` de forma `(batch_size, config.n_docs)`) : Puntuación entre cada embedding de documento recuperado (ver `retrieved_doc_embeds`) y `question_encoder_last_hidden_state`. Si el modelo no se inicializa con un `retriever` o no se proporciona `input_ids`, se debe proporcionar `doc_scores` a la pasada hacia adelante. `doc_scores` son devueltos por `__call__()`.

do_deduplication (`bool`, *opcional*) : Indica si se deben deduplicar las generaciones de diferentes documentos de contexto para una entrada dada. Debe establecerse en `False` si se utiliza durante el entrenamiento con un backend distribuido.

num_return_sequences(`int`, *opcional*, valor predeterminado 1) : El número de secuencias devueltas calculadas de forma independiente para cada elemento del lote. Tenga en cuenta que este no es el valor que se pasa a la función `[generate()](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationMixin.generate)` del `generator`, donde se establece `num_return_sequences` en `num_beams`.

num_beams (`int`, *opcional*, valor predeterminado 1) : Número de haces para la búsqueda por haces. 1 significa que no se realiza búsqueda por haces.

n_docs (`int`, *opcional*, valor predeterminado `config.n_docs`) : Número de documentos a recuperar y/o número de documentos para los que generar una respuesta.

kwargs (`dict[str, Any]`, *opcional*) : Los kwargs adicionales se pasarán a [generate()](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationMixin.generate).

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

Las secuencias generadas. La segunda dimensión (longitud de la secuencia) es igual a `max_length` o más corta si todos los lotes terminaron antes debido a `eos_token_id`.

Implementa la decodificación "thorough" de secuencias RAG. Consulte la documentación de [generate()](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationMixin.generate)` para obtener más información sobre cómo establecer otros parámetros de entrada de generate.

## RagTokenForGeneration[[transformers.RagTokenForGeneration]]

#### transformers.RagTokenForGeneration[[transformers.RagTokenForGeneration]]

```python
transformers.RagTokenForGeneration(config: transformers.configuration_utils.PreTrainedConfig | None = None, question_encoder: transformers.modeling_utils.PreTrainedModel | None = None, generator: transformers.modeling_utils.PreTrainedModel | None = None, retriever: transformers.models.rag.retrieval_rag.RagRetriever | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/modeling_rag.py#L1102)

**Parámetros:**

config ([PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig), *opcional*) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

question_encoder (`PreTrainedModel`, *opcional*) : El modelo encargado de codificar la pregunta en estados ocultos para la recuperación.

generator (`PreTrainedModel`, *opcional*) : El modelo responsable de generar texto a partir de los documentos recuperados.

retriever (`RagRetriever`, *opcional*) : El componente responsable de recuperar documentos de una base de conocimientos a partir de la pregunta codificada.

Implementación de un modelo RAG-token. Realiza la marginalización específica de RAG-token en la pasada hacia adelante.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.RagTokenForGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, context_input_ids: typing.Optional[torch.LongTensor] = None, context_attention_mask: typing.Optional[torch.LongTensor] = None, doc_scores: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, output_retrieved: bool | None = None, do_marginalize: bool | None = None, reduce_loss: bool | None = None, labels: typing.Optional[torch.LongTensor] = None, n_docs: int | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/modeling_rag.py#L1227)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [RagConfig](/docs/transformers/main/es/model_doc/rag#transformers.RagConfig), utilizado para inicializar el modelo, especifica qué generador se debe usar y también especifica un tokenizador de generador compatible. Utilice esa clase de tokenizador para obtener los índices. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

encoder_outputs (`tuple(tuple(torch.Tensor)`, *optional*) : La tupla consiste en (`generator_enc_last_hidden_state`, *optional*: `generator_enc_hidden_states`, *optional*: `generator_enc_attentions`). `generator_enc_last_hidden_state` de forma `(batch_size, n_docs * sequence_length, hidden_size)` es una secuencia de hidden-states en la salida de la última capa del codificador del generador. Se utiliza por el modelo ([RagModel](/docs/transformers/main/es/model_doc/rag#transformers.RagModel)) durante la decodificación.

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Se proporciona para tareas de generación. `None` por defecto; constrúyase según las instrucciones del modelo generador que se esté utilizando con la instancia de RAG.

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los IDs de entrada del decodificador?](../glossary#decoder-input-ids)

decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size,  target_sequence_length)`, *opcional*) : Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en `decoder_input_ids`. También se usará una máscara causal de forma predeterminada.

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

context_input_ids (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, devuelto cuando *output_retrieved=True*) : IDs de entrada procesados a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta por el recuperador. Si el modelo no se inicializó con un `retriever`, ``context_input_ids` debe proporcionarse en la pasada hacia adelante. `context_input_ids` se devuelve mediante `__call__()`.

context_attention_mask (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`,*opcional*, devuelto cuando *output_retrieved=True*) : Máscara de atención procesada a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta por el recuperador. Si el modelo no está inicializado con un `retriever`, se debe proporcionar `context_attention_mask` en la pasada hacia adelante. `context_attention_mask` es devuelto por `__call__()`.

doc_scores (`torch.Tensor` de forma `(batch_size, config.n_docs)`) : Puntuación entre cada embedding de documento recuperado (ver `retrieved_doc_embeds`) y `question_encoder_last_hidden_state`. Si el modelo no se ha inicializado con un `retriever`, `doc_scores` debe proporcionarse en la pasada hacia adelante. `doc_scores` se puede calcular mediante `question_encoder_last_hidden_state` y `retrieved_doc_embeds`; consulte los ejemplos para obtener más información.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

output_retrieved (`bool`, *opcional*) : Indica si se deben devolver o no `retrieved_doc_embeds`, `retrieved_doc_ids`, `context_input_ids` y `context_attention_mask`. Consulte los tensores devueltos para más detalles.

do_marginalize (`bool`, *opcional*) : Si `True`, los logits se marginalizan sobre todos los documentos mediante el uso de `torch.nn.functional.log_softmax`.

reduce_loss (`bool`, *opcional*) : Solo es relevante si se pasa `labels`. Si es `True`, la pérdida NLL se reduce usando la operación `torch.Tensor.sum`.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

n_docs (`int`, *opcional*) : El número de documentos a recuperar.

**Devuelve:** [RetrievAugLMMarginOutput](/docs/transformers/main/es/model_doc/rag#transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput) o `tuple(torch.Tensor)`

Un [RetrievAugLMMarginOutput](/docs/transformers/main/es/model_doc/rag#transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([RagConfig](/docs/transformers/main/es/model_doc/rag#transformers.RagConfig)) y las entradas.

El método forward de [RagTokenForGeneration](/docs/transformers/main/es/model_doc/rag#transformers.RagTokenForGeneration) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje. La puntuación puede estar marginalizada sobre todos los documentos para cada token del vocabulario.
- **doc_scores** (`torch.Tensor` de forma `(batch_size, config.n_docs)`) -- Puntuación entre cada embedding de documento recuperado (ver `retrieved_doc_embeds`) y `question_encoder_last_hidden_state`.
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **retrieved_doc_embeds** (`torch.Tensor` de forma `(batch_size, config.n_docs, hidden_size)`, *opcional*, devuelto cuando *output_retrieved=True*) -- Documentos incrustados recuperados por el recuperador. Se utiliza junto con `question_encoder_last_hidden_state` para calcular `doc_scores`.
- **retrieved_doc_ids** (`torch.LongTensor` de forma `(batch_size, config.n_docs)`, *opcional*, se devuelve cuando *output_retrieved=True*) -- Los índices de los documentos incrustados recuperados por el recuperador.
- **context_input_ids** (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, se devuelve cuando *output_retrieved=True*) -- ids de entrada procesados a partir de los documentos recuperados y de los input_ids del codificador de la pregunta, por el recuperador.
- **context_attention_mask** (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, se devuelve cuando *output_retrieved=True*) -- Máscara de atención procesada a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta, por el recuperador.
- **question_encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador de preguntas, salida agrupada del modelo.
- **question_enc_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones y una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del codificador de la pregunta en la salida de cada capa más las salidas de la incrustación inicial.
- **question_enc_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención del codificador de la pregunta, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **generator_enc_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del generador del modelo.
- **generator_enc_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings y una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del codificador del generador en la salida de cada capa más las salidas de la incrustación inicial.
- **generator_enc_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención del codificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **generator_dec_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings y una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del decodificador del generador en la salida de cada capa más las salidas de la incrustación inicial.
- **generator_dec_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención del decodificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **generator_cross_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de las cross-attentions del decodificador del generador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de cross-attention.

Ejemplo:

```python
>>> 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[[transformers.RagTokenForGeneration.generate]]

```python
generate(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, context_input_ids: typing.Optional[torch.LongTensor] = None, context_attention_mask: typing.Optional[torch.LongTensor] = None, doc_scores: typing.Optional[torch.Tensor] = None, n_docs: int | None = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, prefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = [], stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = [], **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rag/modeling_rag.py#L1400)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : La secuencia utilizada como indicación para la generación. Si no se pasa `input_ids`, se debe proporcionar `context_input_ids`.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

context_input_ids (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, devuelto cuando *output_retrieved=True*) : IDs de entrada procesados a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta por el recuperador. Si el modelo no se inicializa con un `retriever`, se debe proporcionar `context_input_ids` a la pasada hacia adelante. `context_input_ids` son devueltos por `__call__()`.

context_attention_mask (`torch.LongTensor` de forma `(batch_size * config.n_docs, config.max_combined_length)`, *opcional*, devuelto cuando *output_retrieved=True*) : Máscara de atención procesada a partir de los documentos recuperados y de los `input_ids` del codificador de la pregunta por el recuperador. Si el modelo no se inicializa con un `retriever`, se debe proporcionar `context_input_ids` en la pasada hacia adelante. `context_input_ids` se devuelve mediante `__call__()`.

doc_scores (`torch.Tensor` de forma `(batch_size, config.n_docs)`) : Puntuación entre cada embedding de documento recuperado (ver `retrieved_doc_embeds`) y `question_encoder_last_hidden_state`. Si el modelo no se inicializa con un `retriever`, se debe proporcionar `context_input_ids` a la pasada hacia adelante. `context_input_ids` son devueltos por `__call__()`.

n_docs (`int`, *opcional*, valor predeterminado `config.n_docs`) : Número de documentos a recuperar y/o número de documentos para los que generar una respuesta.

generation_config (`~generation.GenerationConfig`, *opcional*) : La configuración de generación que se utilizará como parametrización base para la llamada de generación. Los `**kwargs` pasados a generate que coincidan con los atributos de `generation_config` los sobrescribirán. Si no se proporciona `generation_config`, se utilizará la predeterminada, que tiene la siguiente prioridad de carga: 1) desde el archivo de modelo `generation_config.json`, si existe; 2) desde la configuración del modelo. Tenga en cuenta que los parámetros no especificados heredarán los valores predeterminados de [GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig), cuya documentación debe consultarse para parametrizar la generación.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *opcional*) : Si se proporciona, esta función restringe la búsqueda por haz a los tokens permitidos en cada paso. Si no se proporciona, no se aplica ninguna restricción. Esta función toma 2 argumentos, `inputs_ids` y el ID del lote `batch_id`. Debe devolver una lista con los tokens permitidos para el siguiente paso de generación, condicionada a los tokens generados previamente `inputs_ids` y al ID del lote `batch_id`. Este argumento es útil para la generación condicionada al prefijo, tal como se describe en [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904).

logits_processor (`LogitsProcessorList`, *opcional*) : Procesadores de logits personalizados que complementan los procesadores de logits predeterminados creados a partir de los argumentos y la configuración de un modelo. Si se pasa un procesador de logits que ya ha sido creado con los argumentos o la configuración de un modelo, se lanza un error.

stopping_criteria (`StoppingCriteriaList`, *opcional*) : Criterios de parada personalizados que complementan los criterios de parada predeterminados construidos a partir de los argumentos y la configuración de un modelo. Si se pasa un criterio de parada que ya se ha creado con los argumentos o la configuración de un modelo, se lanza un error.

kwargs (`dict[str, Any]`, *opcional*) : Parametrización ad hoc de `generate_config` y/o kwargs adicionales específicos del modelo que se reenviarán a la función `forward` del modelo.

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

Las secuencias generadas. La segunda dimensión (sequence_length) es igual a `max_length` o más corta si todos los lotes terminaron antes debido a `eos_token_id`.

Implementa la decodificación de tokens de RAG.