Una implementación de código de la estimación de profundidad monocular utilizando el modelo de código abierto Intel Midas en Google Colab con Pytorch y OpenCV

La estimación de la profundidad monocular implica predecir la profundidad de la escena de una sola imagen RGB, una tarea fundamental en la visión por computadora con aplicaciones de gran alcance, que incluyen realidad aumentada, robótica y comprensión de la escena 3D. En este tutorial, implementamos el MIDAS de Intel (estimación de profundidad monocular a través de un transformador de visión a múltiples escala), un modelo de última generación diseñado para una predicción de profundidad de alta calidad a partir de una sola imagen. Aprovechando Google Colab como la plataforma de cómputo, junto con Pytorch, OpenCV y Matplotlib, este tutorial le permite cargar su imagen y visualizar los mapas de profundidad correspondientes fácilmente.

!pip install -q timm opencv-python matplotlib

Primero, instalamos las bibliotecas de Python necesarias: TIMM para el soporte del modelo, OpenCV-Python para el procesamiento de imágenes y matplotlib para visualizar los mapas de profundidad.

!git clone https://github.com/isl-org/MiDaS.git
%cd MiDaS

Luego, clonamos el repositorio oficial de Intel Midas desde GitHub y navegamos a su directorio para acceder al código del modelo y las utilidades de transformación.

import torch
import cv2
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
from torchvision.transforms import Compose
from google.colab import files


from midas.dpt_depth import DPTDepthModel
from midas.transforms import Resize, NormalizeImage, PrepareForNet
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

Importamos todas las bibliotecas necesarias y componentes MIDAS necesarios para cargar el modelo, preprocesar imágenes, manejar cargas y visualizar las predicciones de profundidad. Luego establecemos el dispositivo de cálculo en GPU (CUDA) si está disponible; De lo contrario, el valor predeterminado a la CPU, asegurando la compatibilidad del sistema.

model_path = torch.hub.load("intel-isl/MiDaS", "DPT_Large", pretrained=True, force_reload=True)
model = model_path.to(device)
model.eval()

Aquí, descargamos el modelo MIDAS DPT_LARGE previamente practicado de Intel’s Torch.Hub, lo mueve al dispositivo seleccionado (CPU o GPU) y lo establece en modo de evaluación para inferencia.

transform = Compose([
    Resize(384, 384, resize_target=None, keep_aspect_ratio=True, ensure_multiple_of=32, resize_method="upper_bound"),
    NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
    PrepareForNet()
])

Definimos la tubería de preprocesamiento de la imagen de Midas, que cambia de tamaño de la imagen de entrada, normaliza sus valores de píxeles y la formatea adecuadamente para la inferencia del modelo.

uploaded = files.upload()
for filename in uploaded:
    img = cv2.imread(filename)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    break

Permitimos que el usuario cargue una imagen en Colab, la lea usando OpenCV y la convierta de BGR a Formato RGB para una representación de color precisa.

img_input = transform({"image": img})["image"]
input_tensor = torch.from_numpy(img_input).unsqueeze(0).to(device)


with torch.no_grad():
    prediction = model(input_tensor)
    prediction = torch.nn.functional.interpolate(
        prediction.unsqueeze(1),
        size=img.shape[:2],
        mode="bicubic",
        align_corners=False,
    ).squeeze()


depth_map = prediction.cpu().numpy()

Ahora, aplicamos la transformación de preprocesamiento a la imagen cargada, la convertimos en un tensor, realizamos una predicción de profundidad usando el modelo MIDAS, cambia el tamaño de la salida para que coincida con las dimensiones de la imagen originales y extraiga el mapa de profundidad final como una matriz numpy.

plt.figure(figsize=(10, 5))


plt.subplot(1, 2, 1)
plt.imshow(img)
plt.title("Original Image")
plt.axis("off")


plt.subplot(1, 2, 2)
plt.imshow(depth_map, cmap='inferno')
plt.title("Depth Map")
plt.axis("off")


plt.tight_layout()
plt.show()

Finalmente, creamos una visualización de lado a lado de la imagen original y su mapa de profundidad correspondiente usando matplotlib. El mapa de profundidad se muestra utilizando el color ‘infernal’ para un mejor contraste.

En conclusión, al completar este tutorial, hemos implementado con éxito el modelo MIDAS de Intel en Google Colab para realizar una estimación de profundidad monocular utilizando solo una imagen RGB. Utilizando Pytorch para la inferencia del modelo, OpenCV para el procesamiento de imágenes y Matplotlib para la visualización, hemos construido una tubería robusta para generar mapas de profundidad de alta calidad con una configuración mínima. Esta implementación es una base sólida para una exploración adicional, incluida la estimación de profundidad de video, las aplicaciones en tiempo real e integración de sistemas AR/VR.

Aquí está el Cuaderno de colab. Además, no olvides seguirnos Gorjeo y únete a nuestro Canal de telegrama y LinkedIn GRsalpicar. No olvides unirte a nuestro 85k+ ml de subreddit.