# DPR

## Visão geral

Dense Passage Retrieval (DPR) é um conjunto de ferramentas e modelos para pesquisa de ponta em Q&A de domínio aberto. Foi introduzido em [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.

O resumo do artigo é o seguinte:

*A resposta a perguntas em domínio aberto depende de uma recuperação eficiente de trechos para selecionar contextos candidatos, em que modelos tradicionais de espaço vetorial esparsos, como TF-IDF ou BM25, são o método de fato. Neste trabalho, mostramos que a recuperação pode ser implementada na prática usando apenas representações densas, em que os embeddings são aprendidos a partir de um pequeno número de perguntas e trechos por meio de um framework simples de dual-encoder. Ao ser avaliado em uma ampla variedade de conjuntos de dados de QA em domínio aberto, nosso recuperador denso supera um sistema Lucene-BM25 forte em grande medida, com uma diferença absoluta de 9%-19% em termos de precisão de recuperação dos 20 melhores trechos, e ajuda nosso sistema de QA de ponta a ponta a estabelecer novos state-of-the-art em múltiplos benchmarks de QA em domínio aberto.*

Este modelo foi contribuído por [lhoestq](https://huggingface.co/lhoestq). O código original pode ser encontrado [aqui](https://github.com/facebookresearch/DPR).

## Dicas de uso

- O DPR consiste em três modelos:

  * Codificador de perguntas: codifique perguntas como vetores
  * Codificador de contexto: codifique contextos como vetores
  * Leitor: extrai a resposta das perguntas nos contextos recuperados, juntamente com uma pontuação de relevância (alta se o trecho inferido realmente responde à pergunta).

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

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

**Parâmetros:**

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

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

num_hidden_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer.

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

intermediate_size (`int`, *opcional*, padrão `3072`) : Dimensão das representações do MLP.

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

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

attention_probs_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.1`) : A taxa de dropout para as probabilidades de atenção.

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

type_vocab_size (`int`, *opcional*, padrão `2`) : O tamanho do vocabulário dos `token_type_ids`.

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

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

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

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

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

projection_dim (`int`, *opcional*, padrão `0`) : Dimensionalidade das camadas de projeção de texto e visão.

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

add_cross_attention (`bool`, *opcional*, padrão `False`) : Se as camadas de atenção cruzada devem ser adicionadas ao modelo.

Esta é a classe de configuração para armazenar a configuração de um DPRQuestionEncoder. Ela é usada para instanciar um modelo Dpr de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [facebook/dpr-ctx_encoder-single-nq-base](https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

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

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

Construa um tokenizer DPRContextEncoder.

[DPRContextEncoderTokenizer](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRContextEncoderTokenizer) é idêntico ao [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) e executa a tokenização de ponta a ponta: divisão de pontuação e wordpiece.

Consulte a superclasse [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) para exemplos de uso e documentação sobre os 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)
```

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

Construa um tokenizer "fast" do DPRContextEncoder (baseado na biblioteca *tokenizers* do HuggingFace).

[DPRContextEncoderTokenizerFast](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRContextEncoderTokenizerFast) é idêntico ao [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) e executa a tokenização de ponta a ponta: divisão de pontuação e wordpiece.

Consulte a superclasse [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) para exemplos de uso e documentação sobre os parâmetros.

## DPRQuestionEncoderTokenizer[[transformers.DPRQuestionEncoderTokenizer]]

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

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

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

Constrói um tokenizer DPRQuestionEncoder.

[DPRQuestionEncoderTokenizer](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRQuestionEncoderTokenizer) é idêntico ao [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) e executa a tokenização de ponta a ponta: divisão de pontuação e wordpiece.

Consulte a superclasse [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) para exemplos de uso e documentação sobre os 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)
```

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

Constrói um tokenizador "fast" DPRQuestionEncoder (baseado na biblioteca *tokenizers* do HuggingFace).

[DPRQuestionEncoderTokenizerFast](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRQuestionEncoderTokenizerFast) é idêntico ao [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) e executa a tokenização de ponta a ponta: divisão de pontuação e wordpiece.

Consulte a superclasse [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) para exemplos de uso e documentação sobre os parâmetros.

## DPRReaderTokenizer[[transformers.DPRReaderTokenizer]]

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

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

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

**Parâmetros:**

questions (`str` ou `list[str]`) : As perguntas a serem codificadas. Você pode especificar uma pergunta para muitas passagens. Nesse caso, a pergunta será duplicada como `[questions] * n_passages`. Caso contrário, você deve especificar tantas perguntas quanto em `titles` ou `texts`.

titles (`str` ou `list[str]`) : Os títulos das passagens a serem codificados. Isso pode ser uma string ou uma lista de strings, caso haja várias passagens.

texts (`str` ou `list[str]`) : Os textos das passagens a serem codificados. Pode ser uma string ou uma lista de strings, caso haja várias passagens.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Ativa e controla o padding. Aceita os seguintes valores:  - `True` ou `'longest'`: Preenche até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Preenche até o comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).

truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, padrão `False`) : Ativa e controla a truncagem. Aceita os seguintes valores:  - `True` ou `'longest_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_second'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `False` ou `'do_not_truncate'` (padrão): Sem truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissível do modelo).

