Depth Anything V2: Prediksi Kedalaman dari Satu Gambar dengan Python

Halo temen-temen, di tutorial kali ini aku mau ngajak kalian main-main sama salah satu model computer vision yang menurutku paling seru beberapa tahun terakhir, namanya Depth Anything, khususnya versi keduanya alias Depth Anything V2. Model ini punya satu tugas yang kedengarannya sederhana tapi sebenernya susah banget: nebak seberapa jauh setiap piksel di sebuah foto dari kamera, cuma dari SATU gambar aja. Iya, satu gambar biasa, bukan foto stereo, bukan hasil sensor LiDAR, bukan kamera depth khusus. Tinggal kasih satu foto RGB, dia bakal ngasih kamu depth map, yaitu peta yang nunjukin mana yang deket dan mana yang jauh.

Di tutorial ini aku bakal jelasin dari nol apa itu monocular depth estimation, kenapa dia berguna banget buat 3D, robotika, sampai efek foto ala portrait mode di HP, terus lanjut ke praktek langsung pakai HuggingFace transformers. Kita bakal jalanin Depth Anything lewat pipeline("depth-estimation") yang super gampang, terus turun lebih dalam ke pemakaian model repo secara manual biar kalian ngerti apa yang sebenernya terjadi di balik layar. Kita juga bakal ngebahas cara normalisasi dan visualisasi depth map, milih ukuran model (Small, Base, Large), bedanya metric depth sama relative depth, dan gimana caranya jalanin model ini di video frame per frame. Siapin kopi, kita mulai pelan-pelan.

Introduction

Sebelum masuk ke kode, aku pengen kalian paham dulu konsep besarnya. Ini penting biar pas nanti liat outputnya kalian ngerti angka-angka itu artinya apa.

Apa Itu Monocular Depth Estimation

Monocular depth estimation itu tugas memperkirakan kedalaman (jarak dari kamera) untuk setiap piksel di sebuah gambar, cuma bermodalkan satu gambar tunggal. Kata "monocular" artinya satu mata, satu sudut pandang. Ini beda sama depth estimation klasik yang biasanya butuh dua kamera (stereo) atau sensor aktif kayak LiDAR yang nembakin sinar buat ngukur jarak.

Kenapa ini susah? Karena secara matematis, satu gambar 2D itu ambigu. Bayangin kamu foto sebuah bola kecil yang deket sama foto bola besar yang jauh. Di gambar 2D, dua-duanya bisa keliatan sama ukurannya. Otak manusia bisa nebak mana yang deket mana yang jauh karena kita punya pengalaman seumur hidup soal ukuran objek, perspektif, bayangan, tekstur, dan konteks. Nah, model deep learning kayak Depth Anything ini pada dasarnya belajar "intuisi" yang sama itu dari jutaan gambar.

Depth Anything V2 dilatih pakai kombinasi data berlabel dan data tak berlabel dalam jumlah masif (jutaan gambar), plus pakai teknik synthetic data dan model guru-murid. Hasilnya, model ini jago banget generalisasi ke gambar yang belum pernah dia liat, mulai dari foto indoor, outdoor, wajah orang, sampai gambar hasil AI generatif sekalipun.

Depth Map Itu Bentuknya Kayak Apa

Output dari model ini namanya depth map. Bentuknya adalah gambar grayscale (satu channel) yang ukurannya sama kayak gambar input. Setiap piksel di depth map itu nilainya menunjukkan kedalaman relatif atau absolut, tergantung tipe modelnya.

Yang perlu kalian catet baik-baik: Depth Anything (versi relatif) itu ngeluarin sesuatu yang namanya inverse depth atau disparity. Artinya, nilai yang GEDE justru berarti DEKET sama kamera, dan nilai yang KECIL berarti JAUH. Ini sering bikin bingung pemula, jadi tolong diinget ya. Nanti pas visualisasi biasanya benda deket bakal keliatan terang dan benda jauh keliatan gelap.

Kegunaan di Dunia Nyata

Aku kasih beberapa contoh biar kebayang kenapa ini worth dipelajari:

