Estimación de Profundidad Monocular con Redes Convolucionales Profundas en PyTorch

La estimación de profundidad monocular es una tarea fascinante de la visión artificial que busca predecir un mapa de profundidad denso (la distancia de cada píxel de la imagen a la cámara) a partir de una sola imagen RGB 2D. A diferencia de los métodos estéreo o de tiempo de vuelo (ToF), que requieren múltiples cámaras o hardware especializado, la estimación monocular ofrece una solución más económica y versátil, aunque intrínsecamente más desafiante.

En este tutorial, desglosaremos los principios detrás de la estimación de profundidad monocular, cómo las redes neuronales convolucionales (CNNs) han revolucionado este campo y te guiaremos a través de un ejemplo práctico utilizando PyTorch para construir y entrenar un modelo básico.

🎯 ¿Por Qué la Estimación de Profundidad Monocular?

La capacidad de inferir la profundidad desde una sola imagen tiene un sinfín de aplicaciones:

• Robótica y Vehículos Autónomos: Navegación, planificación de rutas, detección de obstáculos y mapeo 3D.
• Realidad Aumentada (RA) y Virtual (RV): Superposición de objetos virtuales de manera realista en escenas del mundo real, interacción espacial.
• Edición de Imágenes y Video: Efectos de desenfoque de profundidad (bokeh), manipulación 3D, reiluminación.
• Medición y Reconstrucción 3D: Estimación de dimensiones, modelado de escenas.

📖 Fundamentos Teóricos

La Ambivalencia del Mundo 3D en 2D

Cuando proyectamos un objeto 3D sobre un plano 2D (como la retina o el sensor de una cámara), perdemos la información de profundidad. Objetos de diferentes tamaños y distancias pueden proyectarse en el mismo tamaño aparente en la imagen 2D. Sin embargo, el cerebro humano y, por extensión, las redes neuronales, utilizan una variedad de pistas monoculares para inferir la profundidad:

• Perspectiva Lineal: Líneas paralelas convergen en un punto de fuga.
• Tamaño Relativo: Objetos del mismo tipo parecen más pequeños cuanto más lejos están.
• Oclusión: Un objeto que bloquea la vista de otro se percibe como más cercano.
• Textura y Gradientes: Las texturas se vuelven más densas y menos detalladas con la distancia.
• Sombreado y Sombras: La distribución de la luz y las sombras proporciona pistas sobre la forma y profundidad.
• Niebla/Atmósfera: Objetos distantes aparecen menos contrastados y con tonos azulados.

Las redes convolucionales profundas son capaces de aprender a extraer y combinar estas pistas complejas para predecir el mapa de profundidad.

Arquitecturas de Redes Neuronales 🧠

Tradicionalmente, la estimación de profundidad se trataba como un problema de regresión píxel a píxel, donde la red produce un mapa de profundidad del mismo tamaño que la imagen de entrada. Las arquitecturas más comunes para esta tarea son las redes codificador-decodificador.

• Codificador (Encoder): Extrae características de alto nivel de la imagen de entrada. Generalmente, es una red convolucional profunda (ej., ResNet, VGG) que reduce espacialmente la imagen mientras aumenta la profundidad de las características.
• Decodificador (Decoder): Reconstruye el mapa de profundidad a partir de las características de alto nivel. A menudo utiliza capas de transposición convolucional (o deconvolución) para aumentar la resolución espacial y producir una salida densa.
• Conexiones de Salto (Skip Connections): Son cruciales para llevar información de características de baja resolución (bordes, texturas) del codificador al decodificador. Esto ayuda al decodificador a producir mapas de profundidad más detallados y evitar la pérdida de información fina.

Función de Pérdida (Loss Function) 📉

La elección de la función de pérdida es vital. Para la estimación de profundidad, las funciones de pérdida comunes incluyen:

• L1/L2 Loss (MSE/MAE): Miden la diferencia absoluta o cuadrática entre la profundidad predicha y la profundidad real (ground truth).
• Pérdida de Gradiente (Gradient Loss): Anima al modelo a generar mapas de profundidad con transiciones suaves, penalizando diferencias abruptas que no corresponden a bordes reales. Esto ayuda a evitar la 'pixelación' en el mapa de profundidad.
• Pérdida de Escala Invariante (Scale-Invariant Loss): Un problema común es que la profundidad absoluta es difícil de estimar con una sola imagen. Esta pérdida se centra en la forma relativa del mapa de profundidad, permitiendo que el modelo sea robusto a variaciones de escala global. Un ejemplo es la pérdida propuesta por Eigen et al. (2014) o la pérdida de escala invariante de Log (SILog).