max_length (`int`, *opcional*) : Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento. Se não for definido ou for definido como `None`, será usado o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento até um comprimento máximo será desativado.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de lista de inteiros do Python. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do Numpy.

return_attention_mask (`bool`, *opcional*) : Indica se a máscara de atenção deve ser retornada ou não. Se não for definido, a máscara de atenção será retornada de acordo com o padrão específico do tokenizador, definido pelo atributo `return_outputs`.  [O que são máscaras de atenção?](../glossary#attention-mask)

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

Um dicionário com as seguintes chaves:

- `input_ids`: Lista de ids de tokens a serem fornecidos a um modelo.
- `attention_mask`: Lista de índices que especifica quais tokens devem ser considerados pelo modelo.

Construa um tokenizer DPRReader.

[DPRReaderTokenizer](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRReaderTokenizer) é quase idêntico ao [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) e executa a tokenização de ponta a ponta: divisão de pontuação e wordpiece. A diferença é que ele possui três strings de entrada: question, titles e texts, que são combinadas para serem fornecidas ao modelo [DPRReader](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRReader).

Consulte a superclasse [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) para exemplos de uso e documentação sobre os parâmetros.

Retorna um dicionário com os ids dos tokens das strings de entrada e outras informações para passar a `.decode_best_spans`. Ele converte as strings de uma pergunta e de diferentes passagens (título e texto) em uma sequência de IDs (inteiros), usando o tokenizer e o vocabulário. O `input_ids` resultante é uma matriz de tamanho `(n_passages, sequence_length)`

com o 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)
```

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

**Parâmetros:**

questions (`str` ou `list[str]`) : As perguntas a serem codificadas. Você pode especificar uma pergunta para muitas passagens. Nesse caso, a pergunta será duplicada como `[questions] * n_passages`. Caso contrário, você deve especificar tantas perguntas quanto em `titles` ou `texts`.

titles (`str` ou `list[str]`) : Os títulos das passagens a serem codificados. Isso pode ser uma string ou uma lista de strings, caso haja várias passagens.

texts (`str` ou `list[str]`) : Os textos das passagens a serem codificados. Pode ser uma string ou uma lista de strings, caso haja várias passagens.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Ativa e controla o padding. Aceita os seguintes valores:  - `True` ou `'longest'`: Preenche até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Preenche até o comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).

truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, padrão `False`) : Ativa e controla a truncagem. Aceita os seguintes valores:  - `True` ou `'longest_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_second'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `False` ou `'do_not_truncate'` (padrão): Sem truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissível do modelo).