Buat efek foto, ini yang paling gampang dirasain. Portrait mode di HP yang bikin background blur (bokeh) itu butuh info kedalaman biar tau mana subjek mana latar. Dengan depth map kamu bisa bikin efek blur, ganti background, atau tambah efek fog yang realistis.

Buat robotika dan drone, robot butuh tau jarak objek biar nggak nabrak. Dengan monocular depth, robot murah yang cuma punya satu kamera bisa dapet perkiraan jarak tanpa perlu sensor mahal.

Buat 3D dan AR, depth map bisa dipakai buat rekonstruksi 3D, bikin point cloud, atau naruh objek virtual di posisi yang pas dalam augmented reality.

Buat mobil otonom, estimasi kedalaman bantu kendaraan ngerti lingkungan sekitar, jarak ke mobil lain, pejalan kaki, dan rintangan.

Buat kreatif dan visual effect, banyak seniman digital pakai depth map buat bikin efek parallax, animasi 2.5D, atau relighting foto.

Oke, teorinya udah cukup. Ayo kita instalasi.

Instalasi

Depth Anything V2 udah terintegrasi rapi ke HuggingFace transformers, jadi kita nggak perlu clone repo aneh-aneh atau install dependency ribet. Cukup pakai library standar ekosistem HuggingFace.

Pertama, pastiin kalian punya Python 3.8 ke atas. Aku saranin bikin virtual environment dulu biar nggak berantakan.

python -m venv venv
source venv/bin/activate   # Linux / Mac
venv\Scripts\activate    # Windows

Terus install paket yang kita butuhin:

pip install "transformers>=4.45.0" torch pillow numpy matplotlib opencv-python

Penjelasan singkat tiap paket:

Buat ngecek apakah PyTorch kalian bisa pakai GPU, jalanin ini:

import torch
print("CUDA tersedia:", torch.cuda.isavailable())

print("Device:", "cuda" if torch.cuda.isavailable() else "cpu")

Kalau keluar True, mantap, GPU kalian siap. Kalau False, tenang aja, kita tetep bisa jalan pakai CPU untuk gambar-gambar biasa.

Basic Usage

Nah ini bagian yang paling ditunggu. Cara paling gampang jalanin Depth Anything adalah pakai pipeline dari transformers. Cuma butuh beberapa baris kode doang.

Pakai pipeline("depth-estimation")

Pipeline itu abstraksi tingkat tinggi dari HuggingFace yang ngurusin semua urusan preprocessing, inference, dan postprocessing buat kita. Jadi kita tinggal kasih gambar, keluar depth map.

from transformers import pipeline
from PIL import Image

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

Buka gambar yang mau diproses
image = Image.open("foto.jpg")

Jalankan prediksi
result = pipe(image)

result adalah dict berisi 'predicteddepth' (tensor) dan 'depth' (gambar PIL)

print(result.keys())

depthimage = result["depth"]   # ini udah berupa PIL Image grayscale
depthimage.save("depthoutput.png")
print("Depth map tersimpan!")

Gampang banget kan? Objek result itu dictionary yang isinya dua hal penting. Yang pertama predicteddepth, ini tensor PyTorch mentah berisi nilai kedalaman asli. Yang kedua depth, ini udah berupa PIL Image yang siap disimpan atau ditampilkan, udah dinormalisasi ke range 0-255 buat kita.

from transformers import pipeline
from PIL import Image
import requests

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

pipe = pipeline("depth-estimation", model="depth-anything/Depth-Anything-V2-Small-hf")
result = pipe(image)
result["depth"].save("depthkucing.png")

Gambar contoh dari COCO itu foto dua kucing lagi rebahan di sofa. Setelah diproses, kalian bakal liat kucing yang deket keliatan terang dan dinding di belakang keliatan gelap.

Milih Ukuran Model: Small, Base, Large

Depth Anything V2 datang dalam beberapa ukuran, dan kalian tinggal ganti nama model di pipeline. Ini pilihannya:

# Small: paling cepet, paling ringan (~25 juta parameter), cocok buat real-time / CPU
"depth-anything/Depth-Anything-V2-Small-hf"

