# CHMv2 ## Ikhtisar Model Canopy Height Maps v2 (CHMv2) diusulkan dalam [CHMv2: Improvements in Global Canopy Height Mapping using DINOv3](https://huggingface.co/papers/2603.06382). Berangkat dari [peta tinggi kanopi resolusi tinggi asli](https://sustainability.atmeta.com/blog/2024/04/22/using-artificial-intelligence-to-map-the-earths-forests/) kami yang dirilis pada 2024, CHMv2 memberikan peningkatan substansial dalam akurasi, detail, dan konsistensi global dengan memanfaatkan DINOv3, model visi self-supervised dari Meta. Anda dapat menemukan informasi lebih lanjut [di sini](http://ai.meta.com/blog/world-resources-institute-dino-canopy-height-maps-v2), dan kode aslinya [di sini](https://github.com/facebookresearch/dinov3). Abstrak dari makalah tersebut adalah sebagai berikut: *Informasi tinggi kanopi yang akurat sangat penting untuk mengkuantifikasi karbon hutan, memantau pemulihan dan degradasi, serta menilai struktur habitat, namun pengukuran fidelitas tinggi dari pemindaian laser udara (ALS) masih tersedia secara tidak merata di seluruh dunia. Di sini kami menyajikan CHMv2, peta tinggi kanopi global dengan resolusi meter yang diturunkan dari citra satelit optik resolusi tinggi menggunakan model estimasi kedalaman yang dibangun di atas DINOv3 dan dilatih terhadap model tinggi kanopi ALS. Dibandingkan dengan produk yang ada, CHMv2 secara substansial meningkatkan akurasi, mengurangi bias di hutan tinggi, dan lebih baik dalam mempertahankan struktur skala halus seperti tepi dan celah kanopi. Peningkatan ini dimungkinkan oleh ekspansi besar data pelatihan yang beragam secara geografis, kurasi dan registrasi data otomatis, serta formulasi loss dan strategi pengambilan sampel data yang disesuaikan dengan distribusi tinggi kanopi. Kami memvalidasi CHMv2 terhadap set uji ALS independen dan terhadap puluhan juta pengamatan GEDI dan ICESat-2, menunjukkan kinerja yang konsisten di seluruh bioma hutan utama.* ## Contoh penggunaan Jalankan inferensi pada gambar dengan kode berikut: ```python import torch from PIL import Image from transformers import AutoImageProcessor, AutoModelForDepthEstimation processor = AutoImageProcessor.from_pretrained("facebook/dinov3-vitl16-chmv2-dpt-head") model = AutoModelForDepthEstimation.from_pretrained("facebook/dinov3-vitl16-chmv2-dpt-head", device_map="auto") image = Image.open("image.tif") inputs = processor(images=image, return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model(**inputs) depth = processor.post_process_depth_estimation( outputs, target_sizes=[(image.height, image.width)] )[0]["predicted_depth"] ``` ## CHMv2Config[[transformers.CHMv2Config]] #### transformers.CHMv2Config[[transformers.CHMv2Config]] ```python transformers.CHMv2Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, patch_size: int = 16, initializer_range: float = 0.02, reassemble_factors: list[float | int] | None = None, post_process_channels: list[int] | None = None, fusion_hidden_size: int = 256, head_hidden_size: int = 128, number_output_channels: int = 256, readout_type: str = 'project', min_depth: float = 0.001, max_depth: float = 96.0, bins_strategy: typing.Literal['linear', 'log', 'chmv2_mixlog'] = 'chmv2_mixlog', norm_strategy: typing.Literal['linear', 'softmax', 'sigmoid', 'chmv2_mixlog'] = 'chmv2_mixlog') ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/chmv2/configuration_chmv2.py#L32) **Parameter:** backbone_config (`Union[dict, "PreTrainedConfig"]`, *opsional*) : Konfigurasi model backbone. Saat ini hanya DINOv3ViTConfig yang didukung. patch_size (`int`, *opsional*, default 16) : Ukuran patch yang digunakan oleh vision transformer backbone. initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot. reassemble_factors (`list[float]`, *opsional*, defaultnya `[4, 2, 1, 0.5]`) : Faktor up/downsampling dari lapisan reassemble. post_process_channels (`list[int]`, *opsional*, defaultnya `[128, 256, 512, 1024]`) : Ukuran channel output dari tahap reassemble untuk setiap level fitur backbone. fusion_hidden_size (`int`, *opsional*, defaultnya 256) : Jumlah channel sebelum fusi. head_hidden_size (`int`, *opsional*, default 128) : Jumlah channel di lapisan tersembunyi dari kepala estimasi kedalaman. number_output_channels (`int`, *opsional*, default 256) : Jumlah kanal output untuk kepala CHMv2 (jumlah bin kedalaman). readout_type (`str`, *opsional*, defaultnya `"project"`) : Jenis operasi readout untuk token CLS. Salah satu dari `["ignore", "add", "project"]`. min_depth (`float`, *opsional*, default 0.001) : Nilai kedalaman minimum untuk perhitungan bin kedalaman. max_depth (`float`, *opsional*, default 96.0) : Nilai kedalaman maksimum untuk perhitungan bin kedalaman. bins_strategy (`str`, *opsional*, defaultnya `"chmv2_mixlog"`) : Strategi untuk distribusi bin kedalaman. Salah satu dari `["linear", "log", "chmv2_mixlog"]`. norm_strategy (`str`, *opsional*, defaultnya `"chmv2_mixlog"`) : Strategi normalisasi untuk prediksi kedalaman. Salah satu dari `["linear", "softmax", "sigmoid", "chmv2_mixlog"]`. Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Chmv2Model. Kelas ini digunakan untuk membuat instans model Chmv2 berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [facebook/dinov3-vitl16-chmv2-dpt-head](https://huggingface.co/facebook/dinov3-vitl16-chmv2-dpt-head) Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut. ```python >>> from transformers import CHMv2Config, CHMv2ForDepthEstimation >>> configuration = CHMv2Config() >>> model = CHMv2ForDepthEstimation(configuration) >>> configuration = model.config ``` ## CHMv2ImageProcessor[[transformers.CHMv2ImageProcessor]] #### transformers.CHMv2ImageProcessor[[transformers.CHMv2ImageProcessor]] ```python transformers.CHMv2ImageProcessor(**kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/chmv2/image_processing_chmv2.py#L99) **Parameter:** do_convert_rgb (`bool`, *kwargs*, *opsional*) : Apakah akan mengkonversi gambar ke RGB. do_resize (`bool`, *kwargs*, *opsional*, defaultnya `False`) : 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.42, 0.411, 0.296]`) : 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.213, 0.156, 0.143]`) : 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*, 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*, defaultnya `16`) : Ukuran yang digunakan untuk memastikan bahwa 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 CHMv2ImageProcessor. #### preprocess[[transformers.CHMv2ImageProcessor.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: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/chmv2/image_processing_chmv2.py#L125) **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_depth_estimation[[transformers.CHMv2ImageProcessor.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/main/src/transformers/models/chmv2/image_processing_chmv2.py#L385) **Parameter:** outputs (`DepthEstimatorOutput`) : Output mentah dari model. target_sizes (`TensorType` 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. **Mengembalikan:** `List[Dict[str, TensorType]]` Daftar kamus tensor yang mewakili prediksi kedalaman yang diproses. Mengonversi output mentah dari `DepthEstimatorOutput` menjadi prediksi kedalaman akhir dan gambar kedalaman PIL. Hanya mendukung PyTorch. ## CHMv2ForDepthEstimation[[transformers.CHMv2ForDepthEstimation]] #### transformers.CHMv2ForDepthEstimation[[transformers.CHMv2ForDepthEstimation]] ```python transformers.CHMv2ForDepthEstimation(config: CHMv2Config) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/chmv2/modeling_chmv2.py#L384) **Parameter:** config ([CHMv2Config](/docs/transformers/main/id/model_doc/chmv2#transformers.CHMv2Config)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Model CHMv2 dengan kepala estimasi kedalaman di bagian atas (terdiri dari lapisan konvolusional), misalnya untuk estimasi tinggi kanopi. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum. #### forward[[transformers.CHMv2ForDepthEstimation.forward]] ```python forward(pixel_values: Tensor, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/chmv2/modeling_chmv2.py#L397) **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 [CHMv2ImageProcessor](/docs/transformers/main/id/model_doc/chmv2#transformers.CHMv2ImageProcessor). Lihat [CHMv2ImageProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [CHMv2ImageProcessor](/docs/transformers/main/id/model_doc/chmv2#transformers.CHMv2ImageProcessor) 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/main/id/main_classes/output#transformers.modeling_outputs.DepthEstimatorOutput) atau `tuple(torch.Tensor)` [DepthEstimatorOutput](/docs/transformers/main/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 ([CHMv2Config](/docs/transformers/main/id/model_doc/chmv2#transformers.CHMv2Config)) dan input. Metode forward dari [CHMv2ForDepthEstimation](/docs/transformers/main/id/model_doc/chmv2#transformers.CHMv2ForDepthEstimation) 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, CHMv2ForDepthEstimation >>> import torch >>> 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())).convert("RGB") >>> processor = AutoImageProcessor.from_pretrained("facebook/dinov3-vitl16-chmv2-dpt-head") >>> model = CHMv2ForDepthEstimation.from_pretrained("facebook/dinov3-vitl16-chmv2-dpt-head") >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu") >>> model.to(device) >>> # prepare image for the model >>> inputs = processor(images=image, return_tensors="pt").to(device) >>> with torch.no_grad(): ... outputs = model(**inputs) >>> # interpolate to original size >>> post_processed_output = processor.post_process_depth_estimation( ... outputs, [(image.height, image.width)], ... ) >>> predicted_depth = post_processed_output[0]["predicted_depth"] ```