# DPT

## Ikhtisar

Model DPT diusulkan dalam [Vision Transformers for Dense Prediction](https://huggingface.co/papers/2103.13413) oleh René Ranftl, Alexey Bochkovskiy, Vladlen Koltun. DPT adalah model yang memanfaatkan [Vision Transformer (ViT)](vit) sebagai backbone untuk tugas prediksi padat seperti segmentasi semantik dan estimasi kedalaman.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Kami memperkenalkan dense vision transformers, sebuah arsitektur yang memanfaatkan vision transformers sebagai pengganti jaringan konvolusional sebagai backbone untuk tugas prediksi padat. Kami merangkai token dari berbagai tahap vision transformer menjadi representasi serupa gambar pada berbagai resolusi dan secara bertahap menggabungkannya menjadi prediksi resolusi penuh menggunakan decoder konvolusional. Backbone transformer memproses representasi pada resolusi konstan dan relatif tinggi serta memiliki bidang reseptif global di setiap tahap. Sifat-sifat ini memungkinkan dense vision transformer untuk memberikan prediksi yang lebih rinci dan lebih koheren secara global dibandingkan dengan jaringan konvolusional penuh. Eksperimen kami menunjukkan bahwa arsitektur ini menghasilkan peningkatan substansial pada tugas prediksi padat, terutama ketika sejumlah besar data pelatihan tersedia. Untuk estimasi kedalaman monokular, kami mengamati peningkatan hingga 28% dalam kinerja relatif dibandingkan dengan jaringan konvolusional penuh state-of-the-art. Ketika diterapkan pada segmentasi semantik, dense vision transformers menetapkan state of the art baru pada ADE20K dengan 49,02% mIoU. Kami juga menunjukkan bahwa arsitektur ini dapat dihaluskan (fine-tuned) pada dataset yang lebih kecil seperti NYUv2, KITTI, dan Pascal Context, di mana ia juga menetapkan state of the art baru.*

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

 Arsitektur DPT. Diambil dari paper aslinya.

Model ini disumbangkan oleh [nielsr](https://huggingface.co/nielsr). Kode aslinya dapat ditemukan [di sini](https://github.com/isl-org/DPT).

## Tips penggunaan

DPT kompatibel dengan kelas [AutoBackbone](/docs/transformers/v5.23.0/id/main_classes/backbones#transformers.AutoBackbone). Hal ini memungkinkan Anda menggunakan kerangka kerja DPT dengan berbagai backbone computer vision yang tersedia di pustaka, seperti `VitDetBackbone` atau `Dinov2Backbone`. Anda dapat membuatnya sebagai berikut:

```python
from transformers import Dinov2Config, DPTConfig, DPTForDepthEstimation

# initialize with a Transformer-based backbone such as DINOv2
# in that case, we also specify `reshape_hidden_states=False` to get feature maps of shape (batch_size, num_channels, height, width)
backbone_config = Dinov2Config.from_pretrained("facebook/dinov2-base", out_features=["stage1", "stage2", "stage3", "stage4"], reshape_hidden_states=False)

config = DPTConfig(backbone_config=backbone_config)
model = DPTForDepthEstimation(config=config)
```

## Sumber daya

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

- Notebook demo untuk [DPTForDepthEstimation](/docs/transformers/v5.23.0/id/model_doc/dpt#transformers.DPTForDepthEstimation) dapat ditemukan [di sini](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/DPT).

- [Panduan tugas segmentasi semantik](../tasks/semantic_segmentation)
- [Panduan tugas estimasi kedalaman monokular](../tasks/monocular_depth_estimation)

Jika Anda tertarik untuk mengirimkan sumber daya agar disertakan di sini, silakan buka Pull Request dan kami akan meninjaunya! Sumber daya tersebut sebaiknya mendemonstrasikan sesuatu yang baru, bukan menduplikasi sumber daya yang sudah ada.

## DPTConfig[[transformers.DPTConfig]]

#### transformers.DPTConfig[[transformers.DPTConfig]]

```python
transformers.DPTConfig(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: None | int = 12, num_attention_heads: int | None = 12, intermediate_size: int | None = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int | None = 0.0, attention_probs_dropout_prob: float | int | None = 0.0, initializer_range: float = 0.02, layer_norm_eps: float | None = 1e-12, image_size: int | list[int] | tuple[int, int] | None = 384, patch_size: int | list[int] | tuple[int, int] | None = 16, num_channels: int | None = 3, is_hybrid: bool = False, qkv_bias: bool | None = True, backbone_out_indices: list[int] | tuple[int, ...] | None = (2, 5, 8, 11), readout_type: typing.Literal['ignore', 'add', 'project'] = 'project', reassemble_factors: list[int | float] | tuple[int | float, ...] = (4, 2, 1, 0.5), neck_hidden_sizes: list[int] | tuple[int, ...] = (96, 192, 384, 768), fusion_hidden_size: int = 256, head_in_index: int = -1, use_batch_norm_in_fusion_residual: bool | None = False, use_bias_in_fusion_residual: bool | None = None, add_projection: bool = False, use_auxiliary_head: bool | None = True, auxiliary_loss_weight: float = 0.4, semantic_loss_ignore_index: int = 255, semantic_classifier_dropout: float | int = 0.1, backbone_featmap_shape: list[int] | tuple[int, ...] | None = (1, 1024, 24, 24), neck_ignore_stages: list[int] | tuple[int, ...] = (0, 1), backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pooler_output_size: int | None = None, pooler_act: str = 'tanh')
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/dpt/configuration_dpt.py#L27)

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

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

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

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

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

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

is_hybrid (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan backbone hibrida. Berguna dalam konteks memuat model DPT-Hybrid.

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

backbone_out_indices (`list[int]`, *opsional*, defaultnya `[2, 5, 8, 11]`) : Indeks dari hidden states antara yang akan digunakan dari backbone.

readout_type (`str`, *opsional*, defaultnya `"project"`) : Jenis readout yang digunakan saat memproses readout token (CLS token) dari hidden states antara dari backbone ViT. Bisa berupa salah satu dari [`"ignore"`, `"add"`, `"project"`]. - "ignore" hanya mengabaikan CLS token. - "add" meneruskan informasi dari CLS token ke semua token lain dengan menambahkan representasinya. - "project" meneruskan informasi ke token lain dengan mengonkatenasi readout ke semua token lain sebelum memproyeksikan representasi ke dimensi fitur asli D menggunakan linear layer yang diikuti oleh non-linearity GELU.

reassemble_factors (`list[int]`, *opsional*, defaultnya `[4, 2, 1, 0.5]`) : Faktor up/downsampling dari lapisan reassemble.

neck_hidden_sizes (`list[str]`, *opsional*, defaultnya `[96, 192, 384, 768]`) : Ukuran tersembunyi untuk diproyeksikan ke peta fitur dari backbone.

fusion_hidden_size (`int`, *opsional*, defaultnya 256) : Jumlah channel sebelum fusi.

head_in_index (`int`, *opsional*, defaultnya -1) : Indeks fitur yang akan digunakan di heads.

use_batch_norm_in_fusion_residual (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan batch normalization pada unit residual pre-activate dari blok fusi.

use_bias_in_fusion_residual (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan bias pada unit residual pre-activate dari blok fusi.

add_projection (`bool`, *opsional*, defaultnya `False`) : Apakah akan menambahkan lapisan proyeksi sebelum kepala estimasi kedalaman.

use_auxiliary_head (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan kepala bantu selama pelatihan.

auxiliary_loss_weight (`float`, *opsional*, default 0.4) : Bobot dari cross-entropy loss dari auxiliary head.

semantic_loss_ignore_index (`int`, *opsional*, defaultnya `255`) : Indeks yang diabaikan oleh fungsi loss dari model segmentasi semantik.

semantic_classifier_dropout (`float`, *opsional*, default 0.1) : Rasio dropout untuk kepala klasifikasi semantik.

backbone_featmap_shape (`list[int]`, *opsional*, defaultnya `[1, 1024, 24, 24]`) : Hanya digunakan untuk tipe embedding `hybrid`. Bentuk dari peta fitur backbone.

neck_ignore_stages (`list[int]`, *opsional*, defaultnya `[0, 1]`) : Hanya digunakan untuk tipe embedding `hybrid`. Tahapan dari lapisan readout yang akan diabaikan.

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

pooler_output_size (`int`, *opsional*) : Dimensi dari lapisan pooler. Jika None, defaultnya adalah `hidden_size`.

pooler_act (`str`, *opsional*, defaultnya `"tanh"`) : Fungsi aktivasi yang akan digunakan oleh pooler.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari DPTModel. Kelas ini digunakan untuk membuat instans model Dpt sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [Intel/dpt-large](https://huggingface.co/Intel/dpt-large)

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 DPTModel, DPTConfig

>>> # Initializing a DPT dpt-large style configuration
>>> configuration = DPTConfig()

>>> # Initializing a model from the dpt-large style configuration
>>> model = DPTModel(configuration)

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

## DPTImageProcessor[[transformers.DPTImageProcessor]]

#### transformers.DPTImageProcessor[[transformers.DPTImageProcessor]]

```python
transformers.DPTImageProcessor(**kwargs: *<class 'transformers.models.dpt.image_processing_dpt.DPTImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/dpt/image_processing_dpt.py#L110)

**Parameter:**

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

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

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

default_to_square (`bool`, *kwargs*, *opsional*, defaultnya `True`) : 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*, defaultnya `None`) : Ukuran gambar output setelah menerapkan `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, defaultnya `3`) : 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.5, 0.5, 0.5]`) : 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.5, 0.5, 0.5]`) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

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

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

do_center_crop (`bool`, *kwargs*, *opsional*, defaultnya `None`) : 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.

ensure_multiple_of (`int`, *kwargs*, *opsional*, default 1) : Jika `do_resize` adalah `True`, gambar akan di-resize ke ukuran yang merupakan kelipatan dari nilai ini. Dapat ditimpa oleh `ensure_multiple_of` di `preprocess`.

size_divisor (`int`, *kwargs*) : Ukuran yang memastikan tinggi dan lebar dapat dibagi habis.

keep_aspect_ratio (`bool`, *kwargs*, *opsional*, defaultnya `False`) : Jika `True`, gambar akan di-resize ke ukuran terbesar yang memungkinkan sehingga rasio aspek tetap terjaga. Dapat ditimpa oleh `keep_aspect_ratio` di `preprocess`.

do_reduce_labels (`bool`, *kwargs*, *opsional*, defaultnya `self.do_reduce_labels`) : Apakah akan mengurangi semua nilai label pada peta segmentasi sebesar 1. Biasanya digunakan untuk dataset di mana 0 digunakan untuk latar belakang, dan latar belakang itu sendiri tidak termasuk dalam semua kelas dataset (mis. ADE20k). Label latar belakang akan diganti dengan 255.

Membangun pemroses gambar DPTImageProcessor.

#### preprocess[[transformers.DPTImageProcessor.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']], segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.models.dpt.image_processing_dpt.DPTImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/dpt/image_processing_dpt.py#L135)

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

segmentation_maps (`ImageInput`, *opsional*) : Peta segmentasi yang akan dipreprocess.

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.

ensure_multiple_of (`int`, *kwargs*, *opsional*, default 1) : Jika `do_resize` adalah `True`, gambar akan di-resize ke ukuran yang merupakan kelipatan dari nilai ini. Dapat ditimpa oleh `ensure_multiple_of` di `preprocess`.

size_divisor (`int`, *kwargs*) : Ukuran yang memastikan tinggi dan lebar dapat dibagi habis.

keep_aspect_ratio (`bool`, *kwargs*, *opsional*, defaultnya `False`) : Jika `True`, gambar akan di-resize ke ukuran terbesar yang memungkinkan sehingga rasio aspek tetap terjaga. Dapat ditimpa oleh `keep_aspect_ratio` di `preprocess`.

do_reduce_labels (`bool`, *kwargs*, *opsional*, defaultnya `self.do_reduce_labels`) : Apakah akan mengurangi semua nilai label pada peta segmentasi sebesar 1. Biasanya digunakan untuk dataset di mana 0 digunakan untuk latar belakang, dan latar belakang itu sendiri tidak termasuk dalam semua kelas dataset (mis. ADE20k). Label latar belakang akan diganti dengan 255.

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

## DPTImageProcessorPil[[transformers.DPTImageProcessorPil]]

#### transformers.DPTImageProcessorPil[[transformers.DPTImageProcessorPil]]

```python
transformers.DPTImageProcessorPil(**kwargs: *<class 'transformers.models.dpt.image_processing_pil_dpt.DPTImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/dpt/image_processing_pil_dpt.py#L110)

**Parameter:**

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

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

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

default_to_square (`bool`, *kwargs*, *opsional*, defaultnya `True`) : 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 `3`) : 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.5, 0.5, 0.5]`) : 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.5, 0.5, 0.5]`) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

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

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

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

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

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

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

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

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

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

