Estimasi kedalaman monokular

Estimasi kedalaman monokular adalah tugas computer vision yang melibatkan prediksi informasi kedalaman suatu adegan dari satu gambar. Dengan kata lain, ini adalah proses memperkirakan jarak objek dalam adegan dari satu sudut pandang kamera.

Estimasi kedalaman monokular memiliki berbagai aplikasi, termasuk rekonstruksi 3D, realitas tertambah, pengemudian otonom, dan robotika. Ini adalah tugas yang menantang karena mengharuskan model untuk memahami hubungan kompleks antara objek dalam adegan dan informasi kedalaman yang bersesuaian, yang dapat dipengaruhi oleh faktor-faktor seperti kondisi pencahayaan, oklusi, dan tekstur.

Terdapat dua kategori utama estimasi kedalaman:

• Estimasi kedalaman absolut: Varian tugas ini bertujuan untuk memberikan pengukuran kedalaman yang tepat dari kamera. Istilah ini digunakan secara bergantian dengan estimasi kedalaman metrik, di mana kedalaman diberikan dalam pengukuran presisi dalam meter atau kaki. Model estimasi kedalaman absolut menghasilkan peta kedalaman dengan nilai numerik yang mewakili jarak dunia nyata.

• Estimasi kedalaman relatif: Estimasi kedalaman relatif bertujuan untuk memprediksi urutan kedalaman objek atau titik dalam sebuah adegan tanpa memberikan pengukuran yang presisi. Model-model ini menghasilkan peta kedalaman yang menunjukkan bagian mana dari adegan yang lebih dekat atau lebih jauh secara relatif satu sama lain, tanpa jarak aktual ke A dan B.

Dalam panduan ini, kita akan melihat cara melakukan inferensi dengan Depth Anything V2, model estimasi kedalaman relatif zero-shot state-of-the-art, dan ZoeDepth, model estimasi kedalaman absolut.

Periksa halaman tugas Depth Estimation untuk melihat semua arsitektur dan checkpoint yang kompatibel.

Sebelum memulai, kita perlu menginstal versi terbaru dari Transformers:

pip install -q -U transformers

Pipeline estimasi kedalaman

Cara termudah untuk mencoba inferensi dengan model yang mendukung estimasi kedalaman adalah dengan menggunakan pipeline() yang sesuai. Instansiasi pipeline dari checkpoint di Hugging Face Hub:

>>> from transformers import pipeline
from accelerate import Accelerator
>>> import torch
>>> device = Accelerator().device
>>> checkpoint = "depth-anything/Depth-Anything-V2-base-hf"
>>> pipe = pipeline("depth-estimation", model=checkpoint, device=device)

Selanjutnya, pilih gambar untuk dianalisis:

>>> from PIL import Image
>>> import requests

>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image

Lewatkan gambar ke pipeline.

>>> predictions = pipe(image)

Pipeline mengembalikan kamus dengan dua entri. Yang pertama, bernama predicted_depth, adalah tensor dengan nilai-nilai yang merupakan kedalaman dalam meter untuk setiap piksel. Yang kedua, depth, adalah gambar PIL yang memvisualisasikan hasil estimasi kedalaman.

Mari kita lihat hasil visualisasinya:

>>> predictions["depth"]

Inferensi estimasi kedalaman secara manual

Sekarang setelah Anda melihat cara menggunakan pipeline estimasi kedalaman, mari kita lihat bagaimana kita dapat mereplikasi hasil yang sama secara manual.

Mulai dengan memuat model dan processor terkait dari checkpoint di Hugging Face Hub. Di sini kita akan menggunakan checkpoint yang sama seperti sebelumnya:

>>> from transformers import AutoImageProcessor, AutoModelForDepthEstimation

>>> checkpoint = "Intel/zoedepth-nyu-kitti"

>>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
>>> model = AutoModelForDepthEstimation.from_pretrained(checkpoint).to(device)

Siapkan input gambar untuk model menggunakan image_processor yang akan menangani transformasi gambar yang diperlukan, seperti penyesuaian ukuran dan normalisasi:

>>> pixel_values = image_processor(image, return_tensors="pt").pixel_values.to(device)

Lewatkan input yang sudah disiapkan melalui model:

>>> import torch

>>> with torch.no_grad():
...     outputs = model(pixel_values)

Mari kita lakukan pascapemrosesan pada hasil untuk menghapus padding dan mengubah ukuran peta kedalaman agar sesuai dengan ukuran gambar asli. post_process_depth_estimation menghasilkan daftar dict yang berisi "predicted_depth".

>>> # ZoeDepth dynamically pads the input image. Thus we pass the original image size as argument
>>> # to `post_process_depth_estimation` to remove the padding and resize to original dimensions.
>>> post_processed_output = image_processor.post_process_depth_estimation(
...     outputs,
...     source_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"))

Pada implementasi asli, model ZoeDepth melakukan inferensi pada gambar asli dan gambar yang dibalik, lalu merata-ratakan hasilnya. Fungsi post_process_depth_estimation dapat menangani hal ini untuk kita dengan meneruskan output yang dibalik ke argumen opsional outputs_flipped:

>>> with torch.no_grad():
...     outputs = model(pixel_values)
...     outputs_flipped = model(pixel_values=torch.flip(inputs.pixel_values, dims=[3]))
>>> post_processed_output = image_processor.post_process_depth_estimation(
...     outputs,
...     source_sizes=[(image.height, image.width)],
...     outputs_flipped=outputs_flipped,
... )