# RF-DETR

[RF-DETR](https://github.com/roboflow/rf-detr) mengusulkan arsitektur Receptive Field Detection Transformer (DETR) yang dirancang untuk bersaing dan melampaui seri YOLO yang dominan dalam deteksi objek real-time. Arsitektur 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 RF-DETR ditandai dengan struktur yang sederhana dan efisien: DINOv2 Backbone, Projector, dan DETR Decoder yang dangkal. Arsitektur ini meningkatkan arsitektur DETR untuk efisiensi dan kecepatan menggunakan modifikasi inti berikut:

1. **Backbone DINOv2**: Menggunakan backbone DINOv2 yang kuat untuk ekstraksi fitur yang robust.
2. **Pelatihan Group DETR**: Memanfaatkan Group-Wise One-to-Many Assignment selama pelatihan untuk mempercepat konvergensi.
3. **Input yang Lebih Kaya**: Mengagregasi fitur multi-level dari backbone dan menggunakan C2f Projector (mirip dengan YOLOv8) untuk meneruskan fitur multi-skala.
4. **Faster Decoder**: Menggunakan decoder DETR 3-lapisan yang dangkal dengan deformable cross-attention untuk latensi yang lebih rendah.
5. **Kueri yang Dioptimalkan**: Menggunakan skema kueri campuran yang menggabungkan kueri konten yang dapat dipelajari dan kueri spasial yang dihasilkan.

Anda dapat menemukan semua checkpoint RF-DETR yang tersedia di bawah organisasi [Roboflow](https://huggingface.co/Roboflow). Kode aslinya dapat ditemukan [di sini](https://github.com/roboflow/rf-detr).

Berkat pemetaan konversi bobot, RfDetr kompatibel dengan model dari pustaka [rf-detr](https://github.com/roboflow/rf-detr) asli serta model yang Anda latih menggunakan platform [Roboflow](https://roboflow.com/). Artinya, Anda dapat menggunakan platform Roboflow untuk melatih model Anda dan menggunakan `RfDetr` di `transformers` untuk mengimpor bobot serta mendeploy model Anda di mana saja.

> [!TIP]
>
> Klik pada model RF-DETR di bilah sisi kanan untuk melihat lebih banyak contoh cara menerapkan RF-DETR ke berbagai tugas deteksi objek.

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

```python
from transformers import pipeline
import torch

pipeline = pipeline("object-detection", model="Roboflow/rf-detr-medium", device_map="auto")

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

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

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(BytesIO(httpx.get(url).content))

image_processor = AutoImageProcessor.from_pretrained("Roboflow/rf-detr-medium")
model = AutoModelForObjectDetection.from_pretrained("Roboflow/rf-detr-medium", 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}")
```

### Visualisasi hasil dengan supervisi

Anda dapat menggunakan pustaka [supervision](https://github.com/roboflow/supervision) untuk memvisualisasikan hasil deteksi dan segmentasi. Instal dengan `pip install supervision`.

```python
from transformers import AutoImageProcessor, AutoModelForObjectDetection
from PIL import Image
import supervision as sv

from huggingface_hub.utils import httpx
from io import BytesIO
import torch

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(BytesIO(httpx.get(url).content))

image_processor = AutoImageProcessor.from_pretrained("Roboflow/rf-detr-medium")
model = AutoModelForObjectDetection.from_pretrained("Roboflow/rf-detr-medium", 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
)[0]

detections = sv.Detections.from_transformers(
    transformers_results=results, id2label=model.config.id2label
)

box_annotator = sv.BoxAnnotator()
label_annotator = sv.LabelAnnotator()

annotated_image = image.copy()
annotated_image = box_annotator.annotate(annotated_image, detections)
annotated_image = label_annotator.annotate(annotated_image, detections)

sv.plot_image(annotated_image)
```

```python
from transformers import AutoImageProcessor, AutoModelForInstanceSegmentation
from PIL import Image
import supervision as sv
from huggingface_hub.utils import httpx
from io import BytesIO
import torch

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(BytesIO(httpx.get(url).content))

image_processor = AutoImageProcessor.from_pretrained("Roboflow/rf-detr-seg-medium")
model = AutoModelForInstanceSegmentation.from_pretrained("Roboflow/rf-detr-seg-medium", 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_instance_segmentation(
    outputs, target_sizes=[image.size[::-1]], threshold=0.3
)[0]

detections = sv.Detections.from_transformers(
    transformers_results=results, id2label=model.config.id2label
)

mask_annotator = sv.MaskAnnotator()
label_annotator = sv.LabelAnnotator()

annotated_image = image.copy()
annotated_image = mask_annotator.annotate(annotated_image, detections)
annotated_image = label_annotator.annotate(annotated_image, detections)

sv.plot_image(annotated_image)
```

## Sumber daya

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

## RfDetrConfig[[transformers.RfDetrConfig]]

#### transformers.RfDetrConfig[[transformers.RfDetrConfig]]

```python
transformers.RfDetrConfig(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, hidden_expansion: float = 0.5, c2f_num_blocks: int = 3, activation_function: str = 'silu', dropout: float = 0.1, 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, layer_norm_eps: float = 1e-05, num_feature_levels: int = 1, mask_loss_coefficient: int | float = 1, mask_point_sample_ratio: int = 16, mask_downsample_ratio: int = 4, mask_class_loss_coefficient: int | float = 5.0, mask_dice_loss_coefficient: int | float = 5.0, segmentation_head_activation_function: str = 'gelu', intermediate_size: int = 1024)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/configuration_rf_detr.py#L103)

**Parameter:**

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

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

dropout (`float`, *opsional*, default `0.1`) : Rasio untuk semua lapisan dropout.

decoder_ffn_dim (`int`, *opsional*, defaultnya `2048`) : Dimensi dari 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 decoder di transformer.

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 [RfDetrModel](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrModel) 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 (`float`, *opsional*, default 1) : Bobot relatif dari loss DICE/F-1 dalam loss deteksi objek.

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

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

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.

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

num_feature_levels (`int`, *opsional*, default 1) : Jumlah level fitur yang digunakan dalam perhatian deformabel multiskala.

mask_loss_coefficient (`float`, *opsional*, default 1) : Bobot relatif dari Focal loss dalam loss mask segmentasi instance.

mask_point_sample_ratio (`int`, *opsional*, default 16) : Rasio titik yang akan disampel untuk perhitungan mask loss.

mask_downsample_ratio (`int`, *opsional*, default 4) : Rasio downsampling untuk mask segmentasi dibandingkan resolusi gambar input.

mask_class_loss_coefficient (`float`, *opsional*, default 5.0) : Bobot relatif dari Focal loss dalam loss segmentasi instance.

mask_dice_loss_coefficient (`float`, *opsional*, default 5.0) : Bobot relatif dari loss DICE/F-1 dalam loss segmentasi instance.

segmentation_head_activation_function (`str`, *opsional*, defaultnya `"gelu"`) : Fungsi aktivasi non-linear di kepala segmentasi. Nilai yang didukung adalah `"relu"`, `"silu"`, `"gelu"`.

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

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari RfDetrModel. Kelas ini digunakan untuk membuat instans model Rf Detr sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [Roboflow/rf-detr-base](https://huggingface.co/Roboflow/rf-detr-base)

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 RfDetrConfig, RfDetrModel

>>> # Initializing a RF-DETR roboflow/rf-detr-base style configuration
>>> configuration = RfDetrConfig()

>>> # Initializing a model (with random weights) from the Roboflow/rf-detr-base style configuration
>>> model = RfDetrModel(configuration)

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

## RfDetrDinov2Config[[transformers.RfDetrDinov2Config]]

#### transformers.RfDetrDinov2Config[[transformers.RfDetrDinov2Config]]

```python
transformers.RfDetrDinov2Config(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', hidden_dropout_prob: float | int = 0.0, attention_probs_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] = 224, patch_size: int | list[int] | tuple[int, int] = 14, num_channels: int = 3, qkv_bias: bool = True, layerscale_value: float = 1.0, drop_path_rate: float | int = 0.0, use_swiglu_ffn: bool = False, _out_features: list[str] | None = None, _out_indices: list[int] | None = None, apply_layernorm: bool = True, reshape_hidden_states: bool = True, use_mask_token: bool = True, num_windows: int = 4)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/configuration_rf_detr.py#L30)

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

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

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

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 `224`) : Ukuran (resolusi) dari setiap gambar.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `14`) : 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.

layerscale_value (`float`, *opsional*, default 1.0) : Nilai awal yang digunakan untuk layer scale.

drop_path_rate (`float`, *opsional*, default 0.0) : Tingkat stochastic depth per sampel (ketika diterapkan di jalur utama lapisan residual).

use_swiglu_ffn (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan jaringan saraf feedforward SwiGLU.

apply_layernorm (`bool`, *opsional*, defaultnya `True`) : Apakah akan menerapkan layer normalization ke feature maps jika model digunakan sebagai backbone.

reshape_hidden_states (`bool`, *opsional*, defaultnya `True`) : Apakah akan membentuk ulang peta fitur menjadi tensor 4D dengan bentuk `(batch_size, d_model, height, width)` jika model digunakan sebagai backbone. Jika `False`, peta fitur akan berupa tensor 3D dengan bentuk `(batch_size, seq_len, d_model)`.

use_mask_token (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan mask_token dalam embeddings.

num_windows (`int`, *opsional*, defaultnya 4) : Jumlah jendela yang digunakan untuk windowed attention. Jika 1, windowed attention tidak digunakan.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari RfDetrModel. Kelas ini digunakan untuk membuat instans model Rf Detr sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [Roboflow/rf-detr-base](https://huggingface.co/Roboflow/rf-detr-base)

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 RfDetrDinov2Config, RfDetrDinov2Backbone

>>> # Initializing a RfDetrDinov2 base style configuration
>>> configuration = RfDetrDinov2Config()

>>> # Initializing a model (with random weights) from the base style configuration
>>> model = RfDetrDinov2Backbone(configuration)

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

## RfDetrImageProcessor[[transformers.RfDetrImageProcessor]]

#### transformers.RfDetrImageProcessor[[transformers.RfDetrImageProcessor]]

```python
transformers.RfDetrImageProcessor(**kwargs: *<class 'transformers.models.rf_detr.image_processing_rf_detr.RfDetrImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/image_processing_rf_detr.py#L218)

**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 `{'shortest_edge' : 800, 'longest_edge': 1333}`): 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 `True`) : 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 `True`) : 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 RF_DETR. Mengonversi kotak pembatas 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 RfDetrImageProcessor.

#### preprocess[[transformers.RfDetrImageProcessor.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.rf_detr.image_processing_rf_detr.RfDetrImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/image_processing_rf_detr.py#L464)

**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 RF_DETR. Mengonversi kotak pembatas 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.RfDetrImageProcessor.post_process_object_detection]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/image_processing_rf_detr.py#L606)

**Parameter:**

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

threshold (`float`, *opsional*) : 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.

**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 [RfDetrForObjectDetection](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrForObjectDetection) menjadi kotak batas akhir dalam format (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Hanya mendukung PyTorch.

#### post_process_instance_segmentation[[transformers.RfDetrImageProcessor.post_process_instance_segmentation]]

```python
post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.0, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool = False, return_binary_maps: bool = False, top_k: int | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/image_processing_rf_detr.py#L660)

**Parameter:**

outputs ([*RfDetrInstanceSegmentationOutput*]) : Output mentah dari model.

threshold (*float*, *optional*, default 0.5) : Ambang batas skor untuk mempertahankan mask instance yang diprediksi.

mask_threshold (*float*, *optional*, default 0.0) : Ambang batas untuk mambinarisasi mask prediksi.

target_sizes (*list[tuple[int, int]]*, *opsional*) : Target `(height, width)` untuk setiap gambar. Jika tidak disetel, mask tidak di-resize.

return_coco_annotation (*bool*, *opsional*, default *False*) : Jika *True*, kembalikan peta segmentasi sebagai COCO run-length encoding alih-alih tensor. Saling eksklusif dengan *return_binary_maps*.

return_binary_maps (*bool*, *opsional*, default *False*) : Jika *True*, kembalikan peta segmentasi sebagai tensor bertumpuk dari mask biner instance (satu per instance yang terdeteksi), tanpa resolusi tumpang tindih. Ini sesuai dengan format output dari paket `rfdetr` asli. Saling eksklusif dengan *return_coco_annotation*.

top_k (*int*, *opsional*) : Jumlah maksimum kueri kandidat yang dievaluasi sebelum ambang batas skor. Secara default, sama dengan total jumlah kueri.

**Mengembalikan:** *list[dict]*

Satu dict per gambar dengan kunci:
- **segmentation** -- *Tensor[H, W]* berisi id segmen `int32` (`-1` = latar belakang), *Tensor[num_instances, H, W]* berisi mask biner bool ketika *return_binary_maps=True*, atau daftar enkoding RLE ketika *return_coco_annotation=True*.
- **segments_info** -- Daftar dict dengan kunci `id`, `label_id`, dan `score`.

Mengonversi output dari [*RfDetrForInstanceSegmentation*] menjadi prediksi segmentasi instance.

## RfDetrModel[[transformers.RfDetrModel]]

#### transformers.RfDetrModel[[transformers.RfDetrModel]]

```python
transformers.RfDetrModel(config: RfDetrConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1330)

**Parameter:**

config ([RfDetrConfig](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrConfig)) : 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 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/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.RfDetrModel.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1437)

**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 [RfDetrImageProcessor](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrImageProcessor). Lihat [RfDetrImageProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [RfDetrImageProcessor](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrImageProcessor) 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:** `RfDetrModelOutput` atau `tuple(torch.Tensor)`

Sebuah `RfDetrModelOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([RfDetrConfig](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrConfig)) dan input.

Forward pass dari model RF-DETR. Alur kerja berjalan sebagai berikut:

1. Buatlah set awal dari embedding query objek dan proposal lokasi spasial dari output yang telah diratakan (flattened) dari backbone.
2. Inisialisasi penyimpanan untuk prediksi tahap encoder yang telah disempurnakan (mengakomodasi struktur query multi-grup) dan secara iteratif menyempurnakan query objek beserta koordinatnya untuk setiap grup query guna menangkap kandidat dengan keyakinan tertinggi dari tahap encoder.
3. Inisialisasi fitur query yang dapat dipelajari dan titik referensi spasial (dibatasi pada grup utama selama inferensi untuk efisiensi).
4. Proyeksikan titik referensi dasar di seluruh batch, haluskan dengan penyempurnaan koordinat yang diprediksi (mengalihkan perhatian ke lokasi objek yang ditemukan sebelum decoding), dan perluas fitur query target agar sesuai dengan dimensi batch.
5. Lewatkan kueri yang telah disempurnakan dan titik referensi yang diperbarui melalui transformer decoder untuk mengagregasi konteks spasial yang terperinci dari fitur multi-skala.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran dari lapisan terakhir model.
- **init_reference_points** (`torch.Tensor` dengan bentuk  `(batch_size, num_queries, 4)`) -- Titik referensi awal yang dikirim melalui decoder Transformer.
- **intermediate_hidden_states** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, num_queries, d_model)`) -- 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.
- **backbone_features** (`list` dari `torch.Tensor` dengan bentuk `(batch_size, config.num_channels, config.image_size, config.image_size)`) -- Fitur dari backbone.

Contoh:

```python
>>> from transformers import AutoImageProcessor, RfDetrModel
>>> from PIL import Image
>>> import requests

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

>>> image_processor = AutoImageProcessor.from_pretrained("Roboflow/rf-detr-base")
>>> model = RfDetrModel.from_pretrained("Roboflow/rf-detr-base")

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

>>> outputs = model(**inputs)

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

## RfDetrForObjectDetection[[transformers.RfDetrForObjectDetection]]

#### transformers.RfDetrForObjectDetection[[transformers.RfDetrForObjectDetection]]

```python
transformers.RfDetrForObjectDetection(config: RfDetrConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1678)

**Parameter:**

config ([RfDetrConfig](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrConfig)) : 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 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/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.RfDetrForObjectDetection.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/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1692)

**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 [RfDetrImageProcessor](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrImageProcessor). Lihat [RfDetrImageProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [RfDetrImageProcessor](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrImageProcessor) 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:** `RfDetrObjectDetectionOutput` atau `tuple(torch.Tensor)`

Sebuah `RfDetrObjectDetectionOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([RfDetrConfig](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrConfig)) dan input.

Lalu lintas maju (forward pass) berlangsung sebagai berikut:

1. Proseskan input visual melalui model RF-DETR dasar untuk mendapatkan hidden state terakhir dari transformer dan urutan akhir dari titik referensi.
2. Tahap pertama: Menghasilkan logit klasifikasi dari embedding query objek yang diusulkan oleh encoder.
3. Tahap kedua: Memprediksi label klasifikasi akhir dan kotak pembatas yang disempurnakan menggunakan keadaan tersembunyi terakhir dari decoder dan titik referensi terbaru.

- **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, d_model)`) -- 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.
- **backbone_features** (`list` dari `torch.Tensor` dengan bentuk `(batch_size, config.num_channels, config.image_size, config.image_size)`) -- Fitur dari backbone.

Contoh:

```python
>>> from transformers import AutoImageProcessor, RfDetrForObjectDetection
>>> from PIL import Image
>>> import requests

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

>>> image_processor = AutoImageProcessor.from_pretrained("Roboflow/rf-detr-base")
>>> model = RfDetrForObjectDetection.from_pretrained("Roboflow/rf-detr-base")

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

## RfDetrForInstanceSegmentation[[transformers.RfDetrForInstanceSegmentation]]

#### transformers.RfDetrForInstanceSegmentation[[transformers.RfDetrForInstanceSegmentation]]

```python
transformers.RfDetrForInstanceSegmentation(config: RfDetrConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1938)

#### forward[[transformers.RfDetrForInstanceSegmentation.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/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L2020)

**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 [RfDetrImageProcessor](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrImageProcessor). Lihat [RfDetrImageProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [RfDetrImageProcessor](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrImageProcessor) 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:**

`dict[str, torch.Tensor]`

Forward pass dari model RF-DETR untuk segmentasi instance. Alur kerja berjalan sebagai berikut:

1. Proseskan input visual melalui model RF-DETR dasar untuk memperoleh fitur spasial multi-skala, embedding query, dan riwayat transformasinya.
2. Generate logits klasifikasi dan mask segmentasi awal dari embedding query objek yang diusulkan oleh encoder (tahap pertama).
3. Prediksikan label klasifikasi akhir dan kotak pembatas yang disempurnakan menggunakan keadaan tersembunyi terakhir dari decoder (tahap kedua).
4. Lewatkan fitur spasial resolusi tinggi dan hidden state query melalui kepala segmentasi untuk menghasilkan mask instance akhir yang detail.

## RfDetrDinov2Backbone[[transformers.RfDetrDinov2Backbone]]

#### transformers.RfDetrDinov2Backbone[[transformers.RfDetrDinov2Backbone]]

```python
transformers.RfDetrDinov2Backbone(config: RfDetrDinov2Config)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L473)

**Parameter:**

config ([RfDetrDinov2Config](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrDinov2Config)) : 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 RfDetrDinov2, untuk digunakan dengan framework seperti DETR dan MaskFormer.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L482)

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

**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 ([RfDetrConfig](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrConfig)) dan input.

Metode forward dari [RfDetrDinov2Backbone](/docs/transformers/v5.23.0/id/model_doc/rf_detr#transformers.RfDetrDinov2Backbone) 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 AutoImageProcessor, AutoBackbone
>>> import torch
>>> from PIL import Image
>>> import requests

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

>>> processor = AutoImageProcessor.from_pretrained("facebook/dinov2-base")
>>> model = AutoBackbone.from_pretrained(
...     "facebook/dinov2-base", out_features=["stage2", "stage5", "stage8", "stage11"]
... )

>>> inputs = processor(image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 768, 16, 16]
```

