# LW-DETR

[LW-DETR](https://huggingface.co/papers/2407.17140) mengusulkan arsitektur Detection Transformer (DETR) ringan yang dirancang untuk bersaing dan melampaui seri YOLO yang dominan dalam deteksi objek real-time. Model ini mencapai keseimbangan state-of-the-art baru antara kecepatan (latensi) dan akurasi (mAP) dengan menggabungkan kemajuan transformer terbaru dengan pilihan desain yang efisien.

Arsitektur LW-DETR ditandai dengan struktur yang sederhana dan efisien: Encoder ViT polos, Projector, dan Decoder DETR dangkal. Arsitektur ini meningkatkan arsitektur DETR untuk efisiensi dan kecepatan menggunakan modifikasi inti berikut:
1. Encoder ViT Efisien: Menggunakan ViT polos dengan perhatian jendela/global yang berselang-seling dan organisasi berbasis jendela untuk mengurangi kompleksitas dan latensi perhatian secara drastis.
2. Input yang Lebih Kaya: Mengagregasi fitur multi-level dari encoder dan menggunakan C2f Projector (YOLOv8) untuk meneruskan fitur dua skala ($1/8$ dan $1/32$).
3. Decoder Lebih Cepat: Menggunakan decoder DETR 3-lapis yang dangkal dengan deformable cross-attention untuk latensi lebih rendah dan konvergensi lebih cepat.
4. Kueri yang Dioptimalkan: Menggunakan skema kueri campuran yang menggabungkan kueri konten yang dapat dipelajari dan kueri spasial yang dihasilkan.

Anda dapat menemukan semua checkpoint LW DETR yang tersedia di bawah organisasi [AnnaZhang](https://huggingface.co/AnnaZhang). Kode aslinya dapat ditemukan [di sini](https://github.com/Atten4Vis/LW-DETR).

> [!TIP]
> Model ini disumbangkan oleh [stevenbucaille](https://huggingface.co/stevenbucaille).
>
> Klik pada model LW-DETR di bilah sisi kanan untuk melihat lebih banyak contoh cara menerapkan LW-DETR ke berbagai tugas deteksi objek.

Contoh di bawah ini menunjukkan cara melakukan deteksi objek dengan [Pipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.Pipeline) dan kelas [AutoModel](/docs/transformers/main/id/model_doc/auto#transformers.AutoModel).

```python

from transformers import pipeline

pipeline = pipeline(
    "object-detection",
    model="AnnaZhang/lwdetr_small_60e_coco",
    device_map=0
)

pipeline("http://images.cocodataset.org/val2017/000000039769.jpg")
```

```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("AnnaZhang/lwdetr_small_60e_coco")
model = AutoModelForObjectDetection.from_pretrained("AnnaZhang/lwdetr_small_60e_coco", device_map="auto")

# prepare image for the model
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}")
```

## Sumber daya

Daftar sumber resmi Hugging Face dan komunitas (ditandai dengan 🌎) untuk membantu Anda memulai dengan LwDetr.

- Lihat juga: [Panduan tugas deteksi objek](../tasks/object_detection).

## LwDetrConfig[[transformers.LwDetrConfig]]

#### transformers.LwDetrConfig[[transformers.LwDetrConfig]]

```python
transformers.LwDetrConfig(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, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, projector_scale_factors: list[float] | tuple[float, ...] = (), hidden_expansion: float = 0.5, c2f_num_blocks: int = 3, activation_function: str = 'silu', batch_norm_eps: float = 1e-05, dropout: float | int = 0.0, decoder_ffn_dim: int = 2048, decoder_n_points: int = 4, decoder_layers: int = 3, decoder_self_attention_heads: int = 8, decoder_cross_attention_heads: int = 16, decoder_activation_function: str = 'relu', num_queries: int = 300, attention_bias: bool = True, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, group_detr: int = 13, init_std: float = 0.02, disable_custom_kernels: bool = True, class_cost: int | float = 2, bbox_cost: int | float = 5, giou_cost: int | float = 2, class_loss_coefficient: int | float = 1, dice_loss_coefficient: int | float = 1, bbox_loss_coefficient: int | float = 5, giou_loss_coefficient: int | float = 2, eos_coefficient: float = 0.1, focal_alpha: float = 0.25, auxiliary_loss: bool = True, d_model: int = 256)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/configuration_lw_detr.py#L109)

**Parameter:**

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

projector_scale_factors (`list[float]`, *opsional*, defaultnya `[]`) : Faktor skala untuk feature pyramid network. Setiap faktor skala menentukan resolusi fitur pada level yang berbeda. Nilai yang didukung adalah 0.5, 1.0, dan 2.0.

hidden_expansion (`float`, *opsional*, default 0.5) : Faktor ekspansi untuk dimensi tersembunyi di lapisan proyektor.

c2f_num_blocks (`int`, *opsional*, defaultnya 3) : Jumlah blok di lapisan C2F.

activation_function (`str`, *opsional*, defaultnya `"silu"`) : Fungsi aktivasi non-linear dalam projector. Nilai yang didukung adalah `"silu"`, `"relu"`, `"gelu"`.

batch_norm_eps (`float`, *opsional*, default 1e-05) : Nilai epsilon untuk lapisan normalisasi batch.

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

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

decoder_n_points (`int`, *opsional*, defaultnya 4) : Jumlah kunci yang disampelkan di setiap tingkat fitur untuk setiap kepala perhatian dalam decoder.

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

decoder_self_attention_heads (`int`, *opsional*, defaultnya 8) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam self-attention decoder.

decoder_cross_attention_heads (`int`, *opsional*, default 16) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam cross-attention decoder.

decoder_activation_function (`str`, *opsional*, defaultnya `"relu"`) : Fungsi aktivasi non-linear dalam decoder. Nilai yang didukung adalah `"relu"`, `"silu"`, `"gelu"`.

num_queries (`int`, *opsional*, default 300) : Jumlah query objek, yaitu slot deteksi. Ini adalah jumlah maksimal objek yang dapat dideteksi oleh [LwDetrModel](/docs/transformers/main/id/model_doc/lw_detr#transformers.LwDetrModel) dalam satu gambar.

attention_bias (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan bias pada lapisan proyeksi query, key, value, dan output selama self-attention.

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.

group_detr (`int`, *opsional*, default 13) : Jumlah grup untuk mekanisme perhatian Group DETR, yang membantu mengurangi kompleksitas komputasi.

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

disable_custom_kernels (`bool`, *opsional*, defaultnya `True`) : Menonaktifkan penggunaan kernel CUDA dan CPU kustom. Opsi ini diperlukan untuk ekspor ONNX, karena kernel kustom tidak didukung oleh ekspor ONNX PyTorch.

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

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

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

class_loss_coefficient (`float`, *opsional*, default 1) : Bobot relatif dari loss klasifikasi dalam biaya pencocokan Hungarian.

dice_loss_coefficient (`Union[int, float]`, *opsional*, defaultnya `1`) : Bobot relatif dari dice loss dalam loss segmentasi panoptik.

bbox_loss_coefficient (`Union[int, float]`, *opsional*, defaultnya `5`) : Bobot relatif dari kerugian kotak pembatas L1 dalam kerugian segmentasi panoptik.

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

eos_coefficient (`float`, *opsional*, default `0.1`) : Bobot klasifikasi relatif untuk kelas 'no-object' dalam loss deteksi objek.

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

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

d_model (`int`, *opsional*, defaultnya `256`) : Ukuran lapisan encoder dan lapisan pooler.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari LwDetrModel. Kelas ini digunakan untuk membuat instans model Lw Detr berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [AnnaZhang/lwdetr_small_60e_coco](https://huggingface.co/AnnaZhang/lwdetr_small_60e_coco)

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 LwDetrConfig, LwDetrModel

>>> # Initializing a LW-DETR AnnaZhang/lwdetr_small_60e_coco style configuration
>>> configuration = LwDetrConfig()

>>> # Initializing a model (with random weights) from the AnnaZhang/lwdetr_small_60e_coco style configuration
>>> model = LwDetrModel(configuration)

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

## LwDetrViTConfig[[transformers.LwDetrViTConfig]]

#### transformers.LwDetrViTConfig[[transformers.LwDetrViTConfig]]

```python
transformers.LwDetrViTConfig(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, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, mlp_ratio: int = 4, hidden_act: str = 'gelu', dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, image_size: int | list[int] | tuple[int, int] = 256, pretrain_image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, qkv_bias: bool = True, window_block_indices: list[int] | tuple[int, ...] = (), use_absolute_position_embeddings: bool = True, _out_features: list[str] | None = None, _out_indices: list[int] | None = None, cae_init_values: float = 0.1, num_windows: int = 16)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/configuration_lw_detr.py#L35)

**Parameter:**

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.

mlp_ratio (`int`, *opsional*, defaultnya `4`) : Rasio dimensi tersembunyi MLP terhadap dimensi embedding.

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

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

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-06`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan.

image_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `256`) : Ukuran (resolusi) dari setiap gambar.

pretrain_image_size (`int`, *opsional*, defaultnya 224) : Ukuran (resolusi) setiap gambar selama pra-pelatihan.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `16`) : Ukuran (resolusi) dari setiap patch.

num_channels (`int`, *opsional*, default `3`) : Jumlah saluran input.

qkv_bias (`bool`, *opsional*, defaultnya `True`) : Apakah akan menambahkan bias ke queries, keys, dan values.

window_block_indices (`list[int]`, *opsional*, defaultnya `[]`) : Daftar indeks blok yang harus menggunakan window attention alih-alih self-attention global reguler.

use_absolute_position_embeddings (`bool`, *opsional*, defaultnya `True`) : Apakah akan menambahkan embedding posisi absolut ke embedding patch.

cae_init_values (`float`, *opsional*, default 0.1) : Nilai inisialisasi untuk parameter CAE ketika `use_cae` diaktifkan.

num_windows (`int`, *opsional*, default 16) : Jumlah jendela untuk perhatian berbasis jendela. Nilai ini harus berupa kuadrat sempurna dan ukuran gambar harus dapat dibagi habis oleh akar kuadrat dari nilai ini. Hal ini memungkinkan organisasi peta fitur berbasis jendela yang efisien.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari LwDetrModel. Kelas ini digunakan untuk membuat instans model Lw Detr berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [AnnaZhang/lwdetr_small_60e_coco](https://huggingface.co/AnnaZhang/lwdetr_small_60e_coco)

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 LwDetrViTConfig, LwDetrViTModel

>>> # Initializing a LW-DETR ViT configuration
>>> configuration = LwDetrViTConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = LwDetrViTModel(configuration)

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

## LwDetrModel[[transformers.LwDetrModel]]

#### transformers.LwDetrModel[[transformers.LwDetrModel]]

```python
transformers.LwDetrModel(config: LwDetrConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L1204)

**Parameter:**

config ([LwDetrConfig](/docs/transformers/main/id/model_doc/lw_detr#transformers.LwDetrConfig)) : 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 LW Detr polos (terdiri dari backbone dan decoder Transformer) yang menghasilkan hidden-states mentah 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.LwDetrModel.forward]]

```python
forward(pixel_values: Tensor = None, pixel_mask: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L1310)

**Parameter:**

pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`, *opsional*) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [DeformableDetrImageProcessor](/docs/transformers/main/id/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor). Lihat [DeformableDetrImageProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [DeformableDetrImageProcessor](/docs/transformers/main/id/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor) 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)

**Mengembalikan:** `LwDetrModelOutput` atau `tuple(torch.Tensor)`

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

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

- **init_reference_points** (`torch.Tensor` dengan bentuk  `(batch_size, num_queries, 4)`) -- Titik referensi awal yang dikirim melalui decoder Transformer.
- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran dari lapisan terakhir model.
- **intermediate_hidden_states** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, num_queries, hidden_size)`) -- Hidden states antara yang ditumpuk (output dari setiap layer decoder).
- **intermediate_reference_points** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, num_queries, 4)`) -- Titik referensi antara yang ditumpuk (titik referensi dari setiap lapisan decoder).
- **enc_outputs_class** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.num_labels)`, *opsional*, dikembalikan ketika `config.with_box_refine=True` dan `config.two_stage=True`) -- Skor kotak pembatas yang diprediksi, di mana `config.two_stage_num_proposals` kotak pembatas dengan skor tertinggi dipilih sebagai usulan wilayah pada tahap pertama. Output dari klasifikasi biner kotak pembatas (yaitu latar depan dan latar belakang).
- **enc_outputs_coord_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, 4)`, *opsional*, dikembalikan ketika `config.with_box_refine=True` dan `config.two_stage=True`) -- Logits dari koordinat bounding box yang diprediksi pada tahap pertama.
- **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.
- **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.

Contoh:

```python
>>> from transformers import AutoImageProcessor, DeformableDetrModel
>>> 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("AnnaZhang/lwdetr_small_60e_coco")
>>> model = DeformableDetrModel.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")

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

>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 300, 256]
```

## LwDetrForObjectDetection[[transformers.LwDetrForObjectDetection]]

#### transformers.LwDetrForObjectDetection[[transformers.LwDetrForObjectDetection]]

```python
transformers.LwDetrForObjectDetection(config: LwDetrConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L1540)

**Parameter:**

config ([LwDetrConfig](/docs/transformers/main/id/model_doc/lw_detr#transformers.LwDetrConfig)) : 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 LW DETR (terdiri dari backbone dan decoder Transformer) 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.LwDetrForObjectDetection.forward]]

```python
forward(pixel_values: Tensor = None, pixel_mask: typing.Optional[torch.LongTensor] = None, labels: list[dict] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L1554)

**Parameter:**

pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`, *opsional*) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [DeformableDetrImageProcessor](/docs/transformers/main/id/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor). Lihat [DeformableDetrImageProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [DeformableDetrImageProcessor](/docs/transformers/main/id/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor) 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)

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

**Mengembalikan:** `LwDetrObjectDetectionOutput` atau `tuple(torch.Tensor)`

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

Metode forward dari [LwDetrForObjectDetection](/docs/transformers/main/id/model_doc/lw_detr#transformers.LwDetrForObjectDetection) 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 `~DeformableDetrProcessor.post_process_object_detection` untuk mengambil kotak batas 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.
- **init_reference_points** (`torch.Tensor` dengan bentuk  `(batch_size, num_queries, 4)`) -- Titik referensi awal yang dikirim melalui decoder Transformer.
- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran dari lapisan terakhir model.
- **intermediate_hidden_states** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, num_queries, hidden_size)`) -- Hidden states antara yang ditumpuk (output dari setiap layer decoder).
- **intermediate_reference_points** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, num_queries, 4)`) -- Titik referensi antara yang ditumpuk (titik referensi dari setiap lapisan decoder).
- **enc_outputs_class** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.num_labels)`, *opsional*, dikembalikan ketika `config.with_box_refine=True` dan `config.two_stage=True`) -- Skor kotak pembatas yang diprediksi, di mana `config.two_stage_num_proposals` kotak pembatas dengan skor tertinggi dipilih sebagai usulan wilayah pada tahap pertama. Output dari klasifikasi biner kotak pembatas (yaitu latar depan dan latar belakang).
- **enc_outputs_coord_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, 4)`, *opsional*, dikembalikan ketika `config.with_box_refine=True` dan `config.two_stage=True`) -- Logits dari koordinat bounding box yang diprediksi pada tahap pertama.
- **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.
- **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.

Contoh:

```python
>>> from transformers import AutoImageProcessor, LwDetrForObjectDetection
>>> 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("AnnaZhang/lwdetr_small_60e_coco")
>>> model = LwDetrForObjectDetection.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")

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

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> 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 cat with confidence 0.8 at location [16.5, 52.84, 318.25, 470.78]
Detected cat with confidence 0.789 at location [342.19, 24.3, 640.02, 372.25]
Detected remote with confidence 0.633 at location [40.79, 72.78, 176.76, 117.25]
```

## LwDetrViTBackbone[[transformers.LwDetrViTBackbone]]

#### transformers.LwDetrViTBackbone[[transformers.LwDetrViTBackbone]]

```python
transformers.LwDetrViTBackbone(config: LwDetrViTConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L342)