import torch
import torch.nn as nn

def scale_invariant_log_loss(prediction, target, mask=None, lambda_reg=0.5):
    # Ignorar píxeles sin valor de profundidad (ej. enmascarados)
    if mask is not None:
        prediction = prediction[mask]
        target = target[mask]

    if prediction.numel() == 0: # Si no quedan píxeles válidos
        return torch.tensor(0.0, device=prediction.device, dtype=prediction.dtype)

    # Calcular la diferencia de logaritmos
    diff = torch.log(prediction + 1e-8) - torch.log(target + 1e-8)

    # Calcular el primer término: media de las diferencias al cuadrado
    term1 = torch.mean(diff ** 2)

    # Calcular el segundo término: cuadrado de la media de las diferencias
    term2 = (torch.mean(diff)) ** 2

    # Combinar los términos
    loss = term1 - lambda_reg * term2
    return loss

class MonocularDepthLoss(nn.Module):
    def __init__(self, lambda_si_log=0.5, lambda_gradient=1.0):
        super(MonocularDepthLoss, self).__init__()
        self.lambda_si_log = lambda_si_log
        self.lambda_gradient = lambda_gradient

    def forward(self, prediction, target, mask=None):
        # Pérdida de escala invariante logarítmica
        si_log_loss = scale_invariant_log_loss(prediction, target, mask, self.lambda_si_log)

        # Pérdida de gradiente
        gradient_loss = self._gradient_loss(prediction, target, mask)

        return si_log_loss + self.lambda_gradient * gradient_loss

    def _gradient_loss(self, prediction, target, mask=None):
        # Calcular gradientes para predicción
        pred_dx = torch.abs(prediction[:, :, :, :-1] - prediction[:, :, :, 1:])
        pred_dy = torch.abs(prediction[:, :, :-1, :] - prediction[:, :, 1:, :])

        # Calcular gradientes para target
        target_dx = torch.abs(target[:, :, :, :-1] - target[:, :, :, 1:])
        target_dy = torch.abs(target[:, :, :-1, :] - target[:, :, 1:, :])

        # Aplicar máscaras si existen
        if mask is not None:
            mask_dx = mask[:, :, :, :-1] * mask[:, :, :, 1:]
            mask_dy = mask[:, :, :-1, :] * mask[:, :, 1:, :]
            pred_dx = pred_dx * mask_dx
            pred_dy = pred_dy * mask_dy
            target_dx = target_dx * mask_dx
            target_dy = target_dy * mask_dy

        # Pérdida L1 de los gradientes
        gradient_loss_x = torch.mean(torch.abs(pred_dx - target_dx))
        gradient_loss_y = torch.mean(torch.abs(pred_dy - target_dy))

        return gradient_loss_x + gradient_loss_y

🛠️ Implementación Práctica con PyTorch

Para este tutorial, construiremos un modelo simple de tipo codificador-decodificador basado en un ResNet pre-entrenado como codificador y un decodificador personalizado. Utilizaremos el conjunto de datos NYU Depth V2 para el entrenamiento, que proporciona imágenes RGB y sus correspondientes mapas de profundidad.

1. Entorno y Dependencias 🐍

Necesitarás tener PyTorch y otras bibliotecas comunes de visión artificial instaladas.

# Instalación básica
pip install torch torchvision matplotlib numpy opencv-python scikit-image

# Para un entorno CUDA (GPU)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

2. Preparación del Conjunto de Datos (NYU Depth V2) 💾

NYU Depth V2 es un dataset popular para estimación de profundidad, consistente en pares de imágenes RGB y mapas de profundidad obtenidos de una cámara Kinect. Es un dataset grande, así que la descarga y preprocesamiento pueden tomar tiempo.

Para simplificar, usaremos una versión ya preprocesada o implementaremos un Dataset que cargue los datos directamente desde el formato raw si tenemos los archivos descargados.