ensure_multiple_of (`int`, *kwargs*, *opsional*, default 1) : Jika `do_resize` adalah `True`, gambar akan di-resize ke ukuran yang merupakan kelipatan dari nilai ini. Dapat ditimpa oleh `ensure_multiple_of` di `preprocess`.

size_divisor (`int`, *kwargs*) : Ukuran yang memastikan tinggi dan lebar dapat dibagi habis.

keep_aspect_ratio (`bool`, *kwargs*, *opsional*, defaultnya `False`) : Jika `True`, gambar akan di-resize ke ukuran terbesar yang memungkinkan sehingga rasio aspek tetap terjaga. Dapat ditimpa oleh `keep_aspect_ratio` di `preprocess`.

do_reduce_labels (`bool`, *kwargs*, *opsional*, defaultnya `self.do_reduce_labels`) : Apakah akan mengurangi semua nilai label pada peta segmentasi sebesar 1. Biasanya digunakan untuk dataset di mana 0 digunakan untuk latar belakang, dan latar belakang itu sendiri tidak termasuk dalam semua kelas dataset (mis. ADE20k). Label latar belakang akan diganti dengan 255.

Membangun pemroses gambar DPTImageProcessor.

#### preprocess[[transformers.DPTImageProcessorPil.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']], segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.models.dpt.image_processing_pil_dpt.DPTImageProcessorKwargs'>)
```

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

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

segmentation_maps (`ImageInput`, *opsional*) : Peta segmentasi yang akan dipreprocess.

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.

ensure_multiple_of (`int`, *kwargs*, *opsional*, default 1) : Jika `do_resize` adalah `True`, gambar akan di-resize ke ukuran yang merupakan kelipatan dari nilai ini. Dapat ditimpa oleh `ensure_multiple_of` di `preprocess`.

size_divisor (`int`, *kwargs*) : Ukuran yang memastikan tinggi dan lebar dapat dibagi habis.

keep_aspect_ratio (`bool`, *kwargs*, *opsional*, defaultnya `False`) : Jika `True`, gambar akan di-resize ke ukuran terbesar yang memungkinkan sehingga rasio aspek tetap terjaga. Dapat ditimpa oleh `keep_aspect_ratio` di `preprocess`.

do_reduce_labels (`bool`, *kwargs*, *opsional*, defaultnya `self.do_reduce_labels`) : Apakah akan mengurangi semua nilai label pada peta segmentasi sebesar 1. Biasanya digunakan untuk dataset di mana 0 digunakan untuk latar belakang, dan latar belakang itu sendiri tidak termasuk dalam semua kelas dataset (mis. ADE20k). Label latar belakang akan diganti dengan 255.

**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_semantic_segmentation[[transformers.DPTImageProcessorPil.post_process_semantic_segmentation]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/dpt/image_processing_pil_dpt.py#L268)

**Parameter:**

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

target_sizes (`list[tuple]`, *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 [DPTForSemanticSegmentation](/docs/transformers/v5.23.0/id/model_doc/dpt#transformers.DPTForSemanticSegmentation) menjadi peta segmentasi semantik.

#### post_process_depth_estimation[[transformers.DPTImageProcessorPil.post_process_depth_estimation]]

```python
post_process_depth_estimation(outputs: DepthEstimatorOutput, target_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/dpt/image_processing_pil_dpt.py#L331)

Mengonversi output mentah dari `DepthEstimatorOutput` menjadi prediksi kedalaman akhir.

## DPTModel[[transformers.DPTModel]]

#### transformers.DPTModel[[transformers.DPTModel]]

```python
transformers.DPTModel(config: DPTConfig, add_pooling_layer: bool = True)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/dpt/modeling_dpt.py#L752)

**Parameter:**

config ([DPTConfig](/docs/transformers/v5.23.0/id/model_doc/dpt#transformers.DPTConfig)) : 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.

add_pooling_layer (`bool`, *opsional*, defaultnya `True`) : Apakah akan menambahkan lapisan pooling

Model Dpt polos 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.DPTModel.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/dpt/modeling_dpt.py#L780)

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

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

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

Metode forward dari [DPTModel](/docs/transformers/v5.23.0/id/model_doc/dpt#transformers.DPTModel) 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)`, *opsional*) -- Urutan hidden-states pada keluaran dari lapisan terakhir model.
- **pooler_output** (`torch.Tensor` dengan bentuk `(batch_size, hidden_size)`) -- Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
- **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.
- **intermediate_activations** (`tuple(torch.Tensor)`, *opsional*) -- Aktivasi perantara yang dapat digunakan untuk menghitung hidden states model di berbagai lapisan.

