# Depth Anything V2

## Ikhtisar

Depth Anything V2 diperkenalkan dalam [makalah dengan nama yang sama](https://huggingface.co/papers/2406.09414) oleh Lihe Yang dkk. Model ini menggunakan arsitektur yang sama dengan model [Depth Anything](depth_anything) asli, tetapi memanfaatkan data sintetis dan model guru dengan kapasitas yang lebih besar untuk mencapai prediksi kedalaman yang jauh lebih halus dan robust.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Karya ini memperkenalkan Depth Anything V2. Tanpa mengejar teknik yang rumit, kami bertujuan untuk mengungkapkan temuan-temuan penting guna membuka jalan menuju pembangunan model estimasi kedalaman monokular yang kuat. Secara khusus, dibandingkan dengan V1, versi ini menghasilkan prediksi kedalaman yang jauh lebih halus dan lebih robust melalui tiga praktik utama: 1) mengganti semua gambar nyata berlabel dengan gambar sintetis, 2) memperbesar kapasitas model guru kami, dan 3) melatih model siswa melalui jembatan gambar nyata berlabel pseudo berskala besar. Dibandingkan dengan model-model terbaru yang dibangun di atas Stable Diffusion, model kami jauh lebih efisien (lebih dari 10x lebih cepat) dan lebih akurat. Kami menyediakan model dengan skala yang berbeda (berkisar dari 25M hingga 1,3B parameter) untuk mendukung berbagai skenario. Berkat kemampuan generalisasi yang kuat, kami melakukan fine-tuning dengan label kedalaman metrik untuk mendapatkan model kedalaman metrik kami. Selain model kami, mengingat keterbatasan keragaman dan frekuensi noise dalam set pengujian saat ini, kami membangun benchmark evaluasi yang serbaguna dengan anotasi yang presisi dan adegan yang beragam untuk memfasilitasi penelitian di masa depan.*

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

 Ikhtisar Depth Anything. Diambil dari makalah aslinya.

Model Depth Anything disumbangkan oleh [nielsr](https://huggingface.co/nielsr). Kode aslinya dapat ditemukan [di sini](https://github.com/DepthAnything/Depth-Anything-V2).

## Contoh penggunaan

Ada 2 cara utama untuk menggunakan Depth Anything V2: yaitu dengan menggunakan API pipeline, yang menyederhanakan semua kompleksitas untuk Anda, atau dengan menggunakan kelas `DepthAnythingForDepthEstimation` secara langsung.

### API Pipeline

Pipeline memungkinkan penggunaan model dalam beberapa baris kode:

```python
import requests
from PIL import Image

from transformers import pipeline

# load pipe
pipe = pipeline(task="depth-estimation", model="depth-anything/Depth-Anything-V2-Small-hf")

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

# inference
depth = pipe(image)["depth"]
```

### Menggunakan model Anda sendiri

Jika Anda ingin melakukan pra-pemrosesan dan pasca-pemrosesan sendiri, berikut cara melakukannya:

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

from transformers import AutoImageProcessor, AutoModelForDepthEstimation

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

image_processor = AutoImageProcessor.from_pretrained("depth-anything/Depth-Anything-V2-Small-hf")
model = AutoModelForDepthEstimation.from_pretrained("depth-anything/Depth-Anything-V2-Small-hf", device_map="auto")

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

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

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

predicted_depth = post_processed_output[0]["predicted_depth"]
depth = (predicted_depth - predicted_depth.min()) / (predicted_depth.max() - predicted_depth.min())
depth = depth.detach().cpu().numpy() * 255
depth = Image.fromarray(depth.astype("uint8"))
```

## Sumber daya

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

- [Panduan tugas estimasi kedalaman monokular](../tasks/monocular_depth_estimation)
- [Demo Depth Anything V2](https://huggingface.co/spaces/depth-anything/Depth-Anything-V2).
- Notebook yang menampilkan inferensi dengan [DepthAnythingForDepthEstimation](/docs/transformers/main/id/model_doc/depth_anything#transformers.DepthAnythingForDepthEstimation) dapat ditemukan [di sini](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/Depth%20Anything/Predicting_depth_in_an_image_with_Depth_Anything.ipynb). 🌎
- [Konversi Core ML dari varian `small` untuk digunakan pada Apple Silicon](https://huggingface.co/apple/coreml-depth-anything-v2-small).

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.

## DepthAnythingConfig[[transformers.DepthAnythingConfig]]

#### transformers.DepthAnythingConfig[[transformers.DepthAnythingConfig]]

```python
transformers.DepthAnythingConfig(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 | list[int] | tuple[int, int] = 14, initializer_range: float = 0.02, reassemble_hidden_size: int = 384, reassemble_factors: list[int | float] | tuple[int | float, ...] = (4, 2, 1, 0.5), neck_hidden_sizes: list[int] | tuple[int, ...] = (48, 96, 192, 384), fusion_hidden_size: int = 64, head_in_index: int = -1, head_hidden_size: int = 32, depth_estimation_type: str = 'relative', max_depth: int | None = 1)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_anything/configuration_depth_anything.py#L25)

**Parameter:**

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

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

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

reassemble_hidden_size (`int`, *opsional*, defaultnya 384) : Jumlah saluran input dari lapisan reassemble.

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

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

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

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

head_hidden_size (`int`, *opsional*, defaultnya 32) : Jumlah kanal output pada konvolusi kedua dari kepala estimasi kedalaman.

depth_estimation_type (`str`, *opsional*, defaultnya `"relative"`) : Jenis estimasi kedalaman yang akan digunakan. Bisa berupa salah satu dari `["relative", "metric"]`.

max_depth (`float`, *opsional*) : Kedalaman maksimum yang digunakan untuk kepala estimasi kedalaman "metric". Gunakan 20 untuk model indoor dan 80 untuk model outdoor. Untuk estimasi kedalaman "relative", nilai ini diabaikan.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Depth AnythingModel. Kelas ini digunakan untuk membuat instans model Depth Anything sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [LiheYoung/depth-anything-small-hf](https://huggingface.co/LiheYoung/depth-anything-small-hf)

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.

Contoh:

```python
>>> from transformers import DepthAnythingConfig, DepthAnythingForDepthEstimation

>>> # Initializing a DepthAnything small style configuration
>>> configuration = DepthAnythingConfig()

>>> # Initializing a model from the DepthAnything small style configuration
>>> model = DepthAnythingForDepthEstimation(configuration)

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

## DepthAnythingForDepthEstimation[[transformers.DepthAnythingForDepthEstimation]]

#### transformers.DepthAnythingForDepthEstimation[[transformers.DepthAnythingForDepthEstimation]]

```python
transformers.DepthAnythingForDepthEstimation(config: DepthAnythingConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_anything/modeling_depth_anything.py#L316)

**Parameter:**

config ([DepthAnythingConfig](/docs/transformers/main/id/model_doc/depth_anything#transformers.DepthAnythingConfig)) : 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 Depth Anything dengan kepala estimasi kedalaman di atasnya (terdiri dari 3 lapisan konvolusional) misalnya untuk KITTI, NYUv2.

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

```python
forward(pixel_values: Tensor, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_anything/modeling_depth_anything.py#L327)

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

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

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

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

Sebuah [DepthEstimatorOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.DepthEstimatorOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DepthAnythingConfig](/docs/transformers/main/id/model_doc/depth_anything#transformers.DepthAnythingConfig)) dan input.

Metode forward [DepthAnythingForDepthEstimation](/docs/transformers/main/id/model_doc/depth_anything#transformers.DepthAnythingForDepthEstimation) 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, AutoModelForDepthEstimation
>>> 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("LiheYoung/depth-anything-small-hf")
>>> model = AutoModelForDepthEstimation.from_pretrained("LiheYoung/depth-anything-small-hf")

>>> # 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"))
```