# RT-DETR

## Ikhtisar

Model RT-DETR diusulkan dalam [DETRs Beat YOLOs on Real-time Object Detection](https://huggingface.co/papers/2304.08069) oleh Wenyu Lv, Yian Zhao, Shangliang Xu, Jinman Wei, Guanzhong Wang, Cheng Cui, Yuning Du, Qingqing Dang, Yi Liu.

RT-DETR adalah model deteksi objek yang merupakan singkatan dari "Real-Time DEtection Transformer." Model ini dirancang untuk menjalankan tugas deteksi objek dengan fokus pada pencapaian kinerja real-time sambil mempertahankan akurasi yang tinggi. Dengan memanfaatkan arsitektur transformer, yang telah meraih popularitas signifikan di berbagai bidang pembelajaran mendalam, RT-DETR memproses gambar untuk mengidentifikasi dan menentukan lokasi beberapa objek di dalamnya.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Baru-baru ini, detektor berbasis transformer end-to-end (DETR) telah mencapai kinerja yang luar biasa. Namun, masalah biaya komputasi DETR yang tinggi belum ditangani secara efektif, sehingga membatasi aplikasi praktisnya dan menghalangi pemanfaatan penuh keuntungan dari tidak adanya pascaproses, seperti non-maximum suppression (NMS). Dalam makalah ini, kami pertama kali menganalisis pengaruh NMS pada detektor objek real-time modern terhadap kecepatan inferensi, dan menetapkan benchmark kecepatan end-to-end. Untuk menghindari penundaan inferensi yang disebabkan oleh NMS, kami mengusulkan Real-Time DEtection TRansformer (RT-DETR), detektor objek end-to-end real-time pertama sejauh pengetahuan kami. Secara spesifik, kami merancang encoder hibrida yang efisien untuk memproses fitur multi-skala secara efisien dengan memisahkan interaksi intra-skala dan fusi lintas-skala, serta mengusulkan pemilihan query yang sadar IoU untuk meningkatkan inisialisasi query objek. Selain itu, detektor yang kami usulkan mendukung penyesuaian fleksibel kecepatan inferensi dengan menggunakan lapisan decoder yang berbeda tanpa perlu pelatihan ulang, yang memfasilitasi aplikasi praktis detektor objek real-time. RT-DETR-L kami mencapai 53,0% AP pada COCO val2017 dan 114 FPS pada GPU T4, sementara RT-DETR-X mencapai 54,8% AP dan 74 FPS, melampaui semua detektor YOLO dengan skala yang sama baik dalam kecepatan maupun akurasi. Selain itu, RT-DETR-R50 kami mencapai 53,1% AP dan 108 FPS, melampaui DINO-Deformable-DETR-R50 sebesar 2,2% AP dalam akurasi dan sekitar 21 kali lipat dalam FPS.*

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

 Kinerja RT-DETR relatif terhadap model YOLO. Diambil dari paper aslinya.

Versi model ini disumbangkan oleh [rafaelpadilla](https://huggingface.co/rafaelpadilla) dan [sangbumchoi](https://github.com/SangbumChoi). Kode aslinya dapat ditemukan [di sini](https://github.com/lyuwenyu/RT-DETR/).

## Tips penggunaan

Awalnya, sebuah gambar diproses menggunakan convolutional neural network yang telah dilatih sebelumnya, khususnya varian Resnet-D sebagaimana dirujuk dalam kode asli. Jaringan ini mengekstrak fitur dari tiga lapisan terakhir arsitektur. Selanjutnya, encoder hibrida digunakan untuk mengonversi fitur multi-skala menjadi array berurutan dari fitur gambar. Kemudian, decoder yang dilengkapi dengan kepala prediksi tambahan digunakan untuk menyempurnakan kueri objek. Proses ini memfasilitasi pembuatan langsung kotak pembatas, sehingga menghilangkan kebutuhan akan pascapemrosesan tambahan untuk memperoleh logits dan koordinat kotak pembatas. Model ini dimaksudkan untuk digunakan pada gambar yang di-resize ke ukuran 640x640 dengan ImageProcessor yang sesuai. Mengubah bentuk ke ukuran lain umumnya akan menurunkan kinerja.

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

from transformers import RTDetrForObjectDetection, RTDetrImageProcessor

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

image_processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd")
model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd", 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.height, image.width)]), 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}")
sofa: 0.97 [0.14, 0.38, 640.13, 476.21]
cat: 0.96 [343.38, 24.28, 640.14, 371.5]
cat: 0.96 [13.23, 54.18, 318.98, 472.22]
remote: 0.95 [40.11, 73.44, 175.96, 118.48]
remote: 0.92 [333.73, 76.58, 369.97, 186.99]
```

## Sumber daya

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

- Lihat juga: [Panduan tugas deteksi objek](../tasks/object_detection).
- Notebook mengenai inferensi dan fine-tuning RT-DETR pada dataset kustom dapat ditemukan [di sini](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/RT-DETR). 🌎

## RTDetrConfig[[transformers.RTDetrConfig]]

#### transformers.RTDetrConfig[[transformers.RTDetrConfig]]

```python
transformers.RTDetrConfig(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, initializer_range: float = 0.01, initializer_bias_prior_prob: float | None = None, layer_norm_eps: float = 1e-05, batch_norm_eps: float = 1e-05, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, freeze_backbone_batch_norms: bool = True, encoder_hidden_dim: int = 256, encoder_in_channels: list[int] | tuple[int, ...] = (512, 1024, 2048), feat_strides: list[int] | tuple[int, ...] = (8, 16, 32), encoder_layers: int = 1, encoder_ffn_dim: int = 1024, encoder_attention_heads: int = 8, dropout: float | int = 0.0, activation_dropout: float | int = 0.0, encode_proj_layers: list[int] | tuple[int, ...] = (2,), positional_encoding_temperature: int = 10000, encoder_activation_function: str = 'gelu', activation_function: str = 'silu', eval_size: int | None = None, normalize_before: bool = False, hidden_expansion: float = 1.0, d_model: int = 256, num_queries: int = 300, decoder_in_channels: list[int] | tuple[int, ...] = (256, 256, 256), decoder_ffn_dim: int = 1024, num_feature_levels: int = 3, decoder_n_points: int = 4, decoder_layers: int = 6, decoder_attention_heads: int = 8, decoder_activation_function: str = 'relu', attention_dropout: float | int = 0.0, num_denoising: int = 100, label_noise_ratio: float = 0.5, box_noise_scale: float = 1.0, learn_initial_query: bool = False, anchor_image_size: int | list[int] | None = None, disable_custom_kernels: bool = True, with_box_refine: bool = True, matcher_alpha: float = 0.25, matcher_gamma: float = 2.0, matcher_class_cost: float = 2.0, matcher_bbox_cost: float = 5.0, matcher_giou_cost: float = 2.0, use_focal_loss: bool = True, auxiliary_loss: bool = True, focal_loss_alpha: float = 0.75, focal_loss_gamma: float = 2.0, weight_loss_vfl: float = 1.0, weight_loss_bbox: float = 5.0, weight_loss_giou: float = 2.0, eos_coefficient: float = 0.0001)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/configuration_rt_detr.py#L25)

**Parameter:**

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

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

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.

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

batch_norm_eps (`float`, *opsional*, defaultnya `1e-05`) : Epsilon yang digunakan oleh lapisan normalisasi batch.

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

freeze_backbone_batch_norms (`bool`, *opsional*, defaultnya `True`) : Apakah akan membekukan lapisan batch normalization di backbone.

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

encoder_in_channels (`list`, *opsional*, defaultnya `[512, 1024, 2048]`) : Input fitur multi-level untuk encoder.

feat_strides (`list[int]`, *opsional*, defaultnya `[8, 16, 32]`) : Strides yang digunakan di setiap feature map.

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

encoder_ffn_dim (`int`, *opsional*, defaultnya `1024`) : 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.

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

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

encode_proj_layers (`list[int]`, *opsional*, defaultnya `[2]`) : Indeks dari lapisan proyeksi yang akan digunakan dalam encoder.

positional_encoding_temperature (`int`, *opsional*, default 10000) : Parameter suhu yang digunakan untuk membuat enkoding posisional.

encoder_activation_function (`str`, *opsional*, defaultnya `"gelu"`) : Fungsi aktivasi non-linear (fungsi atau string) di encoder dan pooler. Jika string, `"gelu"`, `"relu"`, `"silu"` dan `"gelu_new"` didukung.

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

eval_size (`tuple[int, int]`, *opsional*) : Tinggi dan lebar yang digunakan untuk menghitung tinggi dan lebar efektif dari posisi embedding setelah memperhitungkan stride.

normalize_before (`bool`, *opsional*, defaultnya `False`) : Menentukan apakah normalisasi lapisan diterapkan pada lapisan encoder transformer sebelum modul self-attention dan feed-forward.

hidden_expansion (`float`, *opsional*, default 1.0) : Rasio ekspansi untuk memperbesar ukuran dimensi dari RepVGGBlock dan CSPRepLayer.

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

num_queries (`int`, *opsional*, default 300) : Jumlah query objek.

decoder_in_channels (`list`, *opsional*, defaultnya `[256, 256, 256]`) : Dimensi fitur multi-level untuk decoder

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

num_feature_levels (`int`, *opsional*, defaultnya 3) : Jumlah level fitur input.

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 `6`) : Jumlah lapisan tersembunyi dalam decoder Transformer. Akan menggunakan nilai yang sama dengan `num_layers` jika tidak diatur.

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

