# DPR

## Resumen

Dense Passage Retrieval (DPR) es un conjunto de herramientas y modelos para la investigación de última generación en preguntas y respuestas de dominio abierto. Fue introducido en [Dense Passage Retrieval for Open-Domain Question Answering](https://huggingface.co/papers/2004.04906) por Vladimir Karpukhin, Barlas Oğuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, Wen-tau Yih.

El resumen del artículo es el siguiente:

*La respuesta a preguntas de dominio abierto depende de una recuperación eficiente de pasajes para seleccionar contextos candidatos, donde los modelos tradicionales de espacio vectorial disperso, como TF-IDF o BM25, son el método de facto. En este trabajo, demostramos que la recuperación puede implementarse de manera práctica utilizando únicamente representaciones densas, donde los embeddings se aprenden a partir de un pequeño número de preguntas y pasajes mediante un simple marco de doble codificador. Al evaluarse en una amplia gama de conjuntos de datos de QA de dominio abierto, nuestro recuperador denso supera en gran medida a un sistema Lucene-BM25 sólido, con una mejora absoluta del 9% al 19% en términos de precisión de recuperación de pasajes top-20, y ayuda a nuestro sistema de QA de extremo a extremo a establecer nuevos récords de estado del arte en varios benchmarks de QA de dominio abierto.*

Este modelo fue aportado por [lhoestq](https://huggingface.co/lhoestq). El código original se puede encontrar [aquí](https://github.com/facebookresearch/DPR).

## Consejos de uso

- DPR consta de tres modelos:

  * Codificador de preguntas: codifica las preguntas como vectores
  * Codificador de contexto: codifica los contextos como vectores
  * Lector: extrae la respuesta de las preguntas dentro de los contextos recuperados, junto con una puntuación de relevancia (alta si el fragmento inferido responde realmente a la pregunta).

## DPRConfig[[transformers.DPRConfig]]

#### transformers.DPRConfig[[transformers.DPRConfig]]

```python
transformers.DPRConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, projection_dim: int = 0, is_decoder: bool = False, add_cross_attention: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/configuration_dpr.py#L24)

**Parámetros:**

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

hidden_size (`int`, *opcional*, valor predeterminado `768`) : Dimensión de las representaciones ocultas.

num_hidden_layers (`int`, *opcional*, valor predeterminado `12`) : Número de capas ocultas en el decodificador del Transformer.

num_attention_heads (`int`, *opcional*, valor predeterminado `12`) : Número de cabezas de atención para cada capa de atención en el decodificador Transformer.

intermediate_size (`int`, *opcional*, valor predeterminado `3072`) : Dimensión de las representaciones MLP.

hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout_prob (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La probabilidad de dropout para todas las capas totalmente conectadas en los embeddings, el codificador y el pooler.

attention_probs_dropout_prob (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción de dropout para las probabilidades de atención.

max_position_embeddings (`int`, *opcional*, valor predeterminado `512`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

type_vocab_size (`int`, *opcional*, valor predeterminado `2`) : El tamaño del vocabulario de `token_type_ids`.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-12`) : El epsilon utilizado por las capas de normalización de capas.

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

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

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

projection_dim (`int`, *opcional*, valor predeterminado `0`) : Dimensionalidad de las capas de proyección de texto y visión.

is_decoder (`bool`, *opcional*, valor predeterminado `False`) : Indica si el modelo se utiliza como decodificador. Si es `False`, el modelo se utiliza como codificador.

add_cross_attention (`bool`, *opcional*, valor predeterminado `False`) : Si se deben añadir capas de atención cruzada al modelo.

Esta es la clase de configuración para almacenar la configuración de un DPRQuestionEncoder. Se utiliza para instanciar un modelo Dpr 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 [facebook/dpr-ctx_encoder-single-nq-base](https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base)

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.

Ejemplo:

```python
>>> from transformers import DPRConfig, DPRContextEncoder

>>> # Initializing a DPR facebook/dpr-ctx_encoder-single-nq-base style configuration
>>> configuration = DPRConfig()

>>> # Initializing a model (with random weights) from the facebook/dpr-ctx_encoder-single-nq-base style configuration
>>> model = DPRContextEncoder(configuration)

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

## DPRContextEncoderTokenizer[[transformers.DPRContextEncoderTokenizer]]

#### transformers.DPRContextEncoderTokenizer[[transformers.DPRContextEncoderTokenizer]]

```python
transformers.DPRContextEncoderTokenizer(*args, do_lower_case = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/tokenization_dpr.py#L28)

Construya un tokenizador DPRContextEncoder.

[DPRContextEncoderTokenizer](/docs/transformers/main/es/model_doc/dpr#transformers.DPRContextEncoderTokenizer) es idéntico a [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) y ejecuta la tokenización de extremo a extremo: división de puntuación y wordpiece.

Consulte la superclase [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) para ver ejemplos de uso y documentación sobre los parámetros.

## DPRContextEncoderTokenizerFast[[transformers.DPRContextEncoderTokenizerFast]]

#### transformers.DPRContextEncoderTokenizerFast[[transformers.DPRContextEncoderTokenizerFast]]

```python
transformers.DPRContextEncoderTokenizerFast(vocab: str | dict[str, int] | None = None, do_lower_case: bool = True, unk_token: str = '[UNK]', sep_token: str = '[SEP]', pad_token: str = '[PAD]', cls_token: str = '[CLS]', mask_token: str = '[MASK]', tokenize_chinese_chars: bool = True, strip_accents: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/tokenization_dpr_fast.py#L29)

Construya un tokenizador "fast" de DPRContextEncoder (respaldado por la biblioteca *tokenizers* de HuggingFace).

[DPRContextEncoderTokenizerFast](/docs/transformers/main/es/model_doc/dpr#transformers.DPRContextEncoderTokenizerFast) es idéntico a [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) y ejecuta la tokenización de extremo a extremo: división de puntuación y wordpiece.

Consulte la superclase [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) para ver ejemplos de uso y documentación sobre los parámetros.

## DPRQuestionEncoderTokenizer[[transformers.DPRQuestionEncoderTokenizer]]

#### transformers.DPRQuestionEncoderTokenizer[[transformers.DPRQuestionEncoderTokenizer]]

```python
transformers.DPRQuestionEncoderTokenizer(*args, do_lower_case = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/tokenization_dpr.py#L45)

Construye un tokenizador DPRQuestionEncoder.

[DPRQuestionEncoderTokenizer](/docs/transformers/main/es/model_doc/dpr#transformers.DPRQuestionEncoderTokenizer) es idéntico a [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) y ejecuta la tokenización de extremo a extremo: división de puntuación y wordpiece.

Consulte la superclase [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) para ver ejemplos de uso y documentación sobre los parámetros.

## DPRQuestionEncoderTokenizerFast[[transformers.DPRQuestionEncoderTokenizerFast]]

#### transformers.DPRQuestionEncoderTokenizerFast[[transformers.DPRQuestionEncoderTokenizerFast]]

```python
transformers.DPRQuestionEncoderTokenizerFast(vocab: str | dict[str, int] | None = None, do_lower_case: bool = True, unk_token: str = '[UNK]', sep_token: str = '[SEP]', pad_token: str = '[PAD]', cls_token: str = '[CLS]', mask_token: str = '[MASK]', tokenize_chinese_chars: bool = True, strip_accents: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/tokenization_dpr_fast.py#L43)

Construye un tokenizador "rápido" de DPRQuestionEncoder (respaldado por la biblioteca *tokenizers* de HuggingFace).

[DPRQuestionEncoderTokenizerFast](/docs/transformers/main/es/model_doc/dpr#transformers.DPRQuestionEncoderTokenizerFast) es idéntico a [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) y ejecuta la tokenización de extremo a extremo: división de puntuación y wordpiece.

Consulte la superclase [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) para ver ejemplos de uso y documentación sobre los parámetros.

## DPRReaderTokenizer[[transformers.DPRReaderTokenizer]]

#### transformers.DPRReaderTokenizer[[transformers.DPRReaderTokenizer]]

```python
transformers.DPRReaderTokenizer(*args, do_lower_case = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/tokenization_dpr.py#L311)

**Parámetros:**

questions (`str` o `list[str]`) : Las preguntas que se van a codificar. Puede especificar una pregunta para muchos pasajes. En este caso, la pregunta se duplicará como `[questions] * n_passages`. De lo contrario, debe especificar tantas preguntas como haya en `titles` o `texts`.

titles (`str` o `list[str]`) : Los títulos de los pasajes a codificar. Puede ser una cadena o una lista de cadenas si hay varios pasajes.

texts (`str` o `list[str]`) : Los textos de los pasajes que se van a codificar. Puede ser una cadena o una lista de cadenas si hay varios pasajes.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : Activa y controla el relleno. Acepta los siguientes valores:  - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de longitudes diferentes).

truncation (`bool`, `str` o [TruncationStrategy](/docs/transformers/main/es/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, valor predeterminado `False`) : Activa y controla la truncación. Acepta los siguientes valores:  - `True` o `'longest_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token por token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_second'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `False` o `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible del modelo).

max_length (`int`, *opcional*) : Controla la longitud máxima que debe usar uno de los parámetros de truncamiento/relleno. Si se deja sin establecer o se establece en `None`, se usará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno requiere una longitud máxima. Si el modelo no tiene una longitud de entrada máxima específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará.

return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy.

return_attention_mask (`bool`, *opcional*) : Indica si se debe devolver la máscara de atención. Si no se establece, se devolverá la máscara de atención según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

**Devuelve:** `dict[str, list[list[int]]]`

Un diccionario con las siguientes claves:

- `input_ids`: Lista de ids de tokens que se enviarán a un modelo.
- `attention_mask`: Lista de índices que especifica qué tokens deben ser atendidos por el modelo.

Construye un tokenizador DPRReader.

[DPRReaderTokenizer](/docs/transformers/main/es/model_doc/dpr#transformers.DPRReaderTokenizer) es casi idéntico a [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) y ejecuta la tokenización de principio a fin: división de puntuación y wordpiece. La diferencia es que tiene tres cadenas de entrada: question, titles y texts, que se combinan para alimentar al modelo [DPRReader](/docs/transformers/main/es/model_doc/dpr#transformers.DPRReader).

Consulte la superclase [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) para ver ejemplos de uso y documentación sobre los parámetros.

Devuelve un diccionario con los ids de los tokens de las cadenas de entrada y otra información para pasar a `.decode_best_spans`. Convierte las cadenas de una pregunta y de distintos pasajes (título y texto) en una secuencia de IDs (enteros), utilizando el tokenizer y el vocabulario. El resultado `input_ids` es una matriz de tamaño `(n_passages, sequence_length)`

con el formato:

```
[CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>
```

## DPRReaderTokenizerFast[[transformers.DPRReaderTokenizerFast]]

#### transformers.DPRReaderTokenizerFast[[transformers.DPRReaderTokenizerFast]]

```python
transformers.DPRReaderTokenizerFast(vocab: str | dict[str, int] | None = None, do_lower_case: bool = True, unk_token: str = '[UNK]', sep_token: str = '[SEP]', pad_token: str = '[PAD]', cls_token: str = '[CLS]', mask_token: str = '[MASK]', tokenize_chinese_chars: bool = True, strip_accents: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/tokenization_dpr_fast.py#L301)

**Parámetros:**

questions (`str` o `list[str]`) : Las preguntas que se van a codificar. Puede especificar una pregunta para muchos pasajes. En este caso, la pregunta se duplicará como `[questions] * n_passages`. De lo contrario, debe especificar tantas preguntas como haya en `titles` o `texts`.

titles (`str` o `list[str]`) : Los títulos de los pasajes a codificar. Puede ser una cadena o una lista de cadenas si hay varios pasajes.

texts (`str` o `list[str]`) : Los textos de los pasajes que se van a codificar. Puede ser una cadena o una lista de cadenas si hay varios pasajes.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : Activa y controla el relleno. Acepta los siguientes valores:  - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de longitudes diferentes).

truncation (`bool`, `str` o [TruncationStrategy](/docs/transformers/main/es/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, valor predeterminado `False`) : Activa y controla la truncación. Acepta los siguientes valores:  - `True` o `'longest_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token por token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_second'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `False` o `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible del modelo).

max_length (`int`, *opcional*) : Controla la longitud máxima que debe usar uno de los parámetros de truncamiento/relleno. Si se deja sin establecer o se establece en `None`, se usará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno requiere una longitud máxima. Si el modelo no tiene una longitud de entrada máxima específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará.

return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy.

return_attention_mask (`bool`, *opcional*) : Indica si se debe devolver la máscara de atención. Si no se establece, se devolverá la máscara de atención según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

**Devuelve:** `dict[str, list[list[int]]]`

Un diccionario con las siguientes claves:

- `input_ids`: Lista de ids de tokens que se enviarán a un modelo.
- `attention_mask`: Lista de índices que especifica qué tokens deben ser atendidos por el modelo.

Construye un tokenizador "fast" de DPRReader (respaldado por la biblioteca *tokenizers* de HuggingFace).

[DPRReaderTokenizerFast](/docs/transformers/main/es/model_doc/dpr#transformers.DPRReaderTokenizerFast) es casi idéntico a [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) y ejecuta la tokenización de extremo a extremo: división de puntuación y wordpiece. La diferencia es que tiene tres cadenas de entrada: question, titles y texts, que se combinan para alimentar al modelo [DPRReader](/docs/transformers/main/es/model_doc/dpr#transformers.DPRReader).

Consulte la superclase [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) para ver ejemplos de uso y documentación sobre los parámetros.

Devuelve un diccionario con los ids de tokens de las cadenas de entrada y otra información para pasar a `.decode_best_spans`. Convierte las cadenas de una pregunta y de distintos pasajes (título y texto) en una secuencia de IDs (enteros), utilizando el tokenizador y el vocabulario. El resultado `input_ids` es una matriz de tamaño `(n_passages, sequence_length)` con el siguiente formato:

[CLS]  [SEP]  [SEP]

## Salidas específicas de DPR[[transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput]]

#### transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput[[transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput]]

```python
transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput(pooler_output: Tensor, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L46)

**Parámetros:**

pooler_output (`torch.Tensor` de forma `(batch_size, embeddings_size)`) : El codificador de DPR devuelve el *pooler_output* que corresponde a la representación del contexto. Es el estado oculto de la última capa del primer token de la secuencia (token de clasificación), procesado adicionalmente por una capa Linear. Esta salida debe utilizarse para incrustar contextos para consultas de vecinos más cercanos con incrustaciones de preguntas.

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, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas de embedding iniciales opcionales.

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 después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase para las salidas de [DPRQuestionEncoder](/docs/transformers/main/es/model_doc/dpr#transformers.DPRQuestionEncoder).

#### transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput[[transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput]]

```python
transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput(pooler_output: Tensor, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L65)

**Parámetros:**

pooler_output (`torch.Tensor` de forma `(batch_size, embeddings_size)`) : El codificador de DPR devuelve el *pooler_output* que corresponde a la representación de la pregunta. Es el estado oculto de la última capa del primer token de la secuencia (token de clasificación), procesado adicionalmente por una capa Linear. Esta salida debe utilizarse para incrustar preguntas en consultas de vecinos más cercanos con incrustaciones de contexto.

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, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas de embedding iniciales opcionales.

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 después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase para las salidas de [DPRQuestionEncoder](/docs/transformers/main/es/model_doc/dpr#transformers.DPRQuestionEncoder).

#### transformers.DPRReaderOutput[[transformers.DPRReaderOutput]]

```python
transformers.DPRReaderOutput(start_logits: Tensor, end_logits: typing.Optional[torch.Tensor] = None, relevance_logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L84)

**Parámetros:**

start_logits (`torch.Tensor` de forma `(n_passages, sequence_length)`) : Logits del índice de inicio del span para cada passage.

end_logits (`torch.Tensor` de forma `(n_passages, sequence_length)`) : Logits del índice final del span para cada passage.

relevance_logits (`torch.Tensor` de forma `(n_passages, )`) : Salidas del clasificador de QA del DPRReader que corresponden a las puntuaciones de cada pasaje para responder a la pregunta, en comparación con todos los demás pasajes.

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, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas de embedding iniciales opcionales.

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 después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase para las salidas de [DPRQuestionEncoder](/docs/transformers/main/es/model_doc/dpr#transformers.DPRQuestionEncoder).

## DPRContextEncoder[[transformers.DPRContextEncoder]]

#### transformers.DPRContextEncoder[[transformers.DPRContextEncoder]]

```python
transformers.DPRContextEncoder(config: DPRConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L265)

**Parámetros:**

config ([DPRConfig](/docs/transformers/main/es/model_doc/dpr#transformers.DPRConfig)) : 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.

El transformador DPRContextEncoder básico que emite las salidas del pooler como representaciones de contexto.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L273)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Para coincidir con el preentrenamiento, la secuencia de entrada de DPR debe formatearse con los tokens [CLS] y [SEP] de la siguiente manera: (a) Para pares de secuencias (por ejemplo, un par título+texto):

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)

token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en `[0, 1]`:  - 0 corresponde a un token de *oración A*, - 1 corresponde a un token de *oración B*.  [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

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.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [DPRContextEncoderOutput](/docs/transformers/main/es/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput) o `tuple(torch.Tensor)`

Un [DPRContextEncoderOutput](/docs/transformers/main/es/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput) 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 ([DPRConfig](/docs/transformers/main/es/model_doc/dpr#transformers.DPRConfig)) y las entradas.

El método forward de [DPRContextEncoder](/docs/transformers/main/es/model_doc/dpr#transformers.DPRContextEncoder) 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.

- **pooler_output** (`torch.Tensor` de forma `(batch_size, embeddings_size)`) -- El codificador de DPR devuelve el *pooler_output* que corresponde a la representación del contexto. Es el estado oculto de la última capa del primer token de la secuencia (token de clasificación), procesado adicionalmente por una capa Linear. Esta salida debe utilizarse para incrustar contextos para consultas de vecinos más cercanos con incrustaciones de preguntas.
- **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, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **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 tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

```
tokens:         [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]
token_type_ids:   0   0  0    0    0     0       0   0   1  1  1  1   1   1
```

  (b) Para secuencias individuales (por ejemplo, para una pregunta):

```
tokens:         [CLS] the dog is hairy . [SEP]
token_type_ids:   0   0   0   0  0     0   0
```

  DPR es un modelo con incrustaciones de posición absoluta, por lo que generalmente se recomienda rellenar las entradas a la derecha en lugar de a la izquierda.

  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?](../glossary#input-ids)

Ejemplos:

```python
>>> from transformers import DPRContextEncoder, DPRContextEncoderTokenizer

>>> tokenizer = DPRContextEncoderTokenizer.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base")
>>> model = DPRContextEncoder.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base")
>>> input_ids = tokenizer("Hello, is my dog cute ?", return_tensors="pt")["input_ids"]
>>> embeddings = model(input_ids).pooler_output
```

## DPRQuestionEncoder[[transformers.DPRQuestionEncoder]]

#### transformers.DPRQuestionEncoder[[transformers.DPRQuestionEncoder]]

```python
transformers.DPRQuestionEncoder(config: DPRConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L371)

**Parámetros:**

config ([DPRConfig](/docs/transformers/main/es/model_doc/dpr#transformers.DPRConfig)) : 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.

El transformador DPRQuestionEncoder sin más, que emite las salidas del pooler como representaciones de la pregunta.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L379)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Para coincidir con el preentrenamiento, la secuencia de entrada de DPR debe formatearse con los tokens [CLS] y [SEP] de la siguiente manera: (a) Para pares de secuencias (por ejemplo, un par título+texto):

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)

token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en `[0, 1]`:  - 0 corresponde a un token de *oración A*, - 1 corresponde a un token de *oración B*.  [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

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.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [DPRQuestionEncoderOutput](/docs/transformers/main/es/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput) o `tuple(torch.Tensor)`

Un [DPRQuestionEncoderOutput](/docs/transformers/main/es/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput) 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 ([DPRConfig](/docs/transformers/main/es/model_doc/dpr#transformers.DPRConfig)) y las entradas.

El método forward de [DPRQuestionEncoder](/docs/transformers/main/es/model_doc/dpr#transformers.DPRQuestionEncoder) 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.

- **pooler_output** (`torch.Tensor` de forma `(batch_size, embeddings_size)`) -- El codificador de DPR devuelve el *pooler_output* que corresponde a la representación de la pregunta. Es el estado oculto de la última capa del primer token de la secuencia (token de clasificación), procesado adicionalmente por una capa Linear. Esta salida debe utilizarse para incrustar preguntas en consultas de vecinos más cercanos con incrustaciones de contexto.
- **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, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **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 tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

```
tokens:         [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]
token_type_ids:   0   0  0    0    0     0       0   0   1  1  1  1   1   1
```

  (b) Para secuencias individuales (por ejemplo, para una pregunta):

```
tokens:         [CLS] the dog is hairy . [SEP]
token_type_ids:   0   0   0   0  0     0   0
```

  DPR es un modelo con incrustaciones de posición absoluta, por lo que generalmente se recomienda rellenar las entradas a la derecha en lugar de a la izquierda.

  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?](../glossary#input-ids)

Ejemplos:

```python
>>> from transformers import DPRQuestionEncoder, DPRQuestionEncoderTokenizer

>>> tokenizer = DPRQuestionEncoderTokenizer.from_pretrained("facebook/dpr-question_encoder-single-nq-base")
>>> model = DPRQuestionEncoder.from_pretrained("facebook/dpr-question_encoder-single-nq-base")
>>> input_ids = tokenizer("Hello, is my dog cute ?", return_tensors="pt")["input_ids"]
>>> embeddings = model(input_ids).pooler_output
```

## DPRReader[[transformers.DPRReader]]

#### transformers.DPRReader[[transformers.DPRReader]]

```python
transformers.DPRReader(config: DPRConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L478)

**Parámetros:**

config ([DPRConfig](/docs/transformers/main/es/model_doc/dpr#transformers.DPRConfig)) : 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.

El transformador DPRReader básico que genera predicciones de fragmentos.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L486)

**Parámetros:**

input_ids (`tuple[torch.LongTensor]` de formas `(n_passages, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Debe ser una tripleta de secuencias con 1) la pregunta y 2) los títulos de los pasajes y 3) los textos de los pasajes. Para coincidir con el preentrenamiento, la secuencia `input_ids` de DPR debe formatearse con [CLS] y [SEP] con el formato:  `[CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>`  DPR es un modelo con embeddings de posición absoluta, por lo que generalmente se recomienda rellenar las entradas a la derecha en lugar de a la izquierda.  Los índices se pueden obtener usando [DPRReaderTokenizer](/docs/transformers/main/es/model_doc/dpr#transformers.DPRReaderTokenizer). Consulte la documentación de esta clase para obtener más detalles.  [¿Qué son los input IDs?](../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)

inputs_embeds (`torch.Tensor` de forma `(n_passages, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

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.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [DPRReaderOutput](/docs/transformers/main/es/model_doc/dpr#transformers.DPRReaderOutput) o `tuple(torch.Tensor)`

Un [DPRReaderOutput](/docs/transformers/main/es/model_doc/dpr#transformers.DPRReaderOutput) 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 ([DPRConfig](/docs/transformers/main/es/model_doc/dpr#transformers.DPRConfig)) y las entradas.

El método forward de [DPRReader](/docs/transformers/main/es/model_doc/dpr#transformers.DPRReader) 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.

- **start_logits** (`torch.Tensor` de forma `(n_passages, sequence_length)`) -- Logits del índice de inicio del fragmento para cada pasaje.
- **end_logits** (`torch.Tensor` de forma `(n_passages, sequence_length)`) -- Logits del índice final del tramo para cada pasaje.
- **relevance_logits** (`torch.Tensor` de forma `(n_passages, )`) -- Salidas del clasificador de QA del DPRReader que corresponden a las puntuaciones de cada pasaje para responder a la pregunta, en comparación con todos los demás pasajes.
- **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, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **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 tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplos:

```python
>>> from transformers import DPRReader, DPRReaderTokenizer

>>> tokenizer = DPRReaderTokenizer.from_pretrained("facebook/dpr-reader-single-nq-base")
>>> model = DPRReader.from_pretrained("facebook/dpr-reader-single-nq-base")
>>> encoded_inputs = tokenizer(
...     questions=["What is love ?"],
...     titles=["Haddaway"],
...     texts=["'What Is Love' is a song recorded by the artist Haddaway"],
...     return_tensors="pt",
... )
>>> outputs = model(**encoded_inputs)
>>> start_logits = outputs.start_logits
>>> end_logits = outputs.end_logits
>>> relevance_logits = outputs.relevance_logits
```