Ce modèle a été publié dans HF papers le 2024-06-13 et contribué à Hugging Face Transformers le 2024-07-05.

Depth Anything V2

Aperçu

Depth Anything V2 a été présenté dans l’article du même nom par Lihe Yang et al. Il utilise la même architecture que le modèle Depth Anything original, mais s’appuie sur des données synthétiques et un modèle enseignant de plus grande capacité pour obtenir des prédictions de profondeur beaucoup plus fines et robustes.

L'abstract de l'article est le suivant :

Ce travail présente Depth Anything V2. Sans recourir à des techniques élaborées, nous visons à révéler des résultats essentiels afin de préparer la voie vers la construction d'un modèle puissant d'estimation de profondeur monoculaire. Notamment, par rapport à la V1, cette version produit des prédictions de profondeur beaucoup plus fines et plus robustes grâce à trois pratiques clés : 1) le remplacement de toutes les images réelles étiquetées par des images synthétiques, 2) l'augmentation de la capacité de notre modèle enseignant, et 3) l'enseignement des modèles étudiants via le pont des images réelles pseudo-étiquetées à grande échelle. Par rapport aux derniers modèles construits sur Stable Diffusion, nos modèles sont significativement plus efficaces (plus de 10 fois plus rapides) et plus précis. Nous proposons des modèles de différentes tailles (allant de 25M à 1,3B de paramètres) pour soutenir des scénarios variés. Bénéficiant de leur forte capacité de généralisation, nous les affinons avec des étiquettes de profondeur métrique pour obtenir nos modèles de profondeur métrique. En plus de nos modèles, compte tenu de la diversité limitée et du bruit fréquent dans les ensembles de test actuels, nous construisons un banc d'évaluation polyvalent avec des annotations précises et des scènes diverses pour faciliter les recherches futures.

Les modèles Depth Anything ont été contribué par nielsr. Le code d'origine peut être trouvé ici.

Exemple d'utilisation

Il existe deux principales façons d’utiliser Depth Anything V2 : soit en utilisant l’API pipeline, qui abstrait toute la complexité pour vous, soit en utilisant vous-même la classe DepthAnythingForDepthEstimation.

API Pipeline

Le pipeline permet d'utiliser le modèle en quelques lignes de code :

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

Utiliser le modèle vous-même

Si vous souhaitez effectuer vous-même le prétraitement et le post-traitement, voici comment faire :

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

Ressources

Une liste de ressources officielles Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec Depth Anything.

• Guide de la tâche d'estimation de profondeur monoculaire
• Démo de Depth Anything V2.
• Un notebook illustrant l'inférence avec DepthAnythingForDepthEstimation est disponible ici. 🌎
• Conversion Core ML de la variante small pour une utilisation sur Apple Silicon.

Si vous souhaitez soumettre une ressource pour qu'elle soit incluse ici, n'hésitez pas à ouvrir une Pull Request et nous la examinerons ! La ressource devrait idéalement démontrer quelque chose de nouveau plutôt que de dupliquer une ressource existante.

DepthAnythingConfig

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

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