Suponiendo que ya has descargado el dataset y está organizado de alguna manera (ej. en carpetas images/ y depth_maps/), aquí un ejemplo de cómo crear un Dataset personalizado.

import os
import torch
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import numpy as np

class NYUDepthDataset(Dataset):
    def __init__(self, root_dir, transform=None):
        self.root_dir = root_dir
        self.transform = transform
        self.image_dir = os.path.join(root_dir, 'images')
        self.depth_dir = os.path.join(root_dir, 'depth_maps') # O el nombre de tu carpeta de mapas de profundidad

        self.image_filenames = sorted([f for f in os.listdir(self.image_dir) if f.endswith('.jpg') or f.endswith('.png')])

    def __len__(self):
        return len(self.image_filenames)

    def __getitem__(self, idx):
        img_name = self.image_filenames[idx]
        img_path = os.path.join(self.image_dir, img_name)
        # Asumimos que el nombre del mapa de profundidad es similar al de la imagen
        # Puede que necesites ajustar esto según tu estructura de carpetas
        depth_name = img_name.replace('.jpg', '.png') # Ejemplo: si profundidades son PNG
        depth_path = os.path.join(self.depth_dir, depth_name)

        image = Image.open(img_path).convert('RGB')
        # Los mapas de profundidad de NYU a menudo están en formato PNG de 16 bits
        depth = Image.open(depth_path).convert('I') # 'I' for 32-bit signed integer pixels, similar to uint16
        depth = np.array(depth, dtype=np.float32) / 1000.0 # Convertir mm a metros
        depth = torch.from_numpy(depth).unsqueeze(0) # Añadir dimensión de canal

        # Crear máscara para valores de profundidad inválidos (0 o NaN)
        mask = (depth > 0) & (~torch.isnan(depth))

        if self.transform:
            image = self.transform(image)
            # Aplicar la misma transformación de tamaño al mapa de profundidad, si es necesario
            # Ten cuidado con las transformaciones de normalización en mapas de profundidad
            # Para el depth_map solo hacemos resize y convertimos a tensor
            depth = transforms.Resize((self.transform.transforms[0].size, self.transform.transforms[0].size))(Image.fromarray(depth.squeeze().numpy()))
            depth = torch.from_numpy(np.array(depth, dtype=np.float32)).unsqueeze(0)

        return image, depth, mask

# Definir transformaciones para las imágenes
input_transform = transforms.Compose([
    transforms.Resize((224, 224)), # Tamaño estándar para muchos modelos pre-entrenados
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # Normalización ImageNet
])

# Ejemplo de uso del DataLoader
# root_dataset = 'path/to/your/nyu_depth_v2_dataset'
# dataset = NYUDepthDataset(root_dataset, transform=input_transform)
# dataloader = DataLoader(dataset, batch_size=4, shuffle=True)

# for batch_idx, (images, depths, masks) in enumerate(dataloader):
#     print(f"Batch {batch_idx}: Image shape {images.shape}, Depth shape {depths.shape}, Mask shape {masks.shape}")
#     break

3. Definición del Modelo de Red Neuronal 🏗️

Usaremos un ResNet-50 pre-entrenado como nuestro codificador y construiremos un decodificador simple.

import torch.nn as nn
import torchvision.models as models

class DepthDecoder(nn.Module):
    def __init__(self, num_features=2048, num_channels=1):
        super(DepthDecoder, self).__init__()
        self.conv1 = nn.Conv2d(num_features, 1024, kernel_size=1)
        self.upsample1 = nn.Upsample(scale_factor=2, mode='nearest') # Usar nearest para mapas de profundidad
        self.conv2 = nn.Conv2d(1024, 512, kernel_size=3, padding=1)
        self.upsample2 = nn.Upsample(scale_factor=2, mode='nearest')
        self.conv3 = nn.Conv2d(512, 256, kernel_size=3, padding=1)
        self.upsample3 = nn.Upsample(scale_factor=2, mode='nearest')
        self.conv4 = nn.Conv2d(256, 128, kernel_size=3, padding=1)
        self.upsample4 = nn.Upsample(scale_factor=2, mode='nearest')
        self.conv5 = nn.Conv2d(128, 64, kernel_size=3, padding=1)
        self.upsample5 = nn.Upsample(scale_factor=2, mode='nearest') # Para llegar a 224x224 desde 7x7
        self.conv_out = nn.Conv2d(64, num_channels, kernel_size=3, padding=1)
        self.relu = nn.ReLU(True) # Asegurarse de que las profundidades sean positivas

    def forward(self, x):
        x = self.relu(self.conv1(x))
        x = self.upsample1(x)
        x = self.relu(self.conv2(x))
        x = self.upsample2(x)
        x = self.relu(self.conv3(x))
        x = self.upsample3(x)
        x = self.relu(self.conv4(x))
        x = self.upsample4(x)
        x = self.relu(self.conv5(x))
        x = self.upsample5(x)
        x = self.relu(self.conv_out(x))
        return x