decoder_activation_function (`str`, *opsional*, defaultnya `"relu"`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Jika string, `"gelu"`, `"relu"`, `"silu"` dan `"gelu_new"` didukung.

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

num_denoising (`int`, *opsional*, default 100) : Jumlah total tugas atau kueri denoising yang akan digunakan untuk denoising kontrastif.

label_noise_ratio (`float`, *opsional*, default 0.5) : Fraksi label denoising yang harus ditambahkan noise acak.

box_noise_scale (`float`, *opsional*, default 1.0) : Skala atau magnitudo noise yang akan ditambahkan ke kotak pembatas.

learn_initial_query (`bool`, *opsional*, defaultnya `False`) : Menunjukkan apakah embedding query awal untuk decoder harus dipelajari selama pelatihan

anchor_image_size (`tuple[int, int]`, *opsional*) : Tinggi dan lebar gambar input yang digunakan selama evaluasi untuk menghasilkan anchor kotak pembatas. Jika None, anchor yang dihasilkan secara otomatis akan diterapkan.

disable_custom_kernels (`bool`, *opsional*, defaultnya `True`) : Apakah akan menonaktifkan kernel kustom.

with_box_refine (`bool`, *opsional*, defaultnya `True`) : Apakah akan menerapkan penyempurnaan kotak batas iteratif, di mana setiap lapisan decoder menyempurnakan kotak batas berdasarkan prediksi dari lapisan sebelumnya.

matcher_alpha (`float`, *opsional*, default 0.25) : Parameter alpha yang digunakan oleh Hungarian Matcher.

matcher_gamma (`float`, *opsional*, default 2.0) : Parameter gamma yang digunakan oleh Hungarian Matcher.

matcher_class_cost (`float`, *opsional*, default 2.0) : Bobot relatif dari class loss yang digunakan oleh Hungarian Matcher.

matcher_bbox_cost (`float`, *opsional*, default 5.0) : Bobot relatif dari bounding box loss yang digunakan oleh Hungarian Matcher.

matcher_giou_cost (`float`, *opsional*, default 2.0) : Bobot relatif dari giou loss yang digunakan oleh Hungarian Matcher.

use_focal_loss (`bool`, *opsional*, defaultnya `True`) : Parameter yang menginformasikan apakah focal loss harus digunakan.

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

focal_loss_alpha (`float`, *opsional*, default 0.75) : Parameter alpha yang digunakan untuk menghitung focal loss.

focal_loss_gamma (`float`, *opsional*, default 2.0) : Parameter gamma yang digunakan untuk menghitung focal loss.

weight_loss_vfl (`float`, *opsional*, default 1.0) : Bobot relatif dari varifocal loss dalam object detection loss.

weight_loss_bbox (`float`, *opsional*, default 5.0) : Bobot relatif dari kerugian kotak pembatas L1 dalam kerugian deteksi objek.

weight_loss_giou (`float`, *opsional*, default 2.0) : Bobot relatif dari kerugian IoU umum dalam kerugian deteksi objek.

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

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari RTDetrModel. Kelas ini digunakan untuk membuat instans model Rt Detr sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [PekingU/rtdetr_r50vd](https://huggingface.co/PekingU/rtdetr_r50vd)

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

Contoh:

```python
>>> from transformers import RTDetrConfig, RTDetrModel

>>> # Initializing a RT-DETR configuration
>>> configuration = RTDetrConfig()

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

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

## RTDetrResNetConfig[[transformers.RTDetrResNetConfig]]

#### transformers.RTDetrResNetConfig[[transformers.RTDetrResNetConfig]]

```python
transformers.RTDetrResNetConfig(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, num_channels: int = 3, embedding_size: int = 64, hidden_sizes: list[int] | tuple[int, ...] = (256, 512, 1024, 2048), depths: list[int] | tuple[int, ...] = (3, 4, 6, 3), layer_type: str = 'bottleneck', hidden_act: str = 'relu', downsample_in_first_stage: bool = False, downsample_in_bottleneck: bool = False, _out_features: list[str] | None = None, _out_indices: list[int] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/configuration_rt_detr_resnet.py#L25)

**Parameter:**

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

embedding_size (`int`, *opsional*, defaultnya `64`) : Dimensi dari embeddings dan hidden states.

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *opsional*, defaultnya `(256, 512, 1024, 2048)`) : Dimensi (hidden size) pada setiap tahap model.

depths (`list[int]`, *opsional*, defaultnya `[3, 4, 6, 3]`) : Kedalaman (jumlah lapisan) untuk setiap tahap.

layer_type (`str`, *opsional*, defaultnya `"bottleneck"`) : Lapisan yang akan digunakan, bisa berupa `"basic"` (dipakai untuk model yang lebih kecil, seperti resnet-18 atau resnet-34) atau `"bottleneck"` (dipakai untuk model yang lebih besar seperti resnet-50 ke atas).

hidden_act (`str`, *opsional*, defaultnya `"relu"`) : Fungsi aktivasi non-linear di setiap blok. Jika berupa string, `"gelu"`, `"relu"`, `"selu"` dan `"gelu_new"` didukung.

downsample_in_first_stage (`bool`, *opsional*, defaultnya `False`) : Jika `True`, tahap pertama akan melakukan downsampling pada input menggunakan `stride` sebesar 2.

downsample_in_bottleneck (`bool`, *opsional*, defaultnya `False`) : Jika `True`, conv 1x1 pertama di ResNetBottleNeckLayer akan melakukan downsampling pada input menggunakan `stride` sebesar 2.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Rt Detr ResnetModel. Kelas ini digunakan untuk membuat instans model Rt Detr Resnet sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [microsoft/resnet-50](https://huggingface.co/microsoft/resnet-50)

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

Contoh:
```python
>>> from transformers import RTDetrResNetConfig, RTDetrResnetBackbone

>>> # Initializing a ResNet resnet-50 style configuration
>>> configuration = RTDetrResNetConfig()

>>> # Initializing a model (with random weights) from the resnet-50 style configuration
>>> model = RTDetrResnetBackbone(configuration)

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

## RTDetrImageProcessor[[transformers.RTDetrImageProcessor]]

#### transformers.RTDetrImageProcessor[[transformers.RTDetrImageProcessor]]

```python
transformers.RTDetrImageProcessor(**kwargs: *<class 'transformers.models.rt_detr.image_processing_rt_detr.RTDetrImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/image_processing_rt_detr.py#L131)

**Parameter:**

do_convert_rgb (`bool`, *kwargs*, *opsional*) : Apakah akan mengkonversi gambar ke RGB.

do_resize (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan mengubah ukuran gambar.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, defaultnya `{'height' : 640, 'width': 640}`): Menjelaskan dimensi input maksimum ke model.

default_to_square (`bool`, *kwargs*, *opsional*, defaultnya `False`) : Apakah secara default menggunakan gambar persegi saat mengubah ukuran, jika size berupa int.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran gambar keluaran setelah menerapkan `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, defaultnya `2`) : Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enum `PILImageResampling`. Hanya berdampak jika `do_resize` diatur ke `True`.

do_rescale (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan melakukan penskalaan ulang pada gambar.

rescale_factor (`float`, *kwargs*, *opsional*, defaultnya `0.00392156862745098`) : Faktor rescale untuk melakukan rescale pada gambar jika `do_rescale` diatur ke `True`.

do_normalize (`bool`, *kwargs*, *opsional*, defaultnya `False`) : Apakah akan menormalisasi gambar.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*, defaultnya `[0.485, 0.456, 0.406]`) : Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*, defaultnya `[0.229, 0.224, 0.225]`) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

do_pad (`bool`, *kwargs*, *opsional*, defaultnya `False`) : Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran dalam `{"height": int, "width" int}` untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang diberikan untuk pra-pemrosesan. Jika `pad_size` tidak diberikan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan center crop pada gambar.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Hanya `ChannelDimension.FIRST` yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels). - `"none"` atau `ChannelDimension.NONE`: gambar dalam format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Mengembalikan tensor yang ditumpuk jika disetel ke `'pt'`, selain itu mengembalikan daftar tensor.

disable_grouping (`bool`, *kwargs*, *opsional*) : Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan tidak dalam batch. Jika None, akan diset ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opsional*) : Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini sebaiknya diatur sebagai atribut prosesor pada model-model mendatang.

format (`str`, *kwargs*, *opsional*, defaultnya `AnnotationFormat.COCO_DETECTION`) : Format data anotasi. Salah satu dari "coco_detection" atau "coco_panoptic".

do_convert_annotations (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Mengontrol apakah anotasi akan dikonversi ke format yang diharapkan oleh model RT_DETR. Mengonversi kotak batas ke format `(center_x, center_y, width, height)` dan dalam rentang `[0, 1]`. Dapat ditimpa oleh parameter `do_convert_annotations` pada metode `preprocess`.

Membangun pemroses gambar RTDetrImageProcessor.

#### preprocess[[transformers.RTDetrImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = None, return_segmentation_masks: bool | None = None, masks_path: str | pathlib.Path | None = None, **kwargs: *<class 'transformers.models.rt_detr.image_processing_rt_detr.RTDetrImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/image_processing_rt_detr.py#L370)

**Parameter:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Gambar yang akan dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika memasukkan gambar dengan nilai piksel antara 0 dan 1, atur `do_rescale=False`.

annotations (`AnnotationType` atau `list[AnnotationType]`, *opsional*) : Anotasi yang akan ditransformasikan sesuai dengan padding yang diterapkan pada gambar.

return_segmentation_masks (`bool`, *opsional*, defaultnya `self.return_segmentation_masks`) : Apakah akan mengembalikan masker segmentasi.

masks_path (`str` atau `pathlib.Path`, *opsional*) : Path ke direktori yang berisi mask segmentasi.

do_convert_rgb (`bool`, *kwargs*, *opsional*) : Apakah akan mengkonversi gambar ke RGB.

do_resize (`bool`, *kwargs*, *opsional*) : Apakah akan mengubah ukuran gambar.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Menjelaskan dimensi input maksimum ke model.

default_to_square (`bool`, *kwargs*, *opsional*) : Apakah secara default menggunakan gambar persegi saat mengubah ukuran, jika size berupa int.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran gambar keluaran setelah menerapkan `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filter resampling yang digunakan saat mengubah ukuran gambar. Nilai ini dapat berupa salah satu enum `PILImageResampling`. Hanya berpengaruh jika `do_resize` diatur ke `True`.

do_rescale (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan penskalaan ulang pada gambar.

rescale_factor (`float`, *kwargs*, *opsional*) : Faktor penskalaan ulang untuk menskalakan ulang gambar jika `do_rescale` diatur ke `True`.

do_normalize (`bool`, *kwargs*, *opsional*) : Apakah akan menormalisasi gambar.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*) : Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

do_pad (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan padding pada gambar. Padding dilakukan hingga ukuran terbesar dalam batch atau hingga ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran dalam `{"height": int, "width" int}` untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang diberikan untuk pra-pemrosesan. Jika `pad_size` tidak diberikan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan center crop pada gambar.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Hanya `ChannelDimension.FIRST` yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels). - `"none"` atau `ChannelDimension.NONE`: gambar dalam format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Mengembalikan tensor yang ditumpuk jika disetel ke `'pt'`, selain itu mengembalikan daftar tensor.

disable_grouping (`bool`, *kwargs*, *opsional*) : Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan tidak dalam batch. Jika None, akan diset ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opsional*) : Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini sebaiknya diatur sebagai atribut prosesor pada model-model mendatang.

format (`str`, *kwargs*, *opsional*, defaultnya `AnnotationFormat.COCO_DETECTION`) : Format data anotasi. Salah satu dari "coco_detection" atau "coco_panoptic".

do_convert_annotations (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Mengontrol apakah anotasi akan dikonversi ke format yang diharapkan oleh model RT_DETR. Mengonversi kotak batas ke format `(center_x, center_y, width, height)` dan dalam rentang `[0, 1]`. Dapat ditimpa oleh parameter `do_convert_annotations` pada metode `preprocess`.

**Mengembalikan:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dictionary berisi list/array/tensor yang dikembalikan oleh metode __call__ ('pixel_values', dll.).
- **tensor_type** (`Union[None, str, TensorType]`, *opsional*) -- Anda dapat memberikan tensor_type di sini untuk mengonversi daftar bilangan bulat menjadi Tensor PyTorch/Numpy saat inisialisasi.

#### post_process_object_detection[[transformers.RTDetrImageProcessor.post_process_object_detection]]

```python
post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] = None, use_focal_loss: bool = True)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/image_processing_rt_detr.py#L511)

**Parameter:**

outputs (`DetrObjectDetectionOutput`) : Output mentah dari model.

threshold (`float`, *opsional*, default 0.5) : Ambang batas skor untuk mempertahankan prediksi deteksi objek.

target_sizes (`torch.Tensor` atau `list[tuple[int, int]]`, *opsional*) : Tensor dengan bentuk `(batch_size, 2)` atau daftar tuple (`tuple[int, int]`) yang berisi ukuran target `(height, width)` dari setiap gambar dalam batch. Jika tidak diset, prediksi tidak akan di-resize.

use_focal_loss (`bool` defaultnya `True`) : Variabel yang menginformasikan apakah focal loss digunakan untuk memprediksi output. Jika `True`, sigmoid diterapkan untuk menghitung skor setiap deteksi, selain itu, fungsi softmax digunakan.

**Mengembalikan:** `list[Dict]`

Daftar kamus, di mana setiap kamus berisi skor, label, dan kotak untuk sebuah gambar dalam batch sebagaimana diprediksi oleh model.

Mengonversi output mentah dari [DetrForObjectDetection](/docs/transformers/v5.23.0/id/model_doc/detr#transformers.DetrForObjectDetection) menjadi kotak batas akhir dalam format (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Hanya mendukung PyTorch.

## RTDetrImageProcessorPil[[transformers.RTDetrImageProcessorPil]]

#### transformers.RTDetrImageProcessorPil[[transformers.RTDetrImageProcessorPil]]

```python
transformers.RTDetrImageProcessorPil(**kwargs: *<class 'transformers.models.rt_detr.image_processing_pil_rt_detr.RTDetrImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/image_processing_pil_rt_detr.py#L130)

**Parameter:**

do_convert_rgb (`bool`, *kwargs*, *opsional*) : Apakah akan mengkonversi gambar ke RGB.

do_resize (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan mengubah ukuran gambar.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, defaultnya `{'height' : 640, 'width': 640}`): Menjelaskan dimensi input maksimum ke model.

default_to_square (`bool`, *kwargs*, *opsional*, defaultnya `False`) : Apakah secara default menggunakan gambar persegi saat mengubah ukuran, jika size berupa int.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran gambar keluaran setelah menerapkan `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, defaultnya `2`) : Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enum `PILImageResampling`. Hanya berdampak jika `do_resize` diatur ke `True`.

do_rescale (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan melakukan penskalaan ulang pada gambar.

rescale_factor (`float`, *kwargs*, *opsional*, defaultnya `0.00392156862745098`) : Faktor rescale untuk melakukan rescale pada gambar jika `do_rescale` diatur ke `True`.

do_normalize (`bool`, *kwargs*, *opsional*, defaultnya `False`) : Apakah akan menormalisasi gambar.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*, defaultnya `[0.485, 0.456, 0.406]`) : Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*, defaultnya `[0.229, 0.224, 0.225]`) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

do_pad (`bool`, *kwargs*, *opsional*, defaultnya `False`) : Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran dalam `{"height": int, "width" int}` untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang diberikan untuk pra-pemrosesan. Jika `pad_size` tidak diberikan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan center crop pada gambar.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Hanya `ChannelDimension.FIRST` yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels). - `"none"` atau `ChannelDimension.NONE`: gambar dalam format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Mengembalikan tensor yang ditumpuk jika disetel ke `'pt'`, selain itu mengembalikan daftar tensor.

disable_grouping (`bool`, *kwargs*, *opsional*) : Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan tidak dalam batch. Jika None, akan diset ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opsional*) : Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini sebaiknya diatur sebagai atribut prosesor pada model-model mendatang.

format (`str`, *kwargs*, *opsional*, defaultnya `AnnotationFormat.COCO_DETECTION`) : Format data anotasi. Salah satu dari "coco_detection" atau "coco_panoptic".

do_convert_annotations (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Mengontrol apakah anotasi akan dikonversi ke format yang diharapkan oleh model RT_DETR. Mengonversi kotak batas ke format `(center_x, center_y, width, height)` dan dalam rentang `[0, 1]`. Dapat ditimpa oleh parameter `do_convert_annotations` pada metode `preprocess`.

Membangun pemroses gambar RTDetrImageProcessor.

#### preprocess[[transformers.RTDetrImageProcessorPil.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = None, return_segmentation_masks: bool | None = None, masks_path: str | pathlib.Path | None = None, **kwargs: *<class 'transformers.models.rt_detr.image_processing_pil_rt_detr.RTDetrImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/image_processing_pil_rt_detr.py#L379)

**Parameter:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Gambar yang akan dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika memasukkan gambar dengan nilai piksel antara 0 dan 1, atur `do_rescale=False`.

annotations (`AnnotationType` atau `list[AnnotationType]`, *opsional*) : Anotasi yang akan ditransformasikan sesuai dengan padding yang diterapkan pada gambar.

return_segmentation_masks (`bool`, *opsional*, defaultnya `self.return_segmentation_masks`) : Apakah akan mengembalikan masker segmentasi.

masks_path (`str` atau `pathlib.Path`, *opsional*) : Path ke direktori yang berisi mask segmentasi.

do_convert_rgb (`bool`, *kwargs*, *opsional*) : Apakah akan mengkonversi gambar ke RGB.

do_resize (`bool`, *kwargs*, *opsional*) : Apakah akan mengubah ukuran gambar.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Menjelaskan dimensi input maksimum ke model.

default_to_square (`bool`, *kwargs*, *opsional*) : Apakah secara default menggunakan gambar persegi saat mengubah ukuran, jika size berupa int.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran gambar keluaran setelah menerapkan `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filter resampling yang digunakan saat mengubah ukuran gambar. Nilai ini dapat berupa salah satu enum `PILImageResampling`. Hanya berpengaruh jika `do_resize` diatur ke `True`.

do_rescale (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan penskalaan ulang pada gambar.

rescale_factor (`float`, *kwargs*, *opsional*) : Faktor penskalaan ulang untuk menskalakan ulang gambar jika `do_rescale` diatur ke `True`.

do_normalize (`bool`, *kwargs*, *opsional*) : Apakah akan menormalisasi gambar.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*) : Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

do_pad (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan padding pada gambar. Padding dilakukan hingga ukuran terbesar dalam batch atau hingga ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran dalam `{"height": int, "width" int}` untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang diberikan untuk pra-pemrosesan. Jika `pad_size` tidak diberikan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan center crop pada gambar.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Hanya `ChannelDimension.FIRST` yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels). - `"none"` atau `ChannelDimension.NONE`: gambar dalam format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Mengembalikan tensor yang ditumpuk jika disetel ke `'pt'`, selain itu mengembalikan daftar tensor.

disable_grouping (`bool`, *kwargs*, *opsional*) : Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan tidak dalam batch. Jika None, akan diset ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opsional*) : Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini sebaiknya diatur sebagai atribut prosesor pada model-model mendatang.

format (`str`, *kwargs*, *opsional*, defaultnya `AnnotationFormat.COCO_DETECTION`) : Format data anotasi. Salah satu dari "coco_detection" atau "coco_panoptic".

do_convert_annotations (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Mengontrol apakah anotasi akan dikonversi ke format yang diharapkan oleh model RT_DETR. Mengonversi kotak batas ke format `(center_x, center_y, width, height)` dan dalam rentang `[0, 1]`. Dapat ditimpa oleh parameter `do_convert_annotations` pada metode `preprocess`.

**Mengembalikan:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dictionary berisi list/array/tensor yang dikembalikan oleh metode __call__ ('pixel_values', dll.).
- **tensor_type** (`Union[None, str, TensorType]`, *opsional*) -- Anda dapat memberikan tensor_type di sini untuk mengonversi daftar bilangan bulat menjadi Tensor PyTorch/Numpy saat inisialisasi.

#### post_process_object_detection[[transformers.RTDetrImageProcessorPil.post_process_object_detection]]

```python
post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] = None, use_focal_loss: bool = True)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/image_processing_pil_rt_detr.py#L507)

**Parameter:**

outputs (`DetrObjectDetectionOutput`) : Output mentah dari model.

threshold (`float`, *opsional*, default 0.5) : Ambang batas skor untuk mempertahankan prediksi deteksi objek.

target_sizes (`torch.Tensor` atau `list[tuple[int, int]]`, *opsional*) : Tensor dengan bentuk `(batch_size, 2)` atau daftar tuple (`tuple[int, int]`) yang berisi ukuran target `(height, width)` dari setiap gambar dalam batch. Jika tidak diset, prediksi tidak akan di-resize.

use_focal_loss (`bool` defaultnya `True`) : Variabel yang menginformasikan apakah focal loss digunakan untuk memprediksi output. Jika `True`, sigmoid diterapkan untuk menghitung skor setiap deteksi, selain itu, fungsi softmax digunakan.

**Mengembalikan:** `list[Dict]`

Daftar kamus, di mana setiap kamus berisi skor, label, dan kotak untuk sebuah gambar dalam batch sebagaimana diprediksi oleh model.

Mengonversi output mentah dari [DetrForObjectDetection](/docs/transformers/v5.23.0/id/model_doc/detr#transformers.DetrForObjectDetection) menjadi kotak batas akhir dalam format (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Hanya mendukung PyTorch.

## RTDetrModel[[transformers.RTDetrModel]]

#### transformers.RTDetrModel[[transformers.RTDetrModel]]

```python
transformers.RTDetrModel(config: RTDetrConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/modeling_rt_detr.py#L1424)

**Parameter:**

config ([RTDetrConfig](/docs/transformers/v5.23.0/id/model_doc/rt_detr#transformers.RTDetrConfig)) : 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/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model RT-DETR (terdiri dari backbone dan encoder-decoder) yang menghasilkan raw hidden states tanpa head di atasnya.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/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.RTDetrModel.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/modeling_rt_detr.py#L1544)

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

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.

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

Sebuah `RTDetrModelOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi (`None`) dan input.

Metode forward dari [RTDetrModel](/docs/transformers/v5.23.0/id/model_doc/rt_detr#transformers.RTDetrModel) 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, num_queries, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir dari decoder 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_logits** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, sequence_length, config.num_labels)`) -- Logit perantara bertumpuk (logit dari setiap lapisan 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).
- **intermediate_predicted_corners** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, num_queries, 4)`) -- Sudut prediksi antara yang ditumpuk (sudut prediksi dari setiap lapisan decoder).
- **initial_reference_points** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, 4)`) -- Titik referensi awal yang digunakan untuk lapisan decoder pertama.
- **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.
- **init_reference_points** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, 4)`) -- Titik referensi awal yang dikirim melalui decoder Transformer.
- **enc_topk_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.num_labels)`) -- Skor kotak pembatas yang diprediksi, di mana `config.two_stage_num_proposals` kotak pembatas dengan skor tertinggi dipilih sebagai usulan wilayah pada tahap encoder. Output dari klasifikasi biner kotak pembatas (yaitu latar depan dan latar belakang).
- **enc_topk_bboxes** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, 4)`) -- Logits dari koordinat kotak pembatas (bounding box) yang diprediksi pada tahap encoder.
- **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.
- **denoising_meta_values** (`dict`, *opsional*) -- Kamus tambahan untuk nilai-nilai terkait denoising.

Contoh:

```python
>>> from transformers import AutoImageProcessor, RTDetrModel
>>> 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("PekingU/rtdetr_r50vd")
>>> model = RTDetrModel.from_pretrained("PekingU/rtdetr_r50vd")

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

## RTDetrForObjectDetection[[transformers.RTDetrForObjectDetection]]

#### transformers.RTDetrForObjectDetection[[transformers.RTDetrForObjectDetection]]

```python
transformers.RTDetrForObjectDetection(config: RTDetrConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/modeling_rt_detr.py#L1750)

**Parameter:**

config ([RTDetrConfig](/docs/transformers/v5.23.0/id/model_doc/rt_detr#transformers.RTDetrConfig)) : 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/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model RT-DETR (terdiri dari backbone dan encoder-decoder) yang menghasilkan bounding box dan logits untuk kemudian didekodekan menjadi skor dan kelas.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/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.RTDetrForObjectDetection.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/modeling_rt_detr.py#L1771)

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

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.

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

Sebuah `RTDetrObjectDetectionOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi (`None`) dan input.

Metode forward dari [RTDetrForObjectDetection](/docs/transformers/v5.23.0/id/model_doc/rt_detr#transformers.RTDetrForObjectDetection) 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 [post_process_object_detection()](/docs/transformers/v5.23.0/id/model_doc/rt_detr#transformers.RTDetrImageProcessor.post_process_object_detection) untuk mengambil kotak batas yang tidak dinormalisasi (absolut).
- **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, num_queries, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir dari decoder 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_logits** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, num_queries, config.num_labels)`) -- Logit perantara bertumpuk (logit 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).
- **intermediate_predicted_corners** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, num_queries, 4)`) -- Sudut prediksi antara yang ditumpuk (sudut prediksi dari setiap lapisan decoder).
- **initial_reference_points** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, num_queries, 4)`) -- Titik referensi awal yang ditumpuk (titik referensi awal dari setiap lapisan decoder).
- **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.
- **init_reference_points** (`torch.Tensor` dengan bentuk  `(batch_size, num_queries, 4)`) -- Titik referensi awal yang dikirim melalui decoder Transformer.
- **enc_topk_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.num_labels)`, *opsional*, dikembalikan ketika `config.with_box_refine=True` dan `config.two_stage=True`) -- Logits dari koordinat bounding box yang diprediksi di encoder.
- **enc_topk_bboxes** (`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 di encoder.
- **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.
- **denoising_meta_values** (`dict`, *opsional*) -- Kamus tambahan untuk nilai-nilai terkait denoising

Contoh:

```python
>>> from transformers import RTDetrImageProcessor, RTDetrForObjectDetection
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> import torch

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

>>> image_processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd")
>>> model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd")

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

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

>>> logits = outputs.logits
>>> list(logits.shape)
[1, 300, 80]

>>> boxes = outputs.pred_boxes
>>> list(boxes.shape)
[1, 300, 4]

>>> # 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.9, 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 sofa with confidence 0.97 at location [0.14, 0.38, 640.13, 476.21]
Detected cat with confidence 0.96 at location [343.38, 24.28, 640.14, 371.5]
Detected cat with confidence 0.958 at location [13.23, 54.18, 318.98, 472.22]
Detected remote with confidence 0.951 at location [40.11, 73.44, 175.96, 118.48]
Detected remote with confidence 0.924 at location [333.73, 76.58, 369.97, 186.99]
```

## RTDetrResNetBackbone[[transformers.RTDetrResNetBackbone]]

#### transformers.RTDetrResNetBackbone[[transformers.RTDetrResNetBackbone]]

```python
transformers.RTDetrResNetBackbone(config: RTDetrResNetConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/modeling_rt_detr_resnet.py#L349)

**Parameter:**

config ([RTDetrResNetConfig](/docs/transformers/v5.23.0/id/model_doc/rt_detr#transformers.RTDetrResNetConfig)) : 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/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Backbone ResNet, untuk digunakan dengan framework seperti RTDETR.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/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.RTDetrResNetBackbone.forward]]

```python
forward(pixel_values: Tensor, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/modeling_rt_detr_resnet.py#L362)

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

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/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

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

`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 ([RTDetrResNetConfig](/docs/transformers/v5.23.0/id/model_doc/rt_detr#transformers.RTDetrResNetConfig)) dan input.

Metode forward dari [RTDetrResNetBackbone](/docs/transformers/v5.23.0/id/model_doc/rt_detr#transformers.RTDetrResNetBackbone) 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 RTDetrResNetConfig, RTDetrResNetBackbone
  >>> import torch
  precation import deprecate_kwarg
  precation import deprecate_kwarg
  precation import deprecate_kwarg
  utils.deprecation import deprecate_kwarg
  utils.deprecation import deprecate_kwarg

  >>> config = RTDetrResNetConfig()
  >>> model = RTDetrResNetBackbone(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, 2048, 7, 7]
  ```