**Parameter:**

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

Backbone Lw Detr.

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

```python
forward(pixel_values: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L356)

**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 [DeformableDetrImageProcessor](/docs/transformers/main/id/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor). Lihat [DeformableDetrImageProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [DeformableDetrImageProcessor](/docs/transformers/main/id/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor) untuk memproses gambar).

**Mengembalikan:** `BackboneOutput` atau `tuple(torch.Tensor)`

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

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

- **feature_maps** (`tuple(torch.Tensor)` dengan bentuk `(batch_size, num_channels, height, width)`) -- Feature maps dari setiap tahap.
- **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 embeddings + satu untuk output setiap layer) dengan bentuk `(batch_size, sequence_length, hidden_size)` atau `(batch_size, num_channels, height, width)`, tergantung pada backbone.

  Hidden-states model pada output setiap tahap ditambah output embedding awal.
- **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)`. Hanya berlaku jika backbone menggunakan attention.

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

Contoh:

```python
>>> from transformers import LwDetrViTConfig, LwDetrViTBackbone
>>> import torch

>>> config = LwDetrViTConfig()
>>> model = LwDetrViTBackbone(config)

>>> pixel_values = torch.randn(1, 3, 224, 224)

>>> with torch.no_grad():
...     outputs = model(pixel_values)

>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 768, 14, 14]
```