class MonocularDepthModel(nn.Module):
    def __init__(self, num_channels=1, use_pretrained_encoder=True):
        super(MonocularDepthModel, self).__init__()
        # Codificador: ResNet-50 pre-entrenado (quitamos la capa final de clasificación)
        self.encoder = models.resnet50(pretrained=use_pretrained_encoder)
        self.encoder = nn.Sequential(*list(self.encoder.children())[:-2]) # Elimina avgpool y fc

        # Decodificador
        self.decoder = DepthDecoder(num_features=2048, num_channels=num_channels) # ResNet-50 output features

    def forward(self, x):
        # Codificador
        features = self.encoder(x)
        # Decodificador
        depth_map = self.decoder(features)
        # Asegurarse de que el mapa de profundidad final sea del mismo tamaño que la entrada
        # Esto es crucial ya que el upsampling puede no ser exacto
        return nn.functional.interpolate(depth_map, size=x.shape[2:], mode='bilinear', align_corners=True)


# Ejemplo de instanciación
# model = MonocularDepthModel(use_pretrained_encoder=True)
# dummy_input = torch.randn(1, 3, 224, 224)
# output_depth = model(dummy_input)
# print(f"Output depth map shape: {output_depth.shape}") # Debería ser (1, 1, 224, 224)

4. Bucle de Entrenamiento 🚀

Ahora, juntemos todo para el proceso de entrenamiento. Necesitaremos un optimizador y nuestra función de pérdida.

import torch.optim as optim
import matplotlib.pyplot as plt

# --- Configuración del entrenamiento ---
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Usando dispositivo: {device}")

# Parámetros del dataset (ajusta esto a tu ruta real)
root_dataset = './nyu_depth_v2_dataset' # Asegúrate de que esta carpeta exista y contenga 'images' y 'depth_maps'

# Crear dataset y dataloader
input_transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

try:
    train_dataset = NYUDepthDataset(os.path.join(root_dataset, 'train'), transform=input_transform)
    val_dataset = NYUDepthDataset(os.path.join(root_dataset, 'val'), transform=input_transform)

    train_dataloader = DataLoader(train_dataset, batch_size=8, shuffle=True, num_workers=4) # num_workers para carga paralela
    val_dataloader = DataLoader(val_dataset, batch_size=8, shuffle=False, num_workers=4)
    
    print(f"Dataset cargado: {len(train_dataset)} muestras de entrenamiento, {len(val_dataset)} muestras de validación.")

except FileNotFoundError:
    print(f"⚠️ Error: Dataset no encontrado en '{root_dataset}'. Creando dataloaders dummy para demostración.")
    # Crear dataloaders dummy para poder ejecutar el código de entrenamiento sin el dataset completo
    class DummyDataset(Dataset):
        def __len__(self): return 100 # Pequeño dataset dummy
        def __getitem__(self, idx):
            img = torch.randn(3, 224, 224) # Imagen aleatoria
            depth = torch.rand(1, 224, 224) * 10 # Profundidad aleatoria entre 0 y 10 metros
            mask = torch.ones(1, 224, 224, dtype=torch.bool) # Máscara completa
            return img, depth, mask
    train_dataloader = DataLoader(DummyDataset(), batch_size=8, shuffle=True)
    val_dataloader = DataLoader(DummyDataset(), batch_size=8, shuffle=False)