Base: keseimbangan kecepatan dan akurasi (~98 juta parameter)
"depth-anything/Depth-Anything-V2-Base-hf"

Large: paling akurat, paling detail (~335 juta parameter), butuh GPU
"depth-anything/Depth-Anything-V2-Large-hf"

Gimana milihnya? Kalau kalian butuh kecepatan, misalnya buat proses video atau jalan di CPU/laptop biasa, pakai Small. Hasilnya udah bagus banget kok buat kebanyakan kasus. Kalau kalian butuh detail maksimal buat cetak besar atau rekonstruksi 3D yang presisi, dan punya GPU yang lumayan, pakai Large. Base ada di tengah-tengah buat yang mau balance.

Aku pribadi biasanya mulai dari Small dulu buat prototyping karena cepet, baru upgrade ke Large kalau memang butuh kualitas. Perbedaan waktu inference-nya lumayan signifikan, Small bisa beberapa kali lipat lebih cepet dibanding Large.

Visualisasi dengan Colormap yang Cakep

Depth map grayscale itu agak membosankan diliat. Biar lebih informatif dan enak diliat, kita bisa kasih colormap. Aku suka pakai colormap "inferno" atau "magma" dari matplotlib.

import numpy as np
import matplotlib.pyplot as plt
from transformers import pipeline
from PIL import Image

pipe = pipeline("depth-estimation", model="depth-anything/Depth-Anything-V2-Small-hf")
image = Image.open("foto.jpg")
result = pipe(image)

Ambil depth mentah sebagai numpy array
depth = np.array(result["depth"])

Tampilkan side by side: gambar asli dan depth map berwarna
fig, axes = plt.subplots(1, 2, figsize=(14, 6))
axes[0].imshow(image)
axes[0].settitle("Gambar Asli")

axes[0].axis("off")

im = axes[1].imshow(depth, cmap="inferno")
axes[1].settitle("Depth Map")
axes[1].axis("off")
fig.colorbar(im, ax=axes[1], fraction=0.046)

plt.tightlayout()

plt.savefig("perbandingandepth.png", dpi=150)
plt.show()

Dengan colormap inferno, area yang deket (nilai tinggi) bakal keliatan kuning terang, dan area jauh (nilai rendah) bakal ungu gelap. Jauh lebih enak diliat kan dibanding grayscale polos.

Advanced Usage

Oke sekarang kita naik level. Pipeline itu enak buat cepet-cepetan, tapi kadang kita butuh kontrol lebih. Di bagian ini kita bakal load model secara manual, ngerti proses raw depth, ngebahas metric vs relative depth, dan proses video.

Load Model Secara Manual

Kalau kalian mau kontrol penuh, misalnya mau atur ukuran input, batch processing, atau ambil raw tensor buat komputasi lanjutan, load model langsung pakai AutoImageProcessor dan AutoModelForDepthEstimation.

import torch
import numpy as np
from PIL import Image
from transformers import AutoImageProcessor, AutoModelForDepthEstimation

device = "cuda" if torch.cuda.isavailable() else "cpu"


Load processor dan model
modelname = "depth-anything/Depth-Anything-V2-Small-hf"
processor = AutoImageProcessor.frompretrained(modelname)
model = AutoModelForDepthEstimation.frompretrained(modelname).to(device)
model.eval()

Siapkan gambar
image = Image.open("foto.jpg").convert("RGB")

Preprocess: resize, normalisasi, jadiin tensor
inputs = processor(images=image, returntensors="pt").to(device)


Inference tanpa hitung gradient biar hemat memori
with torch.nograd():
    outputs = model(*inputs)

    predicteddepth = outputs.predicteddepth

print("Shape raw depth:", predicteddepth.shape)

import torch.nn.functional as F

Interpolasi depth ke ukuran gambar asli (height, width)
prediction = F.interpolate(
    predicteddepth.unsqueeze(1),          # tambah dimensi channel

    size=image.size[::-1],                 # PIL size = (w, h), kita butuh (h, w)
    mode="bicubic",
    aligncorners=False,
).squeeze()