Contoh:

```python
```

## DPTForDepthEstimation[[transformers.DPTForDepthEstimation]]

#### transformers.DPTForDepthEstimation[[transformers.DPTForDepthEstimation]]

```python
transformers.DPTForDepthEstimation(config: DPTConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/dpt/modeling_dpt.py#L923)

**Parameter:**

config ([DPTConfig](/docs/transformers/v5.23.0/id/model_doc/dpt#transformers.DPTConfig)) : 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 DPT dengan kepala estimasi kedalaman di bagian atas (terdiri dari 3 lapisan konvolusional) misalnya untuk KITTI, NYUv2.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/dpt/modeling_dpt.py#L942)

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

labels (`torch.LongTensor` dengan bentuk `(batch_size, height, width)`, *opsional*) : Peta estimasi kedalaman ground truth untuk menghitung loss.

**Mengembalikan:** [DepthEstimatorOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.DepthEstimatorOutput) atau `tuple(torch.Tensor)`

A [DepthEstimatorOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.DepthEstimatorOutput) 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 [DPTForDepthEstimation](/docs/transformers/v5.23.0/id/model_doc/dpt#transformers.DPTForDepthEstimation) 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 saat `labels` disediakan) -- Loss klasifikasi (atau regresi jika config.num_labels==1).
- **predicted_depth** (`torch.Tensor` dengan bentuk `(batch_size, height, width)`) -- Kedalaman yang diprediksi untuk setiap piksel.
- **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, num_channels, height, width)`.

  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, patch_size, sequence_length)`.

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

Contoh:
```python
>>> from transformers import AutoImageProcessor, DPTForDepthEstimation
>>> import torch
>>> import numpy as np
>>> 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("Intel/dpt-large")
>>> model = DPTForDepthEstimation.from_pretrained("Intel/dpt-large")

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

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