# Instanciar modelo, función de pérdida y optimizador
model = MonocularDepthModel(use_pretrained_encoder=True).to(device)
loss_function = MonocularDepthLoss(lambda_si_log=0.5, lambda_gradient=1.0).to(device)
optimizer = optim.Adam(model.parameters(), lr=0.0001)

num_epochs = 10 # Para un entrenamiento real, necesitarías más epochs

history = {'train_loss': [], 'val_loss': []}

for epoch in range(num_epochs):
    model.train() # Modo entrenamiento
    running_loss = 0.0
    for batch_idx, (images, depths, masks) in enumerate(train_dataloader):
        images, depths, masks = images.to(device), depths.to(device), masks.to(device)

        optimizer.zero_grad()
        outputs = model(images)

        loss = loss_function(outputs, depths, masks)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

        if (batch_idx + 1) % 50 == 0: # Imprimir cada 50 batches
            print(f"Epoch [{epoch+1}/{num_epochs}], Batch [{batch_idx+1}/{len(train_dataloader)}], Loss: {running_loss / (batch_idx+1):.4f}")

    avg_train_loss = running_loss / len(train_dataloader)
    history['train_loss'].append(avg_train_loss)
    print(f"Epoch {epoch+1} - Training Loss: {avg_train_loss:.4f}")

    # Evaluación en el conjunto de validación
    model.eval() # Modo evaluación
    val_loss = 0.0
    with torch.no_grad(): # No calcular gradientes en validación
        for images, depths, masks in val_dataloader:
            images, depths, masks = images.to(device), depths.to(device), masks.to(device)
            outputs = model(images)
            loss = loss_function(outputs, depths, masks)
            val_loss += loss.item()

    avg_val_loss = val_loss / len(val_dataloader)
    history['val_loss'].append(avg_val_loss)
    print(f"Epoch {epoch+1} - Validation Loss: {avg_val_loss:.4f}\n")

print("Entrenamiento completado!")

# Guardar el modelo entrenado
torch.save(model.state_dict(), 'monocular_depth_model.pth')
print("Modelo guardado como 'monocular_depth_model.pth'")

# Visualizar el historial de pérdida
plt.figure(figsize=(10, 5))
plt.plot(history['train_loss'], label='Training Loss')
plt.plot(history['val_loss'], label='Validation Loss')
plt.title('Loss durante el entrenamiento')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.grid(True)
plt.savefig('training_loss_plot.png')
plt.show()

5. Inferencia y Visualización ✨

Una vez que el modelo está entrenado, podemos usarlo para predecir mapas de profundidad en nuevas imágenes. Es importante revertir las transformaciones de normalización para la visualización.

import matplotlib.pyplot as plt
import torchvision.transforms.functional as F_vision

# Cargar el modelo entrenado
model = MonocularDepthModel(use_pretrained_encoder=True).to(device)
model.load_state_dict(torch.load('monocular_depth_model.pth', map_location=device))
model.eval()

# Función para visualizar
def visualize_depth_prediction(image_tensor, predicted_depth_map, original_image=None):
    fig, axes = plt.subplots(1, 2 if original_image is not None else 1, figsize=(12, 6))

    # Desnormalizar la imagen para visualización si es necesario
    mean = torch.tensor([0.485, 0.456, 0.406]).view(3, 1, 1)
    std = torch.tensor([0.229, 0.224, 0.225]).view(3, 1, 1)
    input_image_display = image_tensor.cpu() * std + mean
    input_image_display = F_vision.to_pil_image(input_image_display)

    if original_image is not None:
        axes[0].imshow(original_image) # Mostrar la imagen original si se proporciona
        axes[0].set_title('Imagen Original')
        axes[0].axis('off')
        ax_depth = axes[1]
    else:
        ax_depth = axes

    # El mapa de profundidad suele ser un tensor [1, H, W] o [H, W]
    depth_map_display = predicted_depth_map.squeeze().cpu().numpy()
    
    # Algunos mapas de profundidad pueden tener valores muy altos/bajos al inicio
    # Recortar o normalizar para una mejor visualización
    vmax_val = np.percentile(depth_map_display, 95) # Usar el percentil 95 como máximo
    vmin_val = np.min(depth_map_display[depth_map_display > 0]) # Mínimo solo de valores > 0
    
    if np.isnan(vmin_val) or np.isinf(vmin_val): vmin_val = 0.0
    if np.isnan(vmax_val) or np.isinf(vmax_val): vmax_val = 10.0 # Default si no hay valores validos

    c = ax_depth.imshow(depth_map_display, cmap='magma_r', vmin=vmin_val, vmax=vmax_val)
    ax_depth.set_title('Mapa de Profundidad Predicho')
    ax_depth.axis('off')
    fig.colorbar(c, ax=ax_depth, orientation='vertical', label='Profundidad (metros)')
    plt.tight_layout()
    plt.show()

