Hugging Face's logo

Transformers documentation

Depth Anything

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Model ini dipublikasikan di HF papers pada 2024-01-19 dan disumbangkan ke Hugging Face Transformers pada 2024-01-25.

Depth Anything

Depth Anything dirancang sebagai model fondasi untuk estimasi kedalaman monokular (MDE). Model ini dilatih secara bersama pada data berlabel dan sekitar 62 juta gambar tanpa label untuk meningkatkan dataset. Model ini menggunakan model DINOv2 yang telah dilatih sebelumnya sebagai encoder gambar untuk mewarisi prior semantik yang kaya, serta DPT sebagai decoder. Model guru dilatih pada gambar tanpa label untuk membuat pseudo-label. Model siswa dilatih pada kombinasi pseudo-label dan gambar berlabel. Untuk meningkatkan kinerja model siswa, perturbasi kuat ditambahkan pada gambar tanpa label untuk menantang model siswa agar belajar lebih banyak pengetahuan visual dari gambar tersebut.

Anda dapat menemukan semua checkpoint asli Depth Anything di bawah koleksi Depth Anything.

Klik pada model Depth Anything di bilah sisi kanan untuk melihat lebih banyak contoh cara menerapkan Depth Anything ke berbagai tugas visi.

Contoh di bawah ini menunjukkan cara mendapatkan peta kedalaman dengan Pipeline atau kelas AutoModel.

Pipeline
AutoModel
from transformers import pipeline


pipe = pipeline(task="depth-estimation", model="LiheYoung/depth-anything-base-hf", device=0)
pipe("http://images.cocodataset.org/val2017/000000039769.jpg")["depth"]

Catatan

  • DepthAnythingV2, yang dirilis pada Juni 2024, menggunakan arsitektur yang sama dengan Depth Anything dan kompatibel dengan semua contoh kode serta alur kerja yang ada. Model ini menggunakan data sintetis dan model guru dengan kapasitas yang lebih besar untuk mencapai prediksi kedalaman yang jauh lebih halus dan robust.

DepthAnythingConfig

kelas transformers.DepthAnythingConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepatch_size: int | list[int] | tuple[int, int] = 14initializer_range: float = 0.02reassemble_hidden_size: int = 384reassemble_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 = 64head_in_index: int = -1head_hidden_size: int = 32depth_estimation_type: str = 'relative'max_depth: int | None = 1 )

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) — Standar deviasi 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, default [4, 2, 1, 0.5]) — Faktor up/downsampling dari lapisan reassemble.
  • neck_hidden_sizes (list[str], opsional, default [48, 96, 192, 384]) — Ukuran tersembunyi untuk diproyeksikan ke peta fitur dari backbone.
  • fusion_hidden_size (int, opsional, defaultnya 64) — Jumlah saluran sebelum fusi.
  • head_in_index (int, opsional, defaultnya -1) — Indeks fitur yang akan digunakan di head estimasi kedalaman.
  • head_hidden_size (int, opsional, default 32) — Jumlah kanal output pada konvolusi kedua dari head 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

Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.

Contoh:

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

kelas transformers.DepthAnythingForDepthEstimation

< >

( config: DepthAnythingConfig )

Parameter

  • config (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() 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. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)

Model ini juga merupakan subclass dari 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

< >

( pixel_values: Tensorlabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → DepthEstimatorOutput or tuple(torch.Tensor)

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. Lihat DPTImageProcessor.call() untuk detailnya (processor_class menggunakan 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 attentions dari semua lapisan attention. 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 alih-alih tuple biasa.

Mengembalikan

DepthEstimatorOutput atau tuple(torch.Tensor)

A 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) dan input.

Metode forward 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 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, num_channels, height, width).

    Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.

  • attentions (tuple(torch.Tensor), opsional, dikembalikan saat output_attentions=True dilewatkan atau saat 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 perhatian diri (self-attention).

Contoh:

>>> 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"))
Update on GitHub

←DeiT Depth Anything V2→