max_length (`int`, *opcional*) : Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento. Se não for definido ou for definido como `None`, será usado o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento até um comprimento máximo será desativado.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de lista de inteiros do Python. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do Numpy.

return_attention_mask (`bool`, *opcional*) : Indica se a máscara de atenção deve ser retornada ou não. Se não for definido, a máscara de atenção será retornada de acordo com o padrão específico do tokenizador, definido pelo atributo `return_outputs`.  [O que são máscaras de atenção?](../glossary#attention-mask)

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

Um dicionário com as seguintes chaves:

- `input_ids`: Lista de ids de tokens a serem fornecidos a um modelo.
- `attention_mask`: Lista de índices que especifica quais tokens devem ser considerados pelo modelo.

Constrói um tokenizador "fast" do DPRReader (baseado na biblioteca *tokenizers* do HuggingFace).

[DPRReaderTokenizerFast](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRReaderTokenizerFast) é quase idêntico ao [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) e executa a tokenização de ponta a ponta: divisão de pontuação e wordpiece. A diferença é que ele possui três strings de entrada: question, titles e texts, que são combinadas para serem fornecidas ao modelo [DPRReader](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRReader).

Consulte a superclasse [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) para exemplos de uso e documentação sobre os parâmetros.

Retorna um dicionário com os ids dos tokens das strings de entrada e outras informações para passar a `.decode_best_spans`. Ele converte as strings de uma pergunta e de diferentes passagens (título e texto) em uma sequência de IDs (inteiros), usando o tokenizer e o vocabulário. O `input_ids` resultante é uma matriz de tamanho `(n_passages, sequence_length)` com o formato:

[CLS]  [SEP]  [SEP]

## Saídas específicas do 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)
```

[Origem](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)`) : O codificador DPR produz o *pooler_output* que corresponde à representação do contexto. Estado oculto da última camada do primeiro token da sequência (token de classificação) processado adicionalmente por uma camada Linear. Esta saída deve ser usada para incorporar contextos para consultas de vizinhos mais próximos com incorporações de perguntas.

hidden_states (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings.

attentions (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Classe para as saídas de [DPRQuestionEncoder](/docs/transformers/main/pt/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)
```

[Origem](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)`) : O codificador do DPR produz o *pooler_output* que corresponde à representação da pergunta. Estado oculto da última camada do primeiro token da sequência (token de classificação) processado adicionalmente por uma camada Linear. Esta saída deve ser usada para incorporar perguntas para consultas de vizinhos mais próximos com incorporações de contexto.

hidden_states (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings.

attentions (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Classe para as saídas de [DPRQuestionEncoder](/docs/transformers/main/pt/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)
```

[Origem](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 do índice inicial do trecho para cada passagem.

end_logits (`torch.Tensor` de forma `(n_passages, sequence_length)`) : Logits do índice final do trecho para cada passagem.

relevance_logits (`torch.Tensor` de forma `(n_passages, )`) : Saídas do classificador de QA do DPRReader que correspondem às pontuações de cada passagem para responder à pergunta, em comparação com todas as outras passagens.

hidden_states (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings.

attentions (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Classe para as saídas de [DPRQuestionEncoder](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRQuestionEncoder).

## DPRContextEncoder[[transformers.DPRContextEncoder]]

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

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

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

**Parâmetros:**

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

O transformador DPRContextEncoder puro, que produz as saídas do pooler como representações de contexto.

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

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

#### forward[[transformers.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)
```

[Origem](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 dos tokens da sequência de entrada no vocabulário. Para corresponder ao pré-treinamento, a sequência de entrada do DPR deve ser formatada com os tokens [CLS] e [SEP] da seguinte forma:  (a) Para pares de sequências (por exemplo, um par título+texto):

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [DPRContextEncoderOutput](/docs/transformers/main/pt/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput) ou `tuple(torch.Tensor)`

Um [DPRContextEncoderOutput](/docs/transformers/main/pt/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([DPRConfig](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRConfig)) e das entradas.

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

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

- **pooler_output** (`torch.Tensor` de forma `(batch_size, embeddings_size)`) -- O codificador DPR produz o *pooler_output* que corresponde à representação do contexto. Estado oculto da última camada do primeiro token da sequência (token de classificação) processado adicionalmente por uma camada Linear. Esta saída deve ser usada para incorporar contextos para consultas de vizinhos mais próximos com incorporações de perguntas.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

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

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

```
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 sequências únicas (por exemplo, para uma pergunta):

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

  O DPR é um modelo com embeddings de posição absoluta, portanto, geralmente é recomendado preencher os inputs à direita em vez da esquerda.

  Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes.

  [O que são IDs de entrada?](../glossary#input-ids)

Exemplos:

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

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

**Parâmetros:**

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

O transformador DPRQuestionEncoder puro, que produz saídas do pooler como representações de perguntas.

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

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

#### forward[[transformers.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)
```

[Origem](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 dos tokens da sequência de entrada no vocabulário. Para corresponder ao pré-treinamento, a sequência de entrada do DPR deve ser formatada com os tokens [CLS] e [SEP] da seguinte forma:  (a) Para pares de sequências (por exemplo, um par título+texto):

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [DPRQuestionEncoderOutput](/docs/transformers/main/pt/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput) ou `tuple(torch.Tensor)`

Um [DPRQuestionEncoderOutput](/docs/transformers/main/pt/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([DPRConfig](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRConfig)) e das entradas.

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

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

- **pooler_output** (`torch.Tensor` de forma `(batch_size, embeddings_size)`) -- O codificador DPR produz o *pooler_output* que corresponde à representação da pergunta. Estado oculto da última camada do primeiro token da sequência (token de classificação) processado adicionalmente por uma camada Linear. Esta saída deve ser usada para incorporar perguntas para consultas de vizinhos mais próximos com incorporações de contexto.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

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

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

```
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 sequências únicas (por exemplo, para uma pergunta):

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

  O DPR é um modelo com embeddings de posição absoluta, portanto, geralmente é recomendado preencher os inputs à direita em vez da esquerda.

  Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes.

  [O que são IDs de entrada?](../glossary#input-ids)

Exemplos:

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

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

**Parâmetros:**

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

O transformador DPRReader puro que gera previsões de trechos.

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

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

#### forward[[transformers.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)
```

[Origem](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 dos tokens da sequência de entrada no vocabulário. Deve ser uma tríade de sequências contendo 1) a pergunta, 2) os títulos das passagens e 3) os textos das passagens. Para corresponder ao pré-treinamento, a sequência `input_ids` do DPR deve ser formatada com [CLS] e [SEP] no formato:  `[CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>`  O DPR é um modelo com embeddings de posição absoluta, portanto, geralmente é recomendado preencher as entradas à direita em vez da esquerda.  Os índices podem ser obtidos usando [DPRReaderTokenizer](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRReaderTokenizer). Consulte a documentação desta classe para mais detalhes.  [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor` de forma `(n_passages, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [DPRReaderOutput](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRReaderOutput) ou `tuple(torch.Tensor)`

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

O método forward do [DPRReader](/docs/transformers/main/pt/model_doc/dpr#transformers.DPRReader) sobrescreve o método especial `__call__`.

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

- **start_logits** (`torch.Tensor` de forma `(n_passages, sequence_length)`) -- Logits do índice inicial do trecho para cada passagem.
- **end_logits** (`torch.Tensor` de forma `(n_passages, sequence_length)`) -- Logits do índice final do trecho para cada passagem.
- **relevance_logits** (`torch.Tensor` de forma `(n_passages, )`) -- Saídas do classificador de QA do DPRReader que correspondem às pontuações de cada passagem para responder à pergunta, em comparação com todas as outras passagens.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

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

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

Exemplos:

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