# DAB-DETR

## Ikhtisar

Model DAB-DETR diusulkan dalam [DAB-DETR: Dynamic Anchor Boxes are Better Queries for DETR](https://huggingface.co/papers/2201.12329) oleh Shilong Liu, Feng Li, Hao Zhang, Xiao Yang, Xianbiao Qi, Hang Su, Jun Zhu, Lei Zhang. DAB-DETR adalah varian yang ditingkatkan dari Conditional DETR. Model ini memanfaatkan kotak jangkar yang diperbarui secara dinamis untuk menyediakan titik query referensi (x, y) dan ukuran jangkar referensi (w, h), sehingga meningkatkan komputasi cross-attention. Pendekatan baru ini mencapai 45,7% AP ketika dilatih selama 50 epoch dengan satu model ResNet-50 sebagai backbone.

<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/dab_detr_convergence_plot.png"
alt="drawing" width="600"/>

Abstrak dari makalah tersebut adalah sebagai berikut:

*Kami menyajikan formulasi query baru yang menggunakan kotak jangkar dinamis untuk DETR (DEtection TRansformer) dalam makalah ini, serta menawarkan pemahaman yang lebih mendalam tentang peran query dalam DETR. Formulasi baru ini secara langsung menggunakan koordinat kotak sebagai query dalam decoder Transformer dan memperbaruinya secara dinamis per lapisan. Penggunaan koordinat kotak tidak hanya membantu memanfaatkan prior posisional eksplisit untuk meningkatkan kemiripan query-ke-fitur dan menghilangkan masalah konvergensi pelatihan yang lambat pada DETR, tetapi juga memungkinkan kami untuk memodulasi peta perhatian posisional menggunakan informasi lebar dan tinggi kotak. Desain semacam ini membuat jelas bahwa query dalam DETR dapat diimplementasikan sebagai lapisan soft ROI pooling yang dilakukan per lapisan secara berjenjang. Akibatnya, hal ini menghasilkan kinerja terbaik pada benchmark MS-COCO di antara model deteksi serupa DETR dengan pengaturan yang sama, misalnya AP 45,7% menggunakan ResNet50-DC5 sebagai backbone yang dilatih selama 50 epoch. Kami juga melakukan eksperimen yang luas untuk mengonfirmasi analisis kami dan memverifikasi efektivitas metode kami.*

Model ini disumbangkan oleh [davidhajdu](https://huggingface.co/davidhajdu). Kode aslinya dapat ditemukan [di sini](https://github.com/IDEA-Research/DAB-DETR).

## Cara Memulai dengan Model

Gunakan kode di bawah untuk memulai dengan model.

```python
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, AutoModelForObjectDetection

url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
image = Image.open(requests.get(url, stream=True).raw)

image_processor = AutoImageProcessor.from_pretrained("IDEA-Research/dab-detr-resnet-50")
model = AutoModelForObjectDetection.from_pretrained("IDEA-Research/dab-detr-resnet-50", device_map="auto")

inputs = image_processor(images=image, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

results = image_processor.post_process_object_detection(outputs, target_sizes=torch.tensor([image.size[::-1]]), threshold=0.3)

for result in results:
    for score, label_id, box in zip(result["scores"], result["labels"], result["boxes"]):
        score, label = score.item(), label_id.item()
        box = [round(i, 2) for i in box.tolist()]
        print(f"{model.config.id2label[label]}: {score:.2f} {box}")
```

Ini seharusnya menghasilkan

```text
cat: 0.87 [14.7, 49.39, 320.52, 469.28]
remote: 0.86 [41.08, 72.37, 173.39, 117.2]
cat: 0.86 [344.45, 19.43, 639.85, 367.86]
remote: 0.61 [334.27, 75.93, 367.92, 188.81]
couch: 0.59 [-0.04, 1.34, 639.9, 477.09]
```

Terdapat tiga cara lain untuk menginstansiasi model DAB-DETR (tergantung pada preferensi Anda):

Opsi 1: Instansiasi DAB-DETR dengan bobot terlatih sebelumnya untuk seluruh model

```python
from transformers import DabDetrForObjectDetection

model = DabDetrForObjectDetection.from_pretrained("IDEA-Research/dab-detr-resnet-50", device_map="auto")
```

Opsi 2: Instansiasi DAB-DETR dengan bobot yang diinisialisasi secara acak untuk Transformer, tetapi bobot yang telah dilatih sebelumnya untuk backbone

```python
from transformers import DabDetrConfig, DabDetrForObjectDetection

config = DabDetrConfig()
model = DabDetrForObjectDetection(config)
```

Opsi 3: Instansiasi DAB-DETR dengan bobot yang diinisialisasi secara acak untuk backbone + Transformer

```py
config = DabDetrConfig()
model = DabDetrForObjectDetection(config)
```

## DabDetrConfig[[transformers.DabDetrConfig]]

#### transformers.DabDetrConfig[[transformers.DabDetrConfig]]

```python
transformers.DabDetrConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, num_queries: int = 300, encoder_layers: int = 6, encoder_ffn_dim: int = 2048, encoder_attention_heads: int = 8, decoder_layers: int = 6, decoder_ffn_dim: int = 2048, decoder_attention_heads: int = 8, activation_function: str = 'prelu', hidden_size: int = 256, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, init_xavier_std: float = 1.0, auxiliary_loss: bool = False, dilation: bool = False, class_cost: int = 2, bbox_cost: int = 5, giou_cost: int = 2, cls_loss_coefficient: int = 2, bbox_loss_coefficient: int = 5, giou_loss_coefficient: int = 2, focal_alpha: float = 0.25, temperature_height: int = 20, temperature_width: int = 20, query_dim: int = 4, random_refpoints_xy: bool = False, keep_query_pos: bool = False, num_patterns: int = 0, normalize_before: bool = False, sine_position_embedding_scale: float | None = None, initializer_bias_prior_prob: float | None = None, tie_word_embeddings: bool = True)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dab_detr/configuration_dab_detr.py#L25)

**Parameter:**

is_encoder_decoder (`bool`, *opsional*, defaultnya `True`) : Apakah model digunakan sebagai encoder/decoder atau tidak.

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opsional*) : Konfigurasi dari model backbone.

num_queries (`int`, *opsional*, default 300) : Jumlah query objek, yaitu slot deteksi. Ini adalah jumlah maksimal objek yang dapat dideteksi oleh [DabDetrModel](/docs/transformers/main/id/model_doc/dab-detr#transformers.DabDetrModel) dalam satu gambar. Untuk COCO, kami merekomendasikan 100 query.

encoder_layers (`int`, *opsional*, defaultnya `6`) : Jumlah lapisan tersembunyi dalam encoder Transformer. Akan menggunakan nilai yang sama dengan `num_layers` jika tidak diatur.

encoder_ffn_dim (`int`, *opsional*, defaultnya `2048`) : Dimensi dari lapisan "intermediate" (sering disebut feed-forward) dalam encoder.

encoder_attention_heads (`int`, *opsional*, defaultnya `8`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam encoder Transformer.

decoder_layers (`int`, *opsional*, defaultnya `6`) : Jumlah lapisan tersembunyi dalam decoder Transformer. Akan menggunakan nilai yang sama dengan `num_layers` jika tidak diatur.

decoder_ffn_dim (`int`, *opsional*, defaultnya `2048`) : Dimensi dari lapisan "intermediate" (sering disebut feed-forward) dalam decoder.

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

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

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

dropout (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Rasio untuk semua lapisan dropout.

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

activation_dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk aktivasi di dalam lapisan fully connected.

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

init_xavier_std (`float`, *opsional*, defaultnya `1.0`) : Faktor penskalaan yang digunakan untuk inisialisasi Xavier pada bobot cross-attention.

auxiliary_loss (`bool`, *opsional*, defaultnya `False`) : Apakah kerugian dekode bantu (kerugian di setiap lapisan decoder) akan digunakan.

dilation (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengganti stride dengan dilation pada blok konvolusional terakhir (DC5). Hanya didukung ketika `use_timm_backbone` = `True`.

class_cost (`int`, *opsional*, defaultnya `2`) : Bobot relatif dari kesalahan klasifikasi dalam biaya pencocokan Hungarian.

bbox_cost (`int`, *opsional*, defaultnya `5`) : Bobot relatif dari error kotak pembatas L1 dalam biaya pencocokan Hungaria.

giou_cost (`int`, *opsional*, defaultnya `2`) : Bobot relatif dari kerugian IoU umum dalam biaya pencocokan Hungaria.

cls_loss_coefficient (`int`, *opsional*, defaultnya `2`) : Bobot relatif dari loss klasifikasi dalam loss segmentasi panoptik.

bbox_loss_coefficient (`int`, *opsional*, defaultnya `5`) : Bobot relatif dari kerugian kotak batas L1 dalam kerugian segmentasi panoptik.

giou_loss_coefficient (`int`, *opsional*, defaultnya `2`) : Bobot relatif dari kerugian IoU umum dalam kerugian segmentasi panoptik.

focal_alpha (`float`, *opsional*, default `0.25`) : Parameter alpha dalam focal loss.

temperature_height (`int`, *opsional*, default 20) : Parameter suhu untuk mengatur kehalusan perhatian posisional (HEIGHT)

temperature_width (`int`, *opsional*, default 20) : Parameter suhu untuk mengatur kehalusan perhatian posisional (WIDTH)

query_dim (`int`, *opsional*, default 4) : Parameter dimensi query mewakili ukuran vektor output.

random_refpoints_xy (`bool`, *opsional*, defaultnya `False`) : Apakah akan memperbaiki koordinat x dan y dari kotak jangkar dengan inisialisasi acak.

keep_query_pos (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggabungkan positional embedding yang diproyeksikan dari object query ke query (key) asli di setiap lapisan decoder.

num_patterns (`int`, *opsional*, default 0) : Jumlah embedding pola.

normalize_before (`bool`, *opsional*, defaultnya `False`) : Apakah kita menggunakan lapisan normalisasi di Encoder atau tidak.

sine_position_embedding_scale (`float`, *opsional*, default 'None') : Faktor penskalaan yang diterapkan pada enkoding posisi ternormalisasi.

initializer_bias_prior_prob (`float`, *opsional*) : Probabilitas prior yang digunakan oleh bias initializer untuk menginisialisasi bias pada `enc_score_head` dan `class_embed`. Jika `None`, `prior_prob` dihitung sebagai `prior_prob = 1 / (num_labels + 1)` saat menginisialisasi bobot model.

tie_word_embeddings (`bool`, *opsional*, defaultnya `True`) : Apakah mengikat embedding bobot sesuai dengan pemetaan `tied_weights_keys` model.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari model Dab Detr. Kelas ini digunakan untuk membuat instans model Dab Detr berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [IDEA-Research/dab-detr-resnet-50](https://huggingface.co/IDEA-Research/dab-detr-resnet-50)

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 DabDetrConfig, DabDetrModel

>>> # Initializing a DAB-DETR IDEA-Research/dab-detr-resnet-50 style configuration
>>> configuration = DabDetrConfig()

>>> # Initializing a model (with random weights) from the IDEA-Research/dab-detr-resnet-50 style configuration
>>> model = DabDetrModel(configuration)

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

## DabDetrModel[[transformers.DabDetrModel]]

#### transformers.DabDetrModel[[transformers.DabDetrModel]]

```python
transformers.DabDetrModel(config: DabDetrConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dab_detr/modeling_dab_detr.py#L1144)

**Parameter:**

config ([DabDetrConfig](/docs/transformers/main/id/model_doc/dab-detr#transformers.DabDetrConfig)) : 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.

Model DAB-DETR polos (terdiri dari backbone dan Transformer encoder-decoder) yang menghasilkan hidden-states mentah, hidden states perantara, titik referensi, dan koordinat output tanpa head spesifik di atasnya.

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

```python
forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_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/dab_detr/modeling_dab_detr.py#L1196)

**Parameter:**

pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan `image_processor_class`. Lihat `image_processor_class.__call__` untuk detailnya (`processor_class` menggunakan `image_processor_class` untuk memproses gambar).

pixel_mask (`torch.LongTensor` dengan bentuk `(batch_size, height, width)`, *opsional*) : Mask untuk menghindari pelaksanaan perhatian pada nilai piksel padding. Nilai mask yang dipilih dalam `[0, 1]`:  - 1 untuk piksel yang asli (yaitu **tidak dimask**), - 0 untuk piksel yang merupakan padding (yaitu **dimask**).  [Apa itu attention mask?](../glossary#attention-mask)

decoder_attention_mask (`torch.Tensor` dengan bentuk `(batch_size, num_queries)`, *opsional*) : Tidak digunakan secara default. Dapat digunakan untuk memasker kueri objek.

encoder_outputs (`torch.Tensor`, *opsional*) : Tuple terdiri dari (`last_hidden_state`, *opsional*: `hidden_states`, *opsional*: `attentions`) `last_hidden_state` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) adalah urutan hidden-states pada keluaran lapisan terakhir encoder. Digunakan dalam cross-attention decoder.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan peta fitur yang telah diratakan (output dari backbone + lapisan proyeksi), Anda dapat memilih untuk langsung meneruskan representasi ratakan dari sebuah gambar.

decoder_inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, num_queries, hidden_size)`, *opsional*) : Secara opsional, alih-alih menginisialisasi query dengan tensor nol, Anda dapat memilih untuk langsung meneruskan representasi tertanam.

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:** `DabDetrModelOutput` atau `tuple(torch.Tensor)`

Sebuah `DabDetrModelOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DabDetrConfig](/docs/transformers/main/id/model_doc/dab-detr#transformers.DabDetrConfig)) dan input.

Metode forward dari [DabDetrModel](/docs/transformers/main/id/model_doc/dab-detr#transformers.DabDetrModel) 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.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-state pada keluaran lapisan terakhir dari decoder model.

  Jika `past_key_values` digunakan, hanya hidden-state terakhir dari sekuens dengan bentuk `(batch_size, 1, hidden_size)` yang dioutput.
- **past_key_values** (`EncoderDecoderCache`, *opsional*, dikembalikan ketika `use_cache=True` diteruskan atau ketika `config.use_cache=True`) -- Ini adalah instance [EncoderDecoderCache](/docs/transformers/main/id/internal/generation_utils#transformers.EncoderDecoderCache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `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 decoder pada output setiap layer ditambah output embedding awal yang opsional.
- **decoder_attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` diteruskan 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 dari decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **cross_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 dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
- **encoder_last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran lapisan terakhir dari encoder model.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_hidden_states=True` diteruskan 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 encoder pada output setiap layer ditambah output embedding awal yang opsional.
- **encoder_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 dari encoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **intermediate_hidden_states** (`torch.Tensor` dengan bentuk `(config.decoder_layers, batch_size, sequence_length, hidden_size)`, *opsional*, dikembalikan ketika `config.auxiliary_loss=True`) -- Aktivasi decoder antara, yaitu keluaran dari setiap lapisan decoder, di mana masing-masing telah melewati layernorm.
- **reference_points** (`torch.Tensor` dengan bentuk `(config.decoder_layers, batch_size, num_queries, 2 (anchor points))`) -- Titik referensi (titik referensi untuk setiap lapisan decoder).

Contoh:

```python
>>> from transformers import AutoImageProcessor, AutoModel
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("IDEA-Research/dab-detr-resnet-50")
>>> model = AutoModel.from_pretrained("IDEA-Research/dab-detr-resnet-50")

>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**inputs)

>>> # the last hidden states are the final query embeddings of the Transformer decoder
>>> # these are of shape (batch_size, num_queries, hidden_size)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 300, 256]
```

## DabDetrForObjectDetection[[transformers.DabDetrForObjectDetection]]

#### transformers.DabDetrForObjectDetection[[transformers.DabDetrForObjectDetection]]

```python
transformers.DabDetrForObjectDetection(config: DabDetrConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dab_detr/modeling_dab_detr.py#L1416)

**Parameter:**

config ([DabDetrConfig](/docs/transformers/main/id/model_doc/dab-detr#transformers.DabDetrConfig)) : 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.

Model DAB_DETR (terdiri dari backbone dan Transformer encoder-decoder) dengan kepala deteksi objek di atasnya, untuk tugas seperti deteksi COCO.

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

```python
forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = 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/dab_detr/modeling_dab_detr.py#L1445)

**Parameter:**

pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan `image_processor_class`. Lihat `image_processor_class.__call__` untuk detailnya (`processor_class` menggunakan `image_processor_class` untuk memproses gambar).

pixel_mask (`torch.LongTensor` dengan bentuk `(batch_size, height, width)`, *opsional*) : Mask untuk menghindari pelaksanaan perhatian pada nilai piksel padding. Nilai mask yang dipilih dalam `[0, 1]`:  - 1 untuk piksel yang asli (yaitu **tidak dimask**), - 0 untuk piksel yang merupakan padding (yaitu **dimask**).  [Apa itu attention mask?](../glossary#attention-mask)

decoder_attention_mask (`torch.Tensor` dengan bentuk `(batch_size, num_queries)`, *opsional*) : Tidak digunakan secara default. Dapat digunakan untuk memasker kueri objek.

encoder_outputs (`torch.Tensor`, *opsional*) : Tuple terdiri dari (`last_hidden_state`, *opsional*: `hidden_states`, *opsional*: `attentions`) `last_hidden_state` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) adalah urutan hidden-states pada keluaran lapisan terakhir encoder. Digunakan dalam cross-attention decoder.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan peta fitur yang telah diratakan (output dari backbone + lapisan proyeksi), Anda dapat memilih untuk langsung meneruskan representasi ratakan dari sebuah gambar.

decoder_inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, num_queries, hidden_size)`, *opsional*) : Secara opsional, alih-alih menginisialisasi query dengan tensor nol, Anda dapat memilih untuk langsung meneruskan representasi tertanam.

labels (`list[Dict]` of len `(batch_size,)`, *opsional*) : Label untuk menghitung bipartite matching loss. Daftar dict, di mana setiap dict setidaknya berisi 2 kunci berikut: 'class_labels' dan 'boxes' (masing-masing label kelas dan bounding box dari sebuah gambar dalam batch). Label kelas itu sendiri harus berupa `torch.LongTensor` of len `(number of bounding boxes in the image,)` dan boxes a `torch.Tensor` of shape `(number of bounding boxes in the image, 4)`.

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:** `DabDetrObjectDetectionOutput` atau `tuple(torch.Tensor)`

Sebuah `DabDetrObjectDetectionOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DabDetrConfig](/docs/transformers/main/id/model_doc/dab-detr#transformers.DabDetrConfig)) dan input.

Metode forward dari [DabDetrForObjectDetection](/docs/transformers/main/id/model_doc/dab-detr#transformers.DabDetrForObjectDetection) 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.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` disediakan)) -- Total loss sebagai kombinasi linear dari negative log-likelihood (cross-entropy) untuk prediksi kelas dan bounding box loss. Yang terakhir didefinisikan sebagai kombinasi linear dari L1 loss dan generalized scale-invariant IoU loss.
- **loss_dict** (`Dict`, *opsional*) -- Kamus yang berisi kerugian individual. Berguna untuk pencatatan.
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, num_classes + 1)`) -- Logit klasifikasi (termasuk no-object) untuk semua query.
- **pred_boxes** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, 4)`) -- Koordinat kotak yang dinormalisasi untuk semua query, direpresentasikan sebagai (center_x, center_y, width, height). Nilai-nilai ini dinormalisasi dalam rentang [0, 1], relatif terhadap ukuran masing-masing gambar dalam batch (mengabaikan padding yang mungkin ada). Anda dapat menggunakan `~DabDetrImageProcessor.post_process_object_detection` untuk mengambil kotak pembatas yang tidak dinormalisasi.
- **auxiliary_outputs** (`list[Dict]`, *opsional*) -- Opsional, hanya dikembalikan ketika auxiliary losses diaktifkan (yaitu `config.auxiliary_loss` diatur ke `True`) dan label disediakan. Ini adalah daftar kamus yang berisi dua kunci di atas (`logits` dan `pred_boxes`) untuk setiap lapisan decoder.
- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran lapisan terakhir dari decoder model.
- **decoder_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 decoder pada output setiap layer ditambah output embedding awal.
- **decoder_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 dari decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **cross_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 dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
- **encoder_last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran lapisan terakhir dari encoder model.
- **encoder_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 encoder pada output setiap layer ditambah output embedding awal.
- **encoder_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 dari encoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:

```python
>>> from transformers import AutoImageProcessor, AutoModelForObjectDetection
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("IDEA-Research/dab-detr-resnet-50")
>>> model = AutoModelForObjectDetection.from_pretrained("IDEA-Research/dab-detr-resnet-50")

>>> inputs = image_processor(images=image, return_tensors="pt")

>>> with torch.no_grad():
>>>     outputs = model(**inputs)

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([(image.height, image.width)])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.5, target_sizes=target_sizes)[0]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected remote with confidence 0.833 at location [38.31, 72.1, 177.63, 118.45]
Detected cat with confidence 0.831 at location [9.2, 51.38, 321.13, 469.0]
Detected cat with confidence 0.804 at location [340.3, 16.85, 642.93, 370.95]
Detected remote with confidence 0.683 at location [334.48, 73.49, 366.37, 190.01]
Detected couch with confidence 0.535 at location [0.52, 1.19, 640.35, 475.1]
```