Pindah ke CPU dan jadiin numpy
depth = prediction.cpu().numpy()

Normalisasi ke range 0-255 buat visualisasi
depthmin = depth.min()

depthmax = depth.max()
depthnormalized = (depth - depthmin) / (depthmax - depthmin)  # jadi 0-1
depthuint8 = (depthnormalized  255).astype(np.uint8)

Simpan sebagai gambar grayscale
Image.fromarray(depthuint8).save("depthmanual.png")
print("Range depth mentah:", depthmin, "sampai", depthmax)

Rumus normalisasi min-max di atas itu standar banget. Kita geser nilai terkecil ke 0 dan skala nilai terbesar ke 1, terus kali 255 biar jadi 8-bit. Ingat, karena ini inverse depth, nilai terang = deket.

Metric Depth vs Relative Depth

Ini konsep penting yang wajib kalian pahami sebelum pakai depth map buat aplikasi serius.

Relative depth itu artinya model cuma ngasih tau urutan atau perbandingan kedalaman, tapi bukan angka jarak sebenarnya dalam satuan meter. Jadi kalian tau bahwa objek A lebih deket dari objek B, tapi nggak tau persis A itu 2 meter atau 5 meter dari kamera. Depth Anything V2 versi default (yang kita pakai di atas) itu ngeluarin relative depth. Ini cukup buat efek visual, segmentasi latar depan-belakang, dan kebanyakan aplikasi kreatif.

Metric depth itu artinya model ngasih angka jarak absolut dalam satuan meter. Ini yang kalian butuhin kalau mau rekonstruksi 3D beneran, ngukur jarak buat robot, atau navigasi. Depth Anything V2 punya varian khusus metric depth yang di-fine-tune untuk dataset indoor (Hypersim) dan outdoor (Virtual KITTI).

Buat pakai metric depth, kalian pakai model varian metric:

import torch
from PIL import Image
from transformers import AutoImageProcessor, AutoModelForDepthEstimation

device = "cuda" if torch.cuda.isavailable() else "cpu"


Model metric depth untuk indoor
modelname = "depth-anything/Depth-Anything-V2-Metric-Indoor-Small-hf"
processor = AutoImageProcessor.frompretrained(modelname)
model = AutoModelForDepthEstimation.frompretrained(modelname).to(device)
model.eval()

image = Image.open("ruangan.jpg").convert("RGB")
inputs = processor(images=image, returntensors="pt").to(device)


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

    predicteddepth = outputs.predicteddepth

Untuk metric model, nilai depth ADALAH jarak dalam meter
depthmeters = predicteddepth.squeeze().cpu().numpy()
print("Jarak minimum:", depthmeters.min(), "meter")

print("Jarak maksimum:", depthmeters.max(), "meter")

# Untuk pemandangan luar ruangan (jalan, kendaraan, dsb)
modelname = "depth-anything/Depth-Anything-V2-Metric-Outdoor-Small-hf"

import cv2
import numpy as np
from PIL import Image
from transformers import pipeline

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

image = Image.open("orang.jpg").convert("RGB")
result = pipe(image)

Depth sudah 0-255, subjek deket = nilai tinggi
depth = np.array(result["depth"]).astype(np.float32) / 255.0

img = np.array(image)

Bikin versi blur dari gambar
blurred = cv2.GaussianBlur(img, (0, 0), sigmaX=15)

Bikin mask: piksel dengan depth tinggi (deket) = tajam, rendah (jauh) = blur
depth jadi bobot per piksel, ekspansi ke 3 channel
mask = depth[:, :, np.newaxis]

Campur gambar tajam dan blur pakai mask sebagai bobot
output = (img  mask + blurred  (1 - mask)).astype(np.uint8)


Image.fromarray(output).save("bokehoutput.jpg")
print("Efek bokeh selesai!")

import cv2
import numpy as np
import torch
from PIL import Image
from transformers import pipeline

device = 0 if torch.cuda.isavailable() else -1

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

Buka video input
cap = cv2.VideoCapture("input.mp4")
fps = cap.get(cv2.CAPPROPFPS)

width = int(cap.get(cv2.CAPPROPFRAMEWIDTH))
height = int(cap.get(cv2.CAPPROPFRAMEHEIGHT))


Siapkan writer output
fourcc = cv2.VideoWriterfourcc("mp4v")
out = cv2.VideoWriter("outputdepth.mp4", fourcc, fps, (width, height))


framecount = 0
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # OpenCV pakai BGR, konversi ke RGB buat PIL
    rgb = cv2.cvtColor(frame, cv2.COLORBGR2RGB)

    pilimage = Image.fromarray(rgb)

    # Prediksi depth
    result = pipe(pilimage)

    depth = np.array(result["depth"])

    # Kasih colormap biar berwarna (OpenCV colormap)
    depthcolor = cv2.applyColorMap(depth, cv2.COLORMAPINFERNO)


    # Pastiin ukuran sama dengan output
    depthcolor = cv2.resize(depthcolor, (width, height))


    out.write(depthcolor)
    framecount += 1

    if framecount % 30 == 0:
        print(f"Sudah proses {framecount} frame")


cap.release()
out.release()
print("Video depth selesai:", framecount, "frame")

Perlu dicatet, proses video itu berat karena tiap frame di-inference satu per satu. Video 10 detik dengan 30 fps aja udah 300 frame. Kalau punya GPU, jauh lebih cepet. Buat mempercepat, kalian bisa turunin resolusi frame sebelum inference, atau skip beberapa frame terus interpolasi.

Satu catatan penting soal video: karena tiap frame diproses independen, kadang ada flickering atau kedip antar frame karena nilai depth-nya nggak konsisten. Buat aplikasi serius, ada teknik temporal smoothing atau varian Depth Anything khusus video, tapi buat kebanyakan kasus hasil frame-by-frame udah cukup oke.

Batch Processing Banyak Gambar

Kalau kalian punya banyak gambar buat diproses, jangan proses satu-satu bolak-balik load model. Load model sekali, terus loop.

import os
import numpy as np
from PIL import Image
from transformers import pipeline

pipe = pipeline("depth-estimation", model="depth-anything/Depth-Anything-V2-Base-hf")

inputdir = "gambarinput"
outputdir = "depthoutput"
os.makedirs(outputdir, existok=True)

for filename in os.listdir(inputdir):

    if not filename.lower().endswith((".jpg", ".png", ".jpeg")):
        continue
    path = os.path.join(inputdir, filename)
    image = Image.open(path).convert("RGB")
    result = pipe(image)
    outname = os.path.splitext(filename)[0] + "depth.png"
    result["depth"].save(os.path.join(outputdir, outname))
    print("Selesai:", filename)

print("Semua gambar sudah diproses!")

Best Practices

Setelah cukup lama main sama model ini, ada beberapa tips yang pengen aku bagi biar kalian nggak jatuh di lubang yang sama kayak aku dulu.

Pertama soal pemilihan model, mulai selalu dari Small buat eksperimen. Bedanya sama Large di banyak kasus nggak sebesar yang kalian kira, tapi kecepatannya beda jauh. Baru upgrade ke Base atau Large kalau kalian bener-bener ngeliat hasil Small kurang detail buat kebutuhan kalian.

Kedua soal inverse depth, selalu inget bahwa model relative depth ngeluarin inverse depth di mana nilai tinggi = deket. Kalau kalian mau angka yang lebih intuitif (jauh = nilai tinggi), tinggal balik aja dengan depthinvert = depth.max() - depth. Tapi hati-hati, ini cuma buat visualisasi, bukan jarak metrik beneran.

Keempat soal memori, model Large itu berat, apalagi kalau gambar kalian resolusi tinggi. Kalau kena out of memory di GPU, coba turunin resolusi input dulu, atau pindah ke CPU, atau pakai model yang lebih kecil. Selalu bungkus inference dengan torch.nograd() biar nggak nyimpen gradient yang nggak perlu.

