# DETR Kondisional

## Ikhtisar

Model Conditional DETR diusulkan dalam [Conditional DETR for Fast Training Convergence](https://huggingface.co/papers/2108.06152) oleh Depu Meng, Xiaokang Chen, Zejia Fan, Gang Zeng, Houqiang Li, Yuhui Yuan, Lei Sun, Jingdong Wang. Conditional DETR memperkenalkan mekanisme cross-attention bersyarat untuk pelatihan DETR yang cepat. Conditional DETR konvergen 6,7× hingga 10× lebih cepat daripada DETR.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Pendekatan DETR yang baru dikembangkan menerapkan arsitektur encoder dan decoder transformer untuk deteksi objek dan mencapai kinerja yang menjanjikan. Dalam makalah ini, kami menangani masalah kritis, yaitu konvergensi pelatihan yang lambat, dan menyajikan mekanisme cross-attention bersyarat untuk pelatihan DETR yang cepat. Pendekatan kami dimotivasi oleh fakta bahwa cross-attention dalam DETR sangat bergantung pada embedding konten untuk melokalisasi empat titik ekstrem dan memprediksi kotak, yang meningkatkan kebutuhan akan embedding konten berkualitas tinggi dan dengan demikian meningkatkan kesulitan pelatihan. Pendekatan kami, yang disebut conditional DETR, mempelajari kueri spasial bersyarat dari embedding decoder untuk multi-head cross-attention decoder. Manfaatnya adalah bahwa melalui kueri spasial bersyarat, setiap head cross-attention mampu memperhatikan pita yang berisi wilayah yang berbeda, misalnya satu titik ekstrem objek atau wilayah di dalam kotak objek. Ini menyempitkan rentang spasial untuk melokalisasi wilayah yang berbeda untuk klasifikasi objek dan regresi kotak, sehingga mengurangi ketergantungan pada embedding konten dan memudahkan pelatihan. Hasil empiris menunjukkan bahwa conditional DETR berkonvergensi 6,7× lebih cepat untuk backbone R50 dan R101 dan 10× lebih cepat untuk backbone yang lebih kuat DC5-R50 dan DC5-R101. Kode tersedia di https://github.com/Atten4Vis/ConditionalDETR.*

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

 Conditional DETR menunjukkan konvergensi yang jauh lebih cepat dibandingkan dengan DETR asli. Diambil dari paper aslinya.

Model ini disumbangkan oleh [DepuMeng](https://huggingface.co/DepuMeng). Kode aslinya dapat ditemukan [di sini](https://github.com/Atten4Vis/ConditionalDETR).

## Sumber daya

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

## ConditionalDetrConfig[[transformers.ConditionalDetrConfig]]

#### transformers.ConditionalDetrConfig[[transformers.ConditionalDetrConfig]]

```python
transformers.ConditionalDetrConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, num_channels: int = 3, num_queries: int = 300, encoder_layers: int = 6, encoder_ffn_dim: int = 2048, encoder_attention_heads: int = 8, decoder_layers: int = 6, decoder_ffn_dim: int = 2048, decoder_attention_heads: int = 8, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, activation_function: str = 'relu', d_model: int = 256, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, init_xavier_std: float = 1.0, auxiliary_loss: bool = False, position_embedding_type: str = 'sine', dilation: bool = False, class_cost: int = 2, bbox_cost: int = 5, giou_cost: int = 2, mask_loss_coefficient: int = 1, dice_loss_coefficient: int = 1, cls_loss_coefficient: int = 2, bbox_loss_coefficient: int = 5, giou_loss_coefficient: int = 2, focal_alpha: float = 0.25)
```

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

**Parameter:**

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

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

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

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

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

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

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

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

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

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

encoder_layerdrop (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Probabilitas LayerDrop untuk encoder. Lihat [makalah LayerDrop](see https://huggingface.co/papers/1909.11556) untuk detail lebih lanjut.

decoder_layerdrop (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Probabilitas LayerDrop untuk decoder. Lihat [makalah LayerDrop](see https://huggingface.co/papers/1909.11556) untuk detail lebih lanjut.

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

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

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

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

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

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

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

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

position_embedding_type (`str`, *opsional*, defaultnya `"sine"`) : Jenis position embeddings yang akan digunakan di atas fitur gambar. Salah satu dari `"sine"` atau `"learned"`.

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

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

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

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

mask_loss_coefficient (`int`, *opsional*, defaultnya `1`) : Bobot relatif dari focal loss dalam loss segmentasi panoptik.

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

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

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

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

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

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari ConditionalDetrModel. Kelas ini digunakan untuk membuat model Conditional Detr sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [microsoft/conditional-detr-resnet-50](https://huggingface.co/microsoft/conditional-detr-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 ConditionalDetrConfig, ConditionalDetrModel

>>> # Initializing a Conditional DETR microsoft/conditional-detr-resnet-50 style configuration
>>> configuration = ConditionalDetrConfig()

>>> # Initializing a model (with random weights) from the microsoft/conditional-detr-resnet-50 style configuration
>>> model = ConditionalDetrModel(configuration)

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

## ConditionalDetrImageProcessor[[transformers.ConditionalDetrImageProcessor]]

#### transformers.ConditionalDetrImageProcessor[[transformers.ConditionalDetrImageProcessor]]

```python
transformers.ConditionalDetrImageProcessor(**kwargs: *<class 'transformers.models.conditional_detr.image_processing_conditional_detr.ConditionalDetrImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/image_processing_conditional_detr.py#L428)

**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 CONDITIONAL_DETR. Mengonversi kotak batas ke format `(center_x, center_y, width, height)` dan dalam rentang `[0, 1]`. Dapat ditimpa oleh parameter `do_convert_annotations` di metode `preprocess`.

Membangun pemroses gambar ConditionalDetrImageProcessor.

#### preprocess[[transformers.ConditionalDetrImageProcessor.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.conditional_detr.image_processing_conditional_detr.ConditionalDetrImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/image_processing_conditional_detr.py#L683)

**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 CONDITIONAL_DETR. Mengonversi kotak batas ke format `(center_x, center_y, width, height)` dan dalam rentang `[0, 1]`. Dapat ditimpa oleh parameter `do_convert_annotations` di 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.

## ConditionalDetrImageProcessorPil[[transformers.ConditionalDetrImageProcessorPil]]

#### transformers.ConditionalDetrImageProcessorPil[[transformers.ConditionalDetrImageProcessorPil]]

```python
transformers.ConditionalDetrImageProcessorPil(**kwargs: *<class 'transformers.models.conditional_detr.image_processing_pil_conditional_detr.ConditionalDetrImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/image_processing_pil_conditional_detr.py#L429)

**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 CONDITIONAL_DETR. Mengonversi kotak batas ke format `(center_x, center_y, width, height)` dan dalam rentang `[0, 1]`. Dapat ditimpa oleh parameter `do_convert_annotations` di metode `preprocess`.

Membangun pemroses gambar ConditionalDetrImageProcessor.

#### preprocess[[transformers.ConditionalDetrImageProcessorPil.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.conditional_detr.image_processing_pil_conditional_detr.ConditionalDetrImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/image_processing_pil_conditional_detr.py#L697)

**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 CONDITIONAL_DETR. Mengonversi kotak batas ke format `(center_x, center_y, width, height)` dan dalam rentang `[0, 1]`. Dapat ditimpa oleh parameter `do_convert_annotations` di 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.ConditionalDetrImageProcessorPil.post_process_object_detection]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/image_processing_pil_conditional_detr.py#L842)

**Parameter:**

outputs (`ConditionalDetrObjectDetectionOutput`) : 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 (tinggi, lebar) dari setiap gambar dalam batch. Jika dibiarkan None, prediksi tidak akan di-resize.

top_k (`int`, *opsional*, default 100) : Simpan hanya k bounding box teratas sebelum penyaringan dengan ambang batas.

**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 [ConditionalDetrForObjectDetection](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrForObjectDetection) 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.ConditionalDetrImageProcessorPil.post_process_instance_segmentation]]

```python
post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool | None = False)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/image_processing_pil_conditional_detr.py#L974)

**Parameter:**

outputs ([ConditionalDetrForSegmentation](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrForSegmentation)) : Output mentah dari model.

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

mask_threshold (`float`, *opsional*, default 0.5) : Ambang batas yang digunakan saat mengubah maska prediksi menjadi nilai biner.

overlap_mask_area_threshold (`float`, *opsional*, default 0.8) : Ambang batas area mask overlap untuk menggabungkan atau membuang bagian kecil yang terputus di dalam setiap mask instance biner.

target_sizes (`list[Tuple]`, *opsional*) : Daftar dengan panjang (batch_size), di mana setiap item daftar (`tuple[int, int]]`) sesuai dengan ukuran akhir (tinggi, lebar) yang diminta untuk setiap prediksi. Jika tidak disetel, prediksi tidak akan di-resize.

return_coco_annotation (`bool`, *opsional*) : Bawaan adalah `False`. Jika diatur ke `True`, peta segmentasi dikembalikan dalam format pengkodean panjang-runtun (run-length encoding) COCO (RLE).

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

Daftar kamus, satu per gambar, di mana setiap kamus berisi dua kunci:
- **segmentation** -- Tensor dengan bentuk `(height, width)` di mana setiap piksel merepresentasikan `segment_id` atau `list[List]` run-length encoding (RLE) dari peta segmentasi jika return_coco_annotation diatur ke `True`. Diatur ke `None` jika tidak ada mask yang ditemukan di atas `threshold`.
- **segments_info** -- Kamus yang berisi informasi tambahan untuk setiap segmen.
  - **id** -- Bilangan bulat yang merepresentasikan `segment_id`.
  - **label_id** -- Bilangan bulat yang mewakili id label/kelas semantik yang sesuai dengan `segment_id`.
  - **score** -- Skor prediksi segmen dengan `segment_id`.

Mengonversi output dari [ConditionalDetrForSegmentation](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrForSegmentation) menjadi prediksi segmentasi instance. Hanya mendukung PyTorch.

#### post_process_semantic_segmentation[[transformers.ConditionalDetrImageProcessorPil.post_process_semantic_segmentation]]

```python
post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, return_segmentation_scores: bool = False)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/image_processing_pil_conditional_detr.py#L902)

**Parameter:**

outputs ([ConditionalDetrForSegmentation](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrForSegmentation)) : Output mentah dari model.

target_sizes (`list[tuple[int, int]]`, *opsional*) : Daftar tuple (`tuple[int, int]`) yang berisi ukuran target (tinggi, lebar) dari setiap gambar dalam batch. Jika tidak disetel, prediksi tidak akan di-resize.

return_segmentation_scores (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengembalikan skor segmentasi bersama dengan peta segmentasi. Ketika `True`, setiap elemen dari daftar yang dikembalikan adalah `SemanticSegmentationPostProcessorOutput` dengan field `segmentation` (ID kelas, bentuk `(height, width)`) dan `segmentation_scores` (bentuk `(num_classes, height, width)`).

**Mengembalikan:** `list[torch.Tensor]` atau `list[SemanticSegmentationPostProcessorOutput]`

Ketika `return_segmentation_scores=False` (default), sebuah daftar dengan panjang `batch_size` di mana setiap item adalah peta segmentasi dengan bentuk `(height, width)` berisi ID kelas. Ketika `return_segmentation_scores=True`, sebuah daftar `SemanticSegmentationPostProcessorOutput` dengan bidang `segmentation` (ID kelas, bentuk `(height, width)`) dan `segmentation_scores` (bentuk `(num_classes, height, width)`). Dalam kedua kasus, `(height, width)` sesuai dengan ukuran target (jika `target_sizes` ditentukan).

Mengonversi output dari [ConditionalDetrForSegmentation](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrForSegmentation) menjadi peta segmentasi semantik. Hanya mendukung PyTorch.

#### post_process_panoptic_segmentation[[transformers.ConditionalDetrImageProcessorPil.post_process_panoptic_segmentation]]

```python
post_process_panoptic_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, label_ids_to_fuse: set[int] | None = None, target_sizes: list[tuple[int, int]] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/image_processing_pil_conditional_detr.py#L1058)

**Parameter:**

outputs ([ConditionalDetrForSegmentation](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrForSegmentation)) : Output dari [ConditionalDetrForSegmentation](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrForSegmentation).

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

mask_threshold (`float`, *opsional*, default 0.5) : Ambang batas yang digunakan saat mengubah maska prediksi menjadi nilai biner.

overlap_mask_area_threshold (`float`, *opsional*, default 0.8) : Ambang batas area mask overlap untuk menggabungkan atau membuang bagian kecil yang terputus di dalam setiap mask instance biner.

label_ids_to_fuse (`Set[int]`, *opsional*) : Label pada state ini akan memiliki semua instansnya yang digabungkan menjadi satu. Sebagai contoh, kita bisa mengatakan bahwa hanya bisa ada satu langit dalam sebuah gambar, tetapi beberapa orang, sehingga ID label untuk langit akan ada dalam set tersebut, tetapi tidak untuk orang.

target_sizes (`list[Tuple]`, *opsional*) : Daftar dengan panjang (batch_size), di mana setiap item daftar (`tuple[int, int]]`) sesuai dengan ukuran akhir yang diminta (tinggi, lebar) untuk setiap prediksi dalam batch. Jika tidak disetel, prediksi tidak akan di-resize.

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

Daftar kamus, satu per gambar, di mana setiap kamus berisi dua kunci:
- **segmentation** -- tensor dengan bentuk `(height, width)` di mana setiap piksel merepresentasikan `segment_id` atau `None` jika tidak ada mask yang ditemukan di atas `threshold`. Jika `target_sizes` ditentukan, segmentation akan di-resize ke entri `target_sizes` yang sesuai.
- **segments_info** -- Kamus yang berisi informasi tambahan untuk setiap segmen.
  - **id** -- bilangan bulat yang merepresentasikan `segment_id`.
  - **label_id** -- Bilangan bulat yang mewakili id label/kelas semantik yang sesuai dengan `segment_id`.
  - **was_fused** -- sebuah boolean, `True` jika `label_id` ada di dalam `label_ids_to_fuse`, `False` jika tidak. Beberapa instans dari kelas / label yang sama telah digabungkan dan diberikan satu `segment_id`.
  - **score** -- Skor prediksi segmen dengan `segment_id`.

Mengonversi output dari [ConditionalDetrForSegmentation](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrForSegmentation) menjadi prediksi segmentasi panoptik gambar. Hanya mendukung PyTorch.

## ConditionalDetrModel[[transformers.ConditionalDetrModel]]

#### transformers.ConditionalDetrModel[[transformers.ConditionalDetrModel]]

```python
transformers.ConditionalDetrModel(config: ConditionalDetrConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/modeling_conditional_detr.py#L1337)

**Parameter:**

config ([ConditionalDetrConfig](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrConfig)) : 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 CONDITIONAL_DETR polos (terdiri dari backbone dan Transformer encoder-decoder) 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.ConditionalDetrModel.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/modeling_conditional_detr.py#L1366)

**Parameter:**

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

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

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

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

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

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

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

A `ConditionalDetrModelOutput` 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 [ConditionalDetrModel](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrModel) menimpa metode khusus `__call__`.

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

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

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

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

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

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

  Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
- **encoder_last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran lapisan terakhir dari encoder model.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_hidden_states=True` diteruskan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

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

  Bobot perhatian dari encoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **intermediate_hidden_states** (`torch.Tensor` dengan bentuk `(config.decoder_layers, batch_size, sequence_length, hidden_size)`, *opsional*, dikembalikan ketika `config.auxiliary_loss=True`) -- Aktivasi decoder antara, yaitu keluaran dari setiap lapisan decoder, di mana masing-masing telah melewati layernorm.
- **reference_points** (`torch.Tensor` dengan bentuk `(config.decoder_layers, batch_size, num_queries, 2 (anchor points))`) -- Titik referensi (titik referensi untuk setiap lapisan decoder).

Contoh:

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/conditional-detr-resnet-50")
>>> model = AutoModel.from_pretrained("microsoft/conditional-detr-resnet-50")

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

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

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

## ConditionalDetrForObjectDetection[[transformers.ConditionalDetrForObjectDetection]]

#### transformers.ConditionalDetrForObjectDetection[[transformers.ConditionalDetrForObjectDetection]]

```python
transformers.ConditionalDetrForObjectDetection(config: ConditionalDetrConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/modeling_conditional_detr.py#L1509)

**Parameter:**

config ([ConditionalDetrConfig](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrConfig)) : 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 CONDITIONAL_DETR (terdiri dari backbone dan Transformer encoder-decoder) dengan kepala deteksi objek di atasnya, untuk tugas seperti deteksi COCO.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/modeling_conditional_detr.py#L1523)

**Parameter:**

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

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

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

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

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

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

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

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

Sebuah `ConditionalDetrObjectDetectionOutput` 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 [ConditionalDetrForObjectDetection](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrForObjectDetection) 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()` untuk mengambil kotak pembatas yang tidak dinormalisasi.
- **auxiliary_outputs** (`list[Dict]`, *opsional*) -- Opsional, hanya dikembalikan ketika auxiliary losses diaktifkan (yaitu `config.auxiliary_loss` diatur ke `True`) dan label disediakan. Ini adalah daftar kamus yang berisi dua kunci di atas (`logits` dan `pred_boxes`) untuk setiap lapisan decoder.
- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran lapisan terakhir dari decoder model.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

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

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

  Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
- **encoder_last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran lapisan terakhir dari encoder model.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

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

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

Contoh:

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/conditional-detr-resnet-50")
>>> model = AutoModelForObjectDetection.from_pretrained("microsoft/conditional-detr-resnet-50")

>>> 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 remote with confidence 0.833 at location [38.31, 72.1, 177.63, 118.45]
Detected cat with confidence 0.831 at location [9.2, 51.38, 321.13, 469.0]
Detected cat with confidence 0.804 at location [340.3, 16.85, 642.93, 370.95]
Detected remote with confidence 0.683 at location [334.48, 73.49, 366.37, 190.01]
Detected couch with confidence 0.535 at location [0.52, 1.19, 640.35, 475.1]
```

## ConditionalDetrForSegmentation[[transformers.ConditionalDetrForSegmentation]]

#### transformers.ConditionalDetrForSegmentation[[transformers.ConditionalDetrForSegmentation]]

```python
transformers.ConditionalDetrForSegmentation(config: ConditionalDetrConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/modeling_conditional_detr.py#L1650)

**Parameter:**

config ([ConditionalDetrConfig](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrConfig)) : 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 CONDITIONAL_DETR (terdiri dari backbone dan Transformer encoder-decoder) dengan head segmentasi di atasnya, untuk tugas seperti COCO panoptic.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/conditional_detr/modeling_conditional_detr.py#L1672)

**Parameter:**

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

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

decoder_attention_mask (`torch.Tensor` dengan bentuk `(batch_size, num_queries)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada query objek tertentu di decoder. Nilai mask yang dipilih dalam `[0, 1]`: - 1 untuk query yang **tidak di-mask**, - 0 untuk query yang **di-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*) : Dipertahankan untuk kompatibilitas mundur, tetapi tidak dapat digunakan untuk segmentasi, karena segmentasi memerlukan fitur multi-skala dari backbone yang tidak tersedia saat melewati backbone dengan inputs_embeds.

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

labels (`list[Dict]` dengan panjang `(batch_size,)`, *opsional*) : Label untuk menghitung bipartite matching loss, DICE/F-1 loss, dan Focal loss. Daftar dari dict, di mana setiap dictionary memuat setidaknya 3 kunci berikut: 'class_labels', 'boxes', dan 'masks' (masing-masing berisi class labels, bounding boxes, dan segmentation masks dari sebuah gambar dalam batch). Class labels itu sendiri harus berupa `torch.LongTensor` dengan panjang `(number of bounding boxes in the image,)`, boxes berupa `torch.Tensor` dengan bentuk `(number of bounding boxes in the image, 4)`, dan masks berupa `torch.Tensor` dengan bentuk `(number of bounding boxes in the image, height, width)`.

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

Sebuah `ConditionalDetrSegmentationOutput` 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 [ConditionalDetrForSegmentation](/docs/transformers/v5.23.0/id/model_doc/conditional_detr#transformers.ConditionalDetrForSegmentation) 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()` untuk mengambil kotak pembatas yang tidak dinormalisasi.
- **pred_masks** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, height/4, width/4)`) -- Logits mask segmentasi untuk semua query. Lihat juga `post_process_semantic_segmentation()` atau `post_process_instance_segmentation()` `post_process_panoptic_segmentation()` untuk mengevaluasi mask segmentasi semantik, instance, dan panoptik secara masing-masing.
- **auxiliary_outputs** (`list[Dict]`, *opsional*) -- Opsional, hanya dikembalikan ketika auxiliary losses diaktifkan (yaitu `config.auxiliary_loss` diatur ke `True`) dan label disediakan. Ini adalah daftar kamus yang berisi dua kunci di atas (`logits` dan `pred_boxes`) untuk setiap lapisan decoder.
- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran lapisan terakhir dari decoder model.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

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

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

  Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
- **encoder_last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran lapisan terakhir dari encoder model.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

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

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

Contoh:

```python
>>> import io
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image
>>> import torch
>>> import numpy

>>> from transformers import AutoImageProcessor, ConditionalDetrForSegmentation
>>> from transformers.image_transforms import rgb_to_id

>>> 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("facebook/conditional_detr-resnet-50-panoptic")
>>> model = ConditionalDetrForSegmentation.from_pretrained("facebook/conditional_detr-resnet-50-panoptic")

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

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

>>> # Use the `post_process_panoptic_segmentation` method of the `image_processor` to retrieve post-processed panoptic segmentation maps
>>> # Segmentation results are returned as a list of dictionaries
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(300, 500)])

>>> # A tensor of shape (height, width) where each value denotes a segment id, filled with -1 if no segment is found
>>> panoptic_seg = result[0]["segmentation"]
>>> panoptic_seg.shape
torch.Size([300, 500])
>>> # Get prediction score and segment_id to class_id mapping of each segment
>>> panoptic_segments_info = result[0]["segments_info"]
>>> len(panoptic_segments_info)
5
```