>>> # interpolate to original size
>>> post_processed_output = image_processor.post_process_depth_estimation(
...     outputs,
...     target_sizes=[(image.height, image.width)],
... )

>>> # visualize the prediction
>>> predicted_depth = post_processed_output[0]["predicted_depth"]
>>> depth = predicted_depth * 255 / predicted_depth.max()
>>> depth = depth.detach().cpu().numpy()
>>> depth = Image.fromarray(depth.astype("uint8"))
```

## DPTForSemanticSegmentation[[transformers.DPTForSemanticSegmentation]]

#### transformers.DPTForSemanticSegmentation[[transformers.DPTForSemanticSegmentation]]

```python
transformers.DPTForSemanticSegmentation(config: DPTConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/dpt/modeling_dpt.py#L1070)

**Parameter:**

config ([DPTConfig](/docs/transformers/v5.23.0/id/model_doc/dpt#transformers.DPTConfig)) : 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 Dpt dengan head segmentasi semantik di atasnya, misalnya untuk ADE20K, CityScapes.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/dpt/modeling_dpt.py#L1086)

**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 `image_processor_class`. Lihat `image_processor_class.__call__` untuk detailnya (`processor_class` menggunakan `image_processor_class` untuk memproses gambar).

labels (`torch.LongTensor` dengan bentuk `(batch_size, height, width)`, *opsional*) : Peta segmentasi semantik ground truth untuk menghitung loss. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy).

**Mengembalikan:** [SemanticSegmenterOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.SemanticSegmenterOutput) atau `tuple(torch.Tensor)`

Sebuah [SemanticSegmenterOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.SemanticSegmenterOutput) 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 [DPTForSemanticSegmentation](/docs/transformers/v5.23.0/id/model_doc/dpt#transformers.DPTForSemanticSegmentation) 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 saat `labels` disediakan) -- Loss klasifikasi (atau regresi jika config.num_labels==1).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, config.num_labels, logits_height, logits_width)`) -- Skor klasifikasi untuk setiap piksel.

  

  Logits yang dikembalikan tidak selalu memiliki ukuran yang sama dengan `pixel_values` yang diberikan sebagai input. Hal ini dilakukan untuk menghindari dua kali interpolasi dan kehilangan kualitas ketika pengguna perlu mengubah ukuran logits ke ukuran gambar asli sebagai pascapemrosesan. Anda harus selalu memeriksa bentuk logits Anda dan mengubah ukurannya sesuai kebutuhan.

  
- **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, patch_size, 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, patch_size, sequence_length)`.

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

Contoh:
```python
>>> from transformers import AutoImageProcessor, DPTForSemanticSegmentation
>>> 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("Intel/dpt-large-ade")
>>> model = DPTForSemanticSegmentation.from_pretrained("Intel/dpt-large-ade")

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

>>> outputs = model(**inputs)
>>> logits = outputs.logits
```