# Contoh bikin fungsi helper yang rapi dan reusable
import torch
import numpy as np
import torch.nn.functional as F
from PIL import Image
from transformers import AutoImageProcessor, AutoModelForDepthEstimation

class DepthEstimator:
    def init(self, modelname="depth-anything/Depth-Anything-V2-Small-hf"):

        self.device = "cuda" if torch.cuda.isavailable() else "cpu"
        self.processor = AutoImageProcessor.frompretrained(modelname)
        self.model = AutoModelForDepthEstimation.frompretrained(modelname).to(self.device)
        self.model.eval()

    def predict(self, imagepath):

        image = Image.open(imagepath).convert("RGB")
        inputs = self.processor(images=image, returntensors="pt").to(self.device)

        with torch.nograd():
            outputs = self.model(*inputs)

        prediction = F.interpolate(
            outputs.predicteddepth.unsqueeze(1),

            size=image.size[::-1],
            mode="bicubic",
            aligncorners=False,
        ).squeeze()
        return prediction.cpu().numpy()

    @staticmethod
    def normalize(depth):
        d = (depth - depth.min()) / (depth.max() - depth.min())
        return (d  255).astype(np.uint8)

Pakainya jadi rapi banget
estimator = DepthEstimator()
depth = estimator.predict("foto.jpg")
Image.fromarray(DepthEstimator.normalize(depth)).save("hasil.png")

Kelima soal kualitas input, model ini cukup robust, tapi tetep aja gambar yang jelas, terang, dan fokus bakal ngasih depth map yang lebih bagus daripada gambar blur atau gelap. Gambar dengan objek yang jelas batasnya bakal dapet depth map yang lebih tajam.

Keenam soal preprocessing, jangan lupa selalu konversi gambar ke RGB pakai .convert("RGB"). Kadang ada gambar PNG yang punya alpha channel atau gambar grayscale yang bikin error kalau nggak dikonversi dulu.

Ketujuh soal GPU vs CPU, buat produksi yang butuh throughput tinggi, GPU wajib. Tapi buat aplikasi ringan atau proses batch kecil di background, CPU dengan model Small masih sangat layak. Ukur dulu kebutuhan kalian sebelum langsung sewa GPU mahal.

Conclusion

Oke temen-temen, kita udah sampai di ujung tutorial. Kita udah belajar banyak hal soal Depth Anything V2, mulai dari konsep dasar monocular depth estimation, kenapa dia berguna, sampai praktek langsung dari pipeline sederhana sampai load model manual.

Poin-poin penting yang aku harap kalian bawa pulang: monocular depth estimation itu nebak kedalaman dari satu gambar aja, dan Depth Anything V2 adalah salah satu model terbaik buat itu sekarang. Cara paling gampang pakainya lewat pipeline("depth-estimation"), tinggal beberapa baris kode. Ada tiga ukuran model, Small buat cepet, Large buat akurat, Base di tengah. Ingat baik-baik bedanya relative depth (perbandingan, inverse, nilai tinggi = deket) dan metric depth (jarak beneran dalam meter, nilai tinggi = jauh). Buat visualisasi, kita normalisasi min-max terus kasih colormap. Dan kita juga udah liat cara bikin efek bokeh serta proses video frame per frame.

Yang paling aku suka dari model ini adalah dia bikin teknologi yang dulunya butuh hardware mahal (LiDAR, kamera stereo) jadi bisa diakses siapa aja cuma modal satu foto dan sedikit kode Python. Ini membuka pintu buat banyak banget ide kreatif dan aplikasi praktis.

Saranku, jangan cuma baca, langsung praktek. Ambil foto random dari galeri kalian, jalanin kode di atas, dan liat sendiri depth map-nya. Terus coba bikin efek bokeh atau proses video pendek. Dari situ kalian bakal dapet feeling gimana model ini bekerja dan di mana batasannya. Kalau udah nyaman, coba integrasikan ke proyek kalian sendiri, entah itu aplikasi foto, tools 3D, atau robotika.

Selamat ngoprek temen-temen, semoga tutorial ini berguna. Sampai ketemu di tutorial berikutnya!