# --- Ejemplo de inferencia con una imagen del dataset de validación ---
if 'val_dataset' in locals() and len(val_dataset) > 0:
    # Tomar una imagen de ejemplo del dataset de validación
    sample_idx = 5 # Elige un índice
    image_tensor, _, _ = val_dataset[sample_idx] # Solo necesitamos la imagen de entrada para la inferencia

    # Para visualización, obtener la imagen original antes de las transformaciones
    original_image_path = os.path.join(val_dataset.image_dir, val_dataset.image_filenames[sample_idx])
    original_image = Image.open(original_image_path).convert('RGB')
    
    image_tensor_batch = image_tensor.unsqueeze(0).to(device) # Añadir dimensión de batch

    with torch.no_grad():
        predicted_depth = model(image_tensor_batch)

    visualize_depth_prediction(image_tensor, predicted_depth, original_image=original_image)
else:
    print("No se pudo realizar la inferencia con el dataset de validación (no disponible o vacío).")
    # Si no hay dataset, podemos intentar con una imagen local o dummy
    print("Intentando con una imagen dummy generada aleatoriamente...")
    dummy_input_img = torch.randn(1, 3, 224, 224).to(device) # Imagen aleatoria
    with torch.no_grad():
        predicted_depth_dummy = model(dummy_input_img)
    visualize_depth_prediction(dummy_input_img.squeeze(0).cpu(), predicted_depth_dummy)

📈 Métricas de Evaluación

Evaluar la estimación de profundidad es crucial. Algunas métricas comunes incluyen:

• RMSE (Root Mean Squared Error): Mide la diferencia cuadrática promedio entre la profundidad predicha y la real.
• Abs Rel (Absolute Relative Error): |d_pred - d_gt| / d_gt. Mide el error relativo promedio.
• Sq Rel (Squared Relative Error): (d_pred - d_gt)^2 / d_gt. Similar a Abs Rel pero penaliza más los errores grandes.
• Delta Accuracies ($\ ext{delta}_i$): Porcentaje de píxeles donde max(d_pred/d_gt, d_gt/d_pred) < 1.25^i para i = 1, 2, 3. Mide qué tan cerca están las predicciones de la verdad fundamental dentro de un cierto umbral de escala.

🧐 Desafíos y Futuras Mejoras

La estimación de profundidad monocular sigue siendo un campo activo de investigación. Algunos desafíos y áreas de mejora incluyen:

• Generalización: Los modelos entrenados en un dataset a menudo no generalizan bien a nuevas escenas o entornos con características visuales diferentes.
• Profundidad Absoluta: Estimar la escala absoluta de la profundidad es inherentemente difícil con una sola imagen.
• Superficies Especulares y Transparentes: Objetos como el vidrio o superficies brillantes son muy difíciles de manejar.
• Pequeños Detalles y Bordes: A menudo, los mapas de profundidad predichos carecen de la nitidez y el detalle fino en los bordes de los objetos.
• Métodos Auto-Supervisados/No Supervisados: Entrenar modelos sin necesidad de mapas de profundidad ground truth explícitos, utilizando la consistencia de la reproyección de imágenes estéreo o de secuencias de video.

Conclusión ✅

Has aprendido sobre los fundamentos de la estimación de profundidad monocular, las arquitecturas de redes convolucionales utilizadas, las funciones de pérdida clave y cómo implementar un modelo básico en PyTorch. Esta técnica es un componente vital para muchas aplicaciones de visión artificial, y su dominio abre puertas a proyectos emocionantes en robótica, realidad aumentada y más.

¡Anímate a experimentar con diferentes arquitecturas, datasets y funciones de pérdida para mejorar aún más la precisión de tus modelos!