Estimation de la profondeur monoculaire

L'estimation de profondeur monoculaire est une tâche de vision par ordinateur qui consiste à prédire les informations de profondeur d'une scène à partir d'une seule image. Autrement dit, il s'agit du processus d'estimation de la distance des objets d'une scène à partir d'un seul point de vue de caméra.

L'estimation de profondeur monoculaire présente diverses applications, notamment la reconstruction 3D, la réalité augmentée, la conduite autonome et la robotique. C'est une tâche complexe, car elle exige du modèle qu'il comprenne les relations complexes entre les objets de la scène et les informations de profondeur correspondantes, qui peuvent être affectées par des facteurs tels que les conditions d'éclairage, l'occlusion et la texture.

Il existe deux principales catégories d'estimation de profondeur :

• Estimation de profondeur absolue : Cette variante de tâche vise à fournir des mesures de profondeur exactes depuis la caméra. Le terme est utilisé de manière interchangeable avec l'estimation de profondeur métrique, où la profondeur est fournie en mesures précises en mètres ou en pieds. Les modèles d'estimation de profondeur absolue produisent des cartes de profondeur dont les valeurs numériques représentent des distances réelles.

• Estimation de profondeur relative : L'estimation de profondeur relative vise à prédire l'ordre de profondeur des objets ou des points dans une scène sans fournir de mesures précises. Ces modèles produisent une carte de profondeur indiquant quelles parties de la scène sont plus proches ou plus éloignées les unes des autres, sans donner les distances réelles entre A et B.

Dans ce guide, nous allons voir comment effectuer de l’inférence avec Depth Anything V2, un modèle d’estimation relative de la profondeur zero-shot de pointe, et ZoeDepth, un modèle d’estimation absolue de la profondeur.

Consultez la page de la tâche Depth Estimation pour afficher toutes les architectures et points de contrôle compatibles.

Avant de commencer, nous devons installer la dernière version de Transformers :

pip install -q -U transformers

Pipeline d'estimation de profondeur

La manière la plus simple d’essayer l’inférence avec un modèle prenant en charge l’estimation de la profondeur est d’utiliser le pipeline() correspondant. Instanciez un pipeline à partir d’un point de contrôle sur le 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)

Ensuite, choisissez une image à analyser :

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

Passez l'image au pipeline.

>>> predictions = pipe(image)

Le pipeline renvoie un dictionnaire avec deux entrées. La première, nommée predicted_depth, est un tenseur dont les valeurs correspondent à la profondeur exprimée en mètres pour chaque pixel. La seconde, depth, est une image PIL qui visualise le résultat de l'estimation de la profondeur.

Examinons le résultat visualisé :

>>> predictions["depth"]

Inférence d'estimation de profondeur manuelle

Maintenant que vous avez vu comment utiliser le pipeline d'estimation de profondeur, voyons comment reproduire le même résultat manuellement.

Commencez par charger le modèle et le processeur associés depuis un point de contrôle sur le Hugging Face Hub. Ici, nous utiliserons le même point de contrôle que précédemment :

>>> from transformers import AutoImageProcessor, AutoModelForDepthEstimation

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

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

Préparez l'entrée image pour le modèle à l'aide de image_processor, qui s'occupera des transformations d'image nécessaires telles que le redimensionnement et la normalisation :

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

Faites passer les entrées préparées à travers le modèle :

>>> import torch

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

Procédons au post-traitement des résultats afin de supprimer le bourrage et de redimensionner la carte de profondeur pour qu’elle corresponde à la taille de l’image d’origine. La fonction post_process_depth_estimation renvoie une liste de dictionnaires contenant la clé "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"))

Dans l'implémentation originale, le modèle ZoeDepth effectue l'inférence sur l'image originale et l'image retournée, puis moyenne les résultats. La fonction post_process_depth_estimation peut s'en charger pour nous en transmettant les sorties retournées à l'argument facultatif 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,
... )