# DPR

## Ikhtisar

Dense Passage Retrieval (DPR) adalah seperangkat alat dan model untuk penelitian open-domain Q&A terkini. Diperkenalkan dalam [Dense Passage Retrieval for Open-Domain Question Answering](https://huggingface.co/papers/2004.04906) oleh Vladimir Karpukhin, Barlas Oğuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, Wen-tau Yih.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Jawaban pertanyaan domain terbuka bergantung pada pengambilan cuplikan yang efisien untuk memilih konteks kandidat, di mana model ruang vektor sparse tradisional, seperti TF-IDF atau BM25, adalah metode de facto. Dalam karya ini, kami menunjukkan bahwa pengambilan dapat diimplementasikan secara praktis hanya menggunakan representasi padat, di mana embedding dipelajari dari sejumlah kecil pertanyaan dan cuplikan oleh kerangka dual-encoder yang sederhana. Ketika dievaluasi pada berbagai dataset QA domain terbuka, retriever padat kami melampaui sistem Lucene-BM25 yang kuat secara signifikan sebesar 9%-19% absolut dalam hal akurasi pengambilan 20 cuplikan teratas, dan membantu sistem QA end-to-end kami mencapai state-of-the-art baru pada beberapa benchmark QA domain terbuka.*

Model ini disumbangkan oleh [lhoestq](https://huggingface.co/lhoestq). Kode aslinya dapat ditemukan [di sini](https://github.com/facebookresearch/DPR).

## Tips penggunaan

- DPR terdiri dari tiga model:

  * Encoder pertanyaan: mengkodekan pertanyaan sebagai vektor
  * Pengkode konteks: mengkodekan konteks sebagai vektor
  * Reader: mengekstrak jawaban dari pertanyaan di dalam konteks yang diambil, beserta skor relevansi (tinggi jika span yang disimpulkan benar-benar menjawab pertanyaan).

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

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

**Parameter:**

vocab_size (`int`, *opsional*, defaultnya `30522`) : Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh `input_ids`.

hidden_size (`int`, *opsional*, defaultnya `768`) : Dimensi dari representasi tersembunyi.

num_hidden_layers (`int`, *opsional*, defaultnya `12`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

num_attention_heads (`int`, *opsional*, defaultnya `12`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

intermediate_size (`int`, *opsional*, defaultnya `3072`) : Dimensi dari representasi MLP.

hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

hidden_dropout_prob (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler.

attention_probs_dropout_prob (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Rasio dropout untuk probabilitas perhatian.

max_position_embeddings (`int`, *opsional*, defaultnya `512`) : Panjang urutan maksimum yang mungkin digunakan oleh model ini.

type_vocab_size (`int`, *opsional*, defaultnya `2`) : Ukuran kosakata dari `token_type_ids`.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

layer_norm_eps (`float`, *opsional*, defaultnya `1e-12`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan.

pad_token_id (`int`, *opsional*, defaultnya `0`) : ID token yang digunakan untuk padding dalam kosakata.

bos_token_id (`int`, *opsional*) : ID token yang digunakan untuk awal aliran dalam kosakata.

eos_token_id (`Union[int, list[int]]`, *opsional*) : Token id yang digunakan untuk end-of-stream dalam kosakata.

projection_dim (`int`, *opsional*, defaultnya `0`) : Dimensi dari lapisan proyeksi teks dan visi.

is_decoder (`bool`, *opsional*, defaultnya `False`) : Apakah model digunakan sebagai decoder atau tidak. Jika `False`, model digunakan sebagai encoder.

add_cross_attention (`bool`, *opsional*, defaultnya `False`) : Apakah lapisan cross-attention harus ditambahkan ke model.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi DPRQuestionEncoder. Kelas ini digunakan untuk membuat model Dpr sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat konfigurasi dengan nilai default akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [facebook/dpr-ctx_encoder-single-nq-base](https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

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

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

Konstruksi tokenizer DPRContextEncoder.

[DPRContextEncoderTokenizer](/docs/transformers/main/id/model_doc/dpr#transformers.DPRContextEncoderTokenizer) identik dengan [BertTokenizer](/docs/transformers/main/id/model_doc/lxmert#transformers.BertTokenizer) dan menjalankan tokenisasi end-to-end: pemisahan tanda baca dan wordpiece.

Lihat kelas induk [BertTokenizer](/docs/transformers/main/id/model_doc/lxmert#transformers.BertTokenizer) untuk contoh penggunaan dan dokumentasi mengenai parameter.

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

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

Konstruksi tokenizer "fast" DPRContextEncoder (didukung oleh pustaka *tokenizers* dari HuggingFace).

[DPRContextEncoderTokenizerFast](/docs/transformers/main/id/model_doc/dpr#transformers.DPRContextEncoderTokenizerFast) identik dengan [BertTokenizer](/docs/transformers/main/id/model_doc/lxmert#transformers.BertTokenizer) dan menjalankan tokenisasi end-to-end: pemisahan tanda baca dan wordpiece.

Lihat kelas induk [BertTokenizer](/docs/transformers/main/id/model_doc/lxmert#transformers.BertTokenizer) untuk contoh penggunaan dan dokumentasi mengenai parameter.

## DPRQuestionEncoderTokenizer[[transformers.DPRQuestionEncoderTokenizer]]

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

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

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

Membangun tokenizer DPRQuestionEncoder.

[DPRQuestionEncoderTokenizer](/docs/transformers/main/id/model_doc/dpr#transformers.DPRQuestionEncoderTokenizer) identik dengan [BertTokenizer](/docs/transformers/main/id/model_doc/lxmert#transformers.BertTokenizer) dan menjalankan tokenisasi dari awal hingga akhir: pemisahan tanda baca dan wordpiece.

Lihat kelas induk [BertTokenizer](/docs/transformers/main/id/model_doc/lxmert#transformers.BertTokenizer) untuk contoh penggunaan dan dokumentasi mengenai parameter.

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

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

Membuat tokenizer DPRQuestionEncoder "cepat" (didukung oleh pustaka *tokenizers* dari HuggingFace).

[DPRQuestionEncoderTokenizerFast](/docs/transformers/main/id/model_doc/dpr#transformers.DPRQuestionEncoderTokenizerFast) identik dengan [BertTokenizer](/docs/transformers/main/id/model_doc/lxmert#transformers.BertTokenizer) dan menjalankan tokenisasi dari awal hingga akhir: pemisahan tanda baca dan wordpiece.

Lihat kelas induk [BertTokenizer](/docs/transformers/main/id/model_doc/lxmert#transformers.BertTokenizer) untuk contoh penggunaan dan dokumentasi mengenai parameter.

## DPRReaderTokenizer[[transformers.DPRReaderTokenizer]]

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

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

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

**Parameter:**

questions (`str` atau `list[str]`) : Pertanyaan yang akan dienkod. Anda dapat menentukan satu pertanyaan untuk banyak paragraf. Dalam kasus ini, pertanyaan akan diduplikasi seperti `[questions] * n_passages`. Sebaliknya, Anda harus menentukan sebanyak pertanyaan yang ada di `titles` atau `texts`.

titles (`str` atau `list[str]`) : Judul paragraf yang akan dienkod. Ini bisa berupa string atau daftar string jika ada beberapa paragraf.

texts (`str` atau `list[str]`) : Teks paragraf yang akan dienkod. Ini bisa berupa string atau daftar string jika ada beberapa paragraf.

padding (`bool`, `str` atau [PaddingStrategy](/docs/transformers/main/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, defaultnya `False`) : Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:  - `True` atau `'longest'`: Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan). - `'max_length'`: Pad hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. - `False` atau `'do_not_pad'` (default): Tanpa padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda-beda).

truncation (`bool`, `str` atau [TruncationStrategy](/docs/transformers/main/id/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opsional*, default `False`) : Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:  - `True` atau `'longest_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini akan memotong per token, dengan menghapus satu token dari urutan terpanjang dalam pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan pertama dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_second'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan kedua dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `False` atau `'do_not_truncate'` (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang urutan yang melebihi ukuran input maksimum yang diizinkan oleh model).

max_length (`int`, *opsional*) : Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding. Jika tidak disetel atau disetel ke `None`, ini akan menggunakan panjang maksimum model yang telah ditentukan sebelumnya jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum yang spesifik (seperti XLNet), truncation/padding ke panjang maksimum akan dinonaktifkan.

return_tensors (`str` atau [TensorType](/docs/transformers/main/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor alih-alih daftar bilangan bulat python. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` Numpy.

return_attention_mask (`bool`, *opsional*) : Apakah akan mengembalikan attention mask atau tidak. Jika tidak diatur, attention mask akan dikembalikan sesuai dengan default tokenizer spesifik, yang didefinisikan oleh atribut `return_outputs`.  [Apa itu attention mask?](../glossary#attention-mask)

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

Kamus dengan kunci-kunci berikut:

- `input_ids`: Daftar id token yang akan diberikan ke model.
- `attention_mask`: Daftar indeks yang menentukan token mana yang harus diperhatikan oleh model.

Konstruksi tokenizer DPRReader.

[DPRReaderTokenizer](/docs/transformers/main/id/model_doc/dpr#transformers.DPRReaderTokenizer) hampir identik dengan [BertTokenizer](/docs/transformers/main/id/model_doc/lxmert#transformers.BertTokenizer) dan menjalankan tokenisasi dari awal hingga akhir: pemisahan tanda baca dan wordpiece. Perbedaannya adalah bahwa tokenizer ini memiliki tiga string input: question, titles, dan texts yang digabungkan untuk diberikan ke model [DPRReader](/docs/transformers/main/id/model_doc/dpr#transformers.DPRReader).

Lihat kelas induk [BertTokenizer](/docs/transformers/main/id/model_doc/lxmert#transformers.BertTokenizer) untuk contoh penggunaan dan dokumentasi mengenai parameter.

Kembalikan sebuah dictionary berisi token id dari string input dan informasi lain untuk diberikan ke `.decode_best_spans`. Metode ini mengonversi string dari sebuah pertanyaan dan berbagai passage (judul dan teks) menjadi urutan ID (bilangan bulat), menggunakan tokenizer dan vocabulary. Hasil `input_ids` adalah matriks berukuran `(n_passages, sequence_length)`

dengan format:

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

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

**Parameter:**

questions (`str` atau `list[str]`) : Pertanyaan yang akan dienkod. Anda dapat menentukan satu pertanyaan untuk banyak paragraf. Dalam kasus ini, pertanyaan akan diduplikasi seperti `[questions] * n_passages`. Sebaliknya, Anda harus menentukan sebanyak pertanyaan yang ada di `titles` atau `texts`.

titles (`str` atau `list[str]`) : Judul paragraf yang akan dienkod. Ini bisa berupa string atau daftar string jika ada beberapa paragraf.

texts (`str` atau `list[str]`) : Teks paragraf yang akan dienkod. Ini bisa berupa string atau daftar string jika ada beberapa paragraf.

padding (`bool`, `str` atau [PaddingStrategy](/docs/transformers/main/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, defaultnya `False`) : Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:  - `True` atau `'longest'`: Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan). - `'max_length'`: Pad hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. - `False` atau `'do_not_pad'` (default): Tanpa padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda-beda).

truncation (`bool`, `str` atau [TruncationStrategy](/docs/transformers/main/id/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opsional*, default `False`) : Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:  - `True` atau `'longest_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini akan memotong per token, dengan menghapus satu token dari urutan terpanjang dalam pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan pertama dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_second'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan kedua dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `False` atau `'do_not_truncate'` (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang urutan yang melebihi ukuran input maksimum yang diizinkan oleh model).

max_length (`int`, *opsional*) : Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding. Jika tidak disetel atau disetel ke `None`, ini akan menggunakan panjang maksimum model yang telah ditentukan sebelumnya jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum yang spesifik (seperti XLNet), truncation/padding ke panjang maksimum akan dinonaktifkan.

return_tensors (`str` atau [TensorType](/docs/transformers/main/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor alih-alih daftar bilangan bulat python. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` Numpy.

return_attention_mask (`bool`, *opsional*) : Apakah akan mengembalikan attention mask atau tidak. Jika tidak diatur, attention mask akan dikembalikan sesuai dengan default tokenizer spesifik, yang didefinisikan oleh atribut `return_outputs`.  [Apa itu attention mask?](../glossary#attention-mask)

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

Kamus dengan kunci-kunci berikut:

- `input_ids`: Daftar id token yang akan diberikan ke model.
- `attention_mask`: Daftar indeks yang menentukan token mana yang harus diperhatikan oleh model.

Membuat tokenizer DPRReader "cepat" (didukung oleh pustaka *tokenizers* dari HuggingFace).

[DPRReaderTokenizerFast](/docs/transformers/main/id/model_doc/dpr#transformers.DPRReaderTokenizerFast) hampir identik dengan [BertTokenizer](/docs/transformers/main/id/model_doc/lxmert#transformers.BertTokenizer) dan menjalankan tokenisasi dari awal hingga akhir: pemisahan tanda baca dan wordpiece. Perbedaannya adalah bahwa tokenizer ini memiliki tiga string input: question, titles, dan texts yang digabungkan untuk diberikan ke model [DPRReader](/docs/transformers/main/id/model_doc/dpr#transformers.DPRReader).

Lihat kelas induk [BertTokenizer](/docs/transformers/main/id/model_doc/lxmert#transformers.BertTokenizer) untuk contoh penggunaan dan dokumentasi mengenai parameter.

Kembalikan sebuah dictionary berisi token id dari string input dan informasi lain untuk diberikan ke `.decode_best_spans`. Fungsi ini mengonversi string dari sebuah pertanyaan dan berbagai passage (judul dan teks) menjadi urutan ID (bilangan bulat), menggunakan tokenizer dan vocabulary. Hasil `input_ids` adalah matriks berukuran `(n_passages, sequence_length)` dengan format:

[CLS] [SEP] [SEP]

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

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

**Parameter:**

pooler_output (`torch.Tensor` dengan bentuk `(batch_size, embeddings_size)`) : Encoder DPR menghasilkan *pooler_output* yang sesuai dengan representasi konteks. Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) yang diproses lebih lanjut oleh lapisan Linear. Output ini digunakan untuk menyematkan konteks untuk kueri tetangga terdekat dengan embeddings pertanyaan.

hidden_states (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) : Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states dari model pada output setiap lapisan ditambah output embedding awal yang opsional.

attentions (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan saat `output_attentions=True` dilewatkan atau saat `config.output_attentions=True`) : Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Kelas untuk output dari [DPRQuestionEncoder](/docs/transformers/main/id/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)
```

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

**Parameter:**

pooler_output (`torch.Tensor` dengan bentuk `(batch_size, embeddings_size)`) : Encoder DPR menghasilkan *pooler_output* yang sesuai dengan representasi pertanyaan. Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) yang diproses lebih lanjut oleh lapisan Linear. Output ini digunakan untuk menyematkan pertanyaan untuk kueri tetangga terdekat dengan embeddings konteks.

hidden_states (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) : Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states model pada output dari setiap lapisan ditambah output embedding awal yang opsional.

attentions (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan saat `output_attentions=True` dilewatkan atau saat `config.output_attentions=True`) : Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Kelas untuk output dari [DPRQuestionEncoder](/docs/transformers/main/id/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)
```

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

**Parameter:**

start_logits (`torch.Tensor` dengan bentuk `(n_passages, sequence_length)`) : Logits dari indeks awal span untuk setiap passage.

end_logits (`torch.Tensor` dengan bentuk `(n_passages, sequence_length)`) : Logits dari indeks akhir span untuk setiap passage.

relevance_logits (`torch.Tensor` dengan bentuk `(n_passages, )`) : Output dari QA classifier pada DPRReader yang sesuai dengan skor setiap passage untuk menjawab pertanyaan, dibandingkan dengan semua passage lainnya.

hidden_states (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) : Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states dari model pada output setiap lapisan ditambah output embedding awal yang opsional.

attentions (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) : Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Kelas untuk output dari [DPRQuestionEncoder](/docs/transformers/main/id/model_doc/dpr#transformers.DPRQuestionEncoder).

## DPRContextEncoder[[transformers.DPRContextEncoder]]

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

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

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

**Parameter:**

config ([DPRConfig](/docs/transformers/main/id/model_doc/dpr#transformers.DPRConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Transformer DPRContextEncoder polos yang menghasilkan keluaran pooler sebagai representasi konteks.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

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

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

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. Untuk sesuai dengan pra-pelatihan, urutan input DPR harus diformat dengan token [CLS] dan [SEP] sebagai berikut: (a) Untuk pasangan urutan (misalnya untuk pasangan judul+teks):

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

token_type_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token segmen untuk menunjukkan bagian pertama dan kedua dari input. Indeks dipilih dalam `[0, 1]`:  - 0 sesuai dengan token *sentence A*, - 1 sesuai dengan token *sentence B*.  [Apa itu token type IDs?](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** [DPRContextEncoderOutput](/docs/transformers/main/id/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput) atau `tuple(torch.Tensor)`

Sebuah [DPRContextEncoderOutput](/docs/transformers/main/id/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DPRConfig](/docs/transformers/main/id/model_doc/dpr#transformers.DPRConfig)) dan input.

Metode forward dari [DPRContextEncoder](/docs/transformers/main/id/model_doc/dpr#transformers.DPRContextEncoder) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **pooler_output** (`torch.Tensor` dengan bentuk `(batch_size, embeddings_size)`) -- Encoder DPR menghasilkan *pooler_output* yang sesuai dengan representasi konteks. Hidden-state dari lapisan terakhir untuk token pertama dalam urutan (token klasifikasi) yang kemudian diproses lebih lanjut oleh lapisan Linear. Output ini digunakan untuk menyematkan konteks untuk kueri tetangga terdekat dengan embeddings pertanyaan.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

```
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) Untuk urutan tunggal (misalnya untuk sebuah pertanyaan):

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

  DPR adalah model dengan penanam posisi absolut sehingga biasanya disarankan untuk mengisi input di sisi kanan, bukan di sisi kiri.

  Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/main/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya.

  [Apa itu input ID?](../glossary#input-ids)

Contoh:

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

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

**Parameter:**

config ([DPRConfig](/docs/transformers/main/id/model_doc/dpr#transformers.DPRConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Transformer DPRQuestionEncoder polos yang menghasilkan keluaran pooler sebagai representasi pertanyaan.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

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

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

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. Untuk sesuai dengan pra-pelatihan, urutan input DPR harus diformat dengan token [CLS] dan [SEP] sebagai berikut: (a) Untuk pasangan urutan (misalnya untuk pasangan judul+teks):

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

token_type_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token segmen untuk menunjukkan bagian pertama dan kedua dari input. Indeks dipilih dalam `[0, 1]`:  - 0 sesuai dengan token *sentence A*, - 1 sesuai dengan token *sentence B*.  [Apa itu token type IDs?](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** [DPRQuestionEncoderOutput](/docs/transformers/main/id/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput) atau `tuple(torch.Tensor)`

[DPRQuestionEncoderOutput](/docs/transformers/main/id/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DPRConfig](/docs/transformers/main/id/model_doc/dpr#transformers.DPRConfig)) dan input.

Metode forward dari [DPRQuestionEncoder](/docs/transformers/main/id/model_doc/dpr#transformers.DPRQuestionEncoder) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **pooler_output** (`torch.Tensor` dengan bentuk `(batch_size, embeddings_size)`) -- Encoder DPR menghasilkan *pooler_output* yang sesuai dengan representasi pertanyaan. Hidden-state dari lapisan terakhir untuk token pertama dalam urutan (token klasifikasi) yang kemudian diproses oleh lapisan Linear. Output ini digunakan untuk menyematkan pertanyaan guna kueri tetangga terdekat dengan embeddings konteks.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

```
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) Untuk urutan tunggal (misalnya untuk sebuah pertanyaan):

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

  DPR adalah model dengan penanam posisi absolut sehingga biasanya disarankan untuk mengisi input di sisi kanan, bukan di sisi kiri.

  Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/main/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya.

  [Apa itu input ID?](../glossary#input-ids)

Contoh:

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

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

**Parameter:**

config ([DPRConfig](/docs/transformers/main/id/model_doc/dpr#transformers.DPRConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Transformer DPRReader polos yang menghasilkan prediksi span.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

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

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

**Parameter:**

input_ids (`tuple[torch.LongTensor]` dengan bentuk `(n_passages, sequence_length)`) : Indeks token dari urutan input dalam kosakata. Ini harus berupa triplet urutan dengan 1) pertanyaan dan 2) judul passage serta 3) teks passage. Untuk sesuai dengan pra-pelatihan, urutan `input_ids` DPR harus diformat dengan [CLS] dan [SEP] dengan format:  `[CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>`  DPR adalah model dengan embedding posisi absolut, sehingga biasanya disarankan untuk melakukan padding input di sisi kanan, bukan di sisi kiri.  Indeks dapat diperoleh menggunakan [DPRReaderTokenizer](/docs/transformers/main/id/model_doc/dpr#transformers.DPRReaderTokenizer). Lihat dokumentasi kelas ini untuk detail lebih lanjut.  [Apa itu input IDs?](../glossary#input-ids)

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor` dengan bentuk `(n_passages, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait, dibandingkan dengan matriks pencarian embedding internal model.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** [DPRReaderOutput](/docs/transformers/main/id/model_doc/dpr#transformers.DPRReaderOutput) atau `tuple(torch.Tensor)`

[DPRReaderOutput](/docs/transformers/main/id/model_doc/dpr#transformers.DPRReaderOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DPRConfig](/docs/transformers/main/id/model_doc/dpr#transformers.DPRConfig)) dan input.

Metode forward dari [DPRReader](/docs/transformers/main/id/model_doc/dpr#transformers.DPRReader) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **start_logits** (`torch.Tensor` dengan bentuk `(n_passages, sequence_length)`) -- Logits dari indeks awal span untuk setiap passage.
- **end_logits** (`torch.Tensor` dengan bentuk `(n_passages, sequence_length)`) -- Logits dari indeks akhir span untuk setiap passage.
- **relevance_logits** (`torch.Tensor` dengan bentuk `(n_passages, )`) -- Output dari QA classifier pada DPRReader yang sesuai dengan skor setiap passage untuk menjawab pertanyaan, dibandingkan dengan semua passage lainnya.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:

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