Visión por computadora IA

Aproximadamente el 80% de la información que los humanos obtienen proviene de la visión.

Al ver una fotografía, puedes reconocer de inmediato cuántas personas hay, qué están haciendo y si el fondo es interior o exterior.

Pero para una computadora, esa foto es solo un montón de números: cada píxel se representa con tres valores (rojo, verde, azul), y nada más.

La visión por computadora (Computer Vision, abreviado CV) es la tecnología que permite a las computadoras comprender imágenes.

Desde el desbloqueo facial en teléfonos, hasta el reconocimiento del tráfico en la conducción autónoma, pasando por el análisis de lesiones en imágenes médicas, la visión por computadora está en todas partes.

Este módulo te llevará desde las redes neuronales convolucionales básicas hasta los modelos de lenguaje visual más recientes.

Ruta de aprendizaje: Red neuronal convolucional → Vision Transformer → Detección de objetos → Segmentación de imágenes → Modelos de difusión → CLIP → Modelo de lenguaje visual. Cada paso incluye ejemplos de código ejecutables.


Red neuronal convolucional (CNN)

La CNN es la tecnología fundamental de la visión por computadora; imita el funcionamiento de la corteza visual humana y extrae características de la imagen mediante campos receptivos locales.

Principios de la operación de convolución

La idea central de la convolución es:Usar una pequeña ventana deslizante (núcleo de convolución) para escanear la imagen y extraer características locales.。

Por ejemplo, un núcleo de convolución de 3×3 observa 9 píxeles de la imagen a la vez, calcula su suma ponderada y obtiene un valor de salida.

Este proceso se repite; el núcleo de convolución se desliza por la imagen de izquierda a derecha y de arriba hacia abajo, generando finalmente un "mapa de características".

Ejemplo

# ============================================
# Implementar la operación de convolución más simple con NumPy
# Demostrar cómo la convolución extrae características de bordes
# ============================================

import numpy as np


def simple_convolution(image: np.ndarray, kernel: np.ndarray) -> np.ndarray:
    """
Implementar la operación de convolución 2D más básica (sin padding ni stride)

Parámetros:
image: imagen de entrada (H, W), imagen en escala de grises de un solo canal
kernel: núcleo de convolución (kH, kW)

Retorna:
Mapa de características después de la convolución
    """

    # Obtener las dimensiones de la imagen y del núcleo de convolución
    img_h, img_w = image.shape
    kernel_h, kernel_w = kernel.shape

    # Calcular las dimensiones del mapa de características de salida
    # Dimensión de salida = dimensión de entrada - dimensión del núcleo + 1
    out_h = img_h - kernel_h + 1
    out_w = img_w - kernel_w + 1

    # Inicializar el mapa de características de salida
    output = np.zeros((out_h, out_w))

    # Deslizar el núcleo de convolución para el cálculo
    for i in range(out_h):
        for j in range(out_w):
            # Extraer la región local de la imagen correspondiente al núcleo
            region = image[i:i+kernel_h, j:j+kernel_w]
            # Multiplicar los elementos correspondientes y sumar (esto es la convolución)
            output[i, j] = np.sum(region * kernel)

    return output


# Crear una imagen de prueba simple: un cuadrado blanco en el centro, negro alrededor
# Forma: imagen en escala de grises de 8×8
test_image = np.array([
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 1, 1, 1, 1, 0, 0],
    [0, 0, 1, 1, 1, 1, 0, 0],
    [0, 0, 1, 1, 1, 1, 0, 0],
    [0, 0, 1, 1, 1, 1, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
])
print("Imagen original:")
print(test_image)

# Definir un núcleo de convolución para detección de bordes (versión simplificada del operador Sobel)
# Este núcleo puede detectar bordes verticales
edge_kernel = np.array([
    [-1, 0, 1],
    [-2, 0, 2],
    [-1, 0, 1],
])

# Ejecutar la convolución
feature_map = simple_convolution(test_image, edge_kernel)
print("\nMapa de características después de la convolución (borde vertical detectado):")
print(np.round(feature_map, 2))

La clave de la operación de convolución es:Los parámetros del núcleo de convolución se aprenden, no se diseñan manualmente.。

Durante el entrenamiento, el modelo ajusta automáticamente los valores del núcleo para que pueda extraer características útiles para la tarea.

Agrupación (Pooling)

La función del pooling es reducir el tamaño del mapa de características, disminuir la carga computacional y mantener las características importantes sin cambios.

El más común es el max pooling: dividir el mapa de características en varios bloques pequeños y conservar solo el valor máximo de cada bloque.

Ejemplo

# ============================================
# Implementar la operación de max pooling
# ============================================

def max_pooling(feature_map: np.ndarray, pool_size: int = 2) -> np.ndarray:
    """
Implementar la operación de max pooling

Parámetros:
feature_map: mapa de características de entrada (H, W)
pool_size: tamaño de la ventana de pooling, por defecto 2×2

Retorna:
Mapa de características después del pooling
    """

    h, w = feature_map.shape
    # Calcular la dimensión de salida
    out_h = h // pool_size
    out_w = w // pool_size

    output = np.zeros((out_h, out_w))

    for i in range(out_h):
        for j in range(out_w):
            # Extraer la región de la ventana de pooling
            region = feature_map[
                i*pool_size:(i+1)*pool_size,
                j*pool_size:(j+1)*pool_size
            ]
            # Tomar el valor máximo
            output[i, j] = np.max(region)

    return output


# Aplicar pooling al mapa de características anterior
print("Mapa de características antes del pooling:")
print(feature_map)

pooled = max_pooling(feature_map, pool_size=2)
print("\nMapa de características después del max pooling 2×2:")
print(pooled)

Comparación de arquitecturas clásicas

En la historia del desarrollo de las CNN, varias arquitecturas emblemáticas representan enfoques de diseño de diferentes épocas.

ArquitecturaAñoInnovación principalCaracterísticas
AlexNet2012Activación ReLU, Dropout, aumento de datosIniciador de la era del aprendizaje profundo, siendo el primero en superar significativamente a los métodos tradicionales en ImageNet.
VGG2014Uso uniforme de núcleos de convolución pequeños de 3×3Estructura simple y elegante, fácil de entender e implementar
ResNet2015Conexión residual (Skip Connection)Resuelve el problema de la desaparición del gradiente en redes profundas, permitiendo redes de más de cien capas.
EfficientNet2019Método de escalado compuestoEscala simultáneamente profundidad, ancho y resolución, con una eficiencia de parámetros muy alta.

Conexión residual (Skip Connection)

La innovación central de ResNet es la conexión residual, que resuelve el problema de que "cuanto más profunda es la red, más difícil es entrenarla".

El objetivo de aprendizaje de una capa de red tradicional es: aprender directamente el mapeo de la entrada x a la salida y.

El objetivo de aprendizaje de una red residual es:Aprender la diferencia entre la salida y y la entrada x (el residuo).。

Expresión en fórmula: y = F(x) + x, donde F(x) es el residuo a aprender.

La intuición de la conexión residual: hacer que la red aprenda "cuánto cambiar sobre lo ya existente" es mucho más fácil que hacer que "aprenda el mapeo completo desde cero".

Ejemplo

# ============================================
# Implementar un clasificador de imágenes CNN completo con PyTorch
# Incluye convolución, pooling y conexión residual
# ============================================

import torch
import torch.nn as nn
import torch.nn.functional as F


class ResidualBlock(nn.Module):
    """Un bloque residual simple"""

    def __init__(self, in_channels: int, out_channels: int, stride: int = 1):
        super().__init__()
        # Primera capa convolucional
        self.conv1 = nn.Conv2d(
            in_channels, out_channels,
            kernel_size=3, stride=stride, padding=1, bias=False
        )
        self.bn1 = nn.BatchNorm2d(out_channels)

        # Segunda capa convolucional
        self.conv2 = nn.Conv2d(
            out_channels, out_channels,
            kernel_size=3, stride=1, padding=1, bias=False
        )
        self.bn2 = nn.BatchNorm2d(out_channels)

        # Conexión rápida (para ajustar el cambio de dimensiones)
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(
                    in_channels, out_channels,
                    kernel_size=1, stride=stride, bias=False
                ),
                nn.BatchNorm2d(out_channels)
            )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # Ruta principal: Conv → BN → ReLU → Conv → BN
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))

        # Conexión residual: sumar la entrada (o la entrada transformada dimensionalmente)
        out += self.shortcut(x)

        # ReLU final
        out = F.relu(out)
        return out


class SimpleCNN(nn.Module):
    """CNN simple para clasificación de imágenes (con conexión residual)"""

    def __init__(self, num_classes: int = 10):
        super().__init__()
        # Capa convolucional inicial
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1)
        self.bn1 = nn.BatchNorm2d(32)

        # Capa residual
        self.layer1 = ResidualBlock(32, 32)
        self.layer2 = ResidualBlock(32, 64, stride=2)
        self.layer3 = ResidualBlock(64, 64)

        # Pooling promedio global
        self.global_pool = nn.AdaptiveAvgPool2d((1, 1))

        # Cabecera de clasificación
        self.fc = nn.Linear(64, num_classes)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # forma de x: (batch_size, 3, 32, 32)
        x = F.relu(self.bn1(self.conv1(x)))

        x = self.layer1(x)  # (batch_size, 32, 32, 32)
        x = self.layer2(x)  # (batch_size, 64, 16, 16)
        x = self.layer3(x)  # (batch_size, 64, 16, 16)

        x = self.global_pool(x)  # (batch_size, 64, 1, 1)
        x = x.view(x.size(0), -1)  # (batch_size, 64)
        x = self.fc(x)  # (batch_size, num_classes)

        return x


# Crear el modelo y probar
model = SimpleCNN(num_classes=10)
print("Estructura del modelo:")
print(model)

# Probar la propagación hacia adelante
# Crear un batch falso: 4 imágenes, cada una de 3×32×32 (RGB 32×32)
test_input = torch.randn(4, 3, 32, 32)
test_output = model(test_input)
print(f"\nForma de entrada: {test_input.shape}")
print(f"Forma de salida: {test_output.shape} (batch_size, num_classes)")

Vision Transformer(ViT)

En 2020, Google publicó el artículo «An Image is Worth 16x16 Words», trasladando la arquitectura Transformer del campo del lenguaje al campo de la visión.

Incrustación de parches (Patch Embedding)

Transformer procesa datos secuenciales, pero las imágenes son datos de cuadrícula 2D.

La solución de ViT es muy simple:Cortar la imagen en pequeños patches, y tratar cada patch como una palabra.。

Por ejemplo, una imagen de 224×224, cortada en patches de 16×16, da 14×14 = 196 patches.

Cada patch se aplana en un vector unidimensional y luego se proyecta mediante una capa lineal para convertirlo en un embedding, listo para enviarse a Transformer.

Ejemplo

# ============================================
# Implementar Patch Embedding (división de la imagen en patches)
# ============================================

class PatchEmbedding(nn.Module):
    """
Dividir la imagen en patches e incrustarlos (embedding)

Parámetros:
img_size: tamaño de la imagen de entrada (cuadrada)
patch_size: tamaño de cada patch (cuadrado)
in_channels: número de canales de entrada (RGB es 3)
embed_dim: dimensión del embedding de salida
    """


    def __init__(
        self,
        img_size: int = 224,
        patch_size: int = 16,
        in_channels: int = 3,
        embed_dim: int = 768
    ):
        super().__init__()
        self.img_size = img_size
        self.patch_size = patch_size
        # Calcular el número de patches: (224/16)^2 = 14^2 = 196
        self.num_patches = (img_size // patch_size) ** 2

        # Usar convolución para implementar la división e incrustación de patches
        # Esto equivale a: cortar patches → aplanar → proyección lineal
        self.proj = nn.Conv2d(
            in_channels, embed_dim,
            kernel_size=patch_size, stride=patch_size
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # Forma de x: (batch_size, in_channels, img_size, img_size)
        x = self.proj(x)  # (batch_size, embed_dim, num_patches^0.5, num_patches^0.5)
        x = x.flatten(2)  # (batch_size, embed_dim, num_patches)
        x = x.transpose(1, 2)  # (batch_size, num_patches, embed_dim)
        return x


# Probar el Patch Embedding
patch_embed = PatchEmbedding(img_size=224, patch_size=16, embed_dim=768)
test_image = torch.randn(1, 3, 224, 224)  # 1 imagen RGB de 224×224
patches = patch_embed(test_image)
print(f"Forma de la imagen de entrada: {test_image.shape}")
print(f"Forma de la secuencia de patches: {patches.shape} (batch_size, num_patches, embed_dim)")

Arquitectura completa de ViT

La arquitectura completa de ViT necesita además un class token y una codificación posicional.

El class token es un vector aprendible cuya función es "resumir" la información de todos los patches.

La codificación posicional también es aprendible y le indica al modelo "en qué posición de la imagen está cada patch".

Ejemplo

# ============================================
# Implementar una versión simplificada del Vision Transformer
# ============================================

class MultiHeadAttention(nn.Module):
    """Atención multi-cabeza (multi-head self-attention)"""

    def __init__(self, dim: int, num_heads: int):
        super().__init__()
        self.num_heads = num_heads
        self.head_dim = dim // num_heads
        assert self.head_dim * num_heads == dim, "La dimensión debe ser divisible por el número de cabezas"

        # Matrices de proyección Q, K, V
        self.qkv = nn.Linear(dim, dim * 3)
        # Proyección de salida
        self.proj = nn.Linear(dim, dim)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        batch_size, seq_len, dim = x.shape

        # Calcular Q, K, V
        qkv = self.qkv(x)  # (batch_size, seq_len, dim*3)
        qkv = qkv.reshape(
            batch_size, seq_len, 3, self.num_heads, self.head_dim
        )  # (batch_size, seq_len, 3, num_heads, head_dim)
        q, k, v = qkv.unbind(2)  # Cada forma: (batch_size, seq_len, num_heads, head_dim)

        # Reordenar para calcular la atención
        q = q.transpose(1, 2)  # (batch_size, num_heads, seq_len, head_dim)
        k = k.transpose(1, 2)
        v = v.transpose(1, 2)

        # Calcular las puntuaciones de atención
        attention = q @ k.transpose(-2, -1) / (self.head_dim ** 0.5)
        attention = attention.softmax(dim=-1)

        # Agregar los valores (aggregate)
        out = attention @ v  # (batch_size, num_heads, seq_len, head_dim)
        out = out.transpose(1, 2)  # (batch_size, seq_len, num_heads, head_dim)
        out = out.flatten(2)  # (batch_size, seq_len, dim)

        # Proyección de salida
        out = self.proj(out)
        return out


class TransformerBlock(nn.Module):
    """Un bloque Transformer"""

    def __init__(self, dim: int, num_heads: int, mlp_ratio: float = 4.0):
        super().__init__()
        self.norm1 = nn.LayerNorm(dim)
        self.attn = MultiHeadAttention(dim, num_heads)
        self.norm2 = nn.LayerNorm(dim)

        # MLP
        mlp_hidden = int(dim * mlp_ratio)
        self.mlp = nn.Sequential(
            nn.Linear(dim, mlp_hidden),
            nn.GELU(),
            nn.Linear(mlp_hidden, dim)
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # Conexión residual 1
        x = x + self.attn(self.norm1(x))
        # Conexión residual 2
        x = x + self.mlp(self.norm2(x))
        return x


class SimpleViT(nn.Module):
    """Versión simplificada del Vision Transformer"""

    def __init__(
        self,
        img_size: int = 224,
        patch_size: int = 16,
        in_channels: int = 3,
        num_classes: int = 10,
        embed_dim: int = 192,
        depth: int = 6,
        num_heads: int = 6
    ):
        super().__init__()
        # Embedding de patches (Patch Embedding)
        self.patch_embed = PatchEmbedding(
            img_size, patch_size, in_channels, embed_dim
        )
        num_patches = self.patch_embed.num_patches

        # Class token
        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))

        # Codificación posicional
        self.pos_embed = nn.Parameter(
            torch.zeros(1, num_patches + 1, embed_dim)
        )

        # Capas Transformer
        self.blocks = nn.ModuleList([
            TransformerBlock(embed_dim, num_heads)
            for _ in range(depth)
        ])

        # LayerNorm final y cabeza de clasificación
        self.norm = nn.LayerNorm(embed_dim)
        self.head = nn.Linear(embed_dim, num_classes)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        batch_size = x.shape[0]

        # Embedding de patches
        x = self.patch_embed(x)  # (batch_size, num_patches, embed_dim)

        # Añadir el class token
        cls_tokens = self.cls_token.expand(batch_size, -1, -1)
        x = torch.cat((cls_tokens, x), dim=1)  # (batch_size, 1+num_patches, embed_dim)

        # Añadir la codificación posicional
        x = x + self.pos_embed

        # Pasar por las capas Transformer
        for block in self.blocks:
            x = block(x)

        # Usar solo el class token para la clasificación
        x = self.norm(x)
        cls_output = x[:, 0]  # Tomar la primera posición (class token)
        x = self.head(cls_output)

        return x


# Crear el modelo ViT y probar
vit = SimpleViT(
    img_size=32,    # Usar una imagen más pequeña para facilitar la prueba
    patch_size=8,   # Patches de 8×8
    embed_dim=128,
    depth=4,
    num_heads=4,
    num_classes=10
)
print("Estructura del ViT simplificado:")
print(vit)

test_input = torch.randn(2, 3, 32, 32)  # 2 imágenes de 32×32
test_output = vit(test_input)
print(f"\n"Forma de entrada: {test_input.shape}")
print(f"Forma de salida: {test_output.shape}")

Comparación CNN vs ViT

Ambas arquitecturas tienen ventajas y desventajas; cuál elegir depende de tu escenario concreto.

CaracterísticaCNNViT
Sesgo inductivoFuerte (localidad, invariancia a traslaciones)Débil (aprendido de los datos)
Requisitos de datosFunciona incluso con pocos datosNecesita muchos datos para aprovechar sus ventajas
Eficiencia computacionalGeneralmente más rápido, con optimización de hardware maduraMuchos parámetros y cómputo intensivo
InterpretabilidadFácil visualizar los kernels de convoluciónLos mapas de atención son interpretables, pero el conjunto es más difícil
Dependencias de largo alcanceNecesita varias capas para establecerseSoporta de forma natural un campo receptivo global
Escenarios de aplicaciónDatos limitados, alta exigencia de tiempo realGrandes conjuntos de datos, tareas visuales complejas

Regla empírica: con pocos datos usa CNN (ResNet, EfficientNet); con millones de datos puedes considerar ViT. También existen arquitecturas híbridas (como ConvNeXt) que combinan las ventajas de ambos.


Detección de objetos

La clasificación de imágenes responde "qué hay en esta imagen"; la detección de objetos responde "qué hay en esta imagen y dónde está cada cosa".

La salida de la detección de objetos es una serie de bounding boxes, donde cada caja corresponde a una categoría de objeto.

Detección de dos etapas: serie R-CNN

La idea de la detección en dos etapas es:Primero encontrar regiones que posiblemente contengan objetos y luego clasificar esas regiones.。

Primera etapa: generar regiones candidatas (Region Proposal), posiblemente cientos de cajas de "aquí puede haber algo".

Segunda etapa: extraer características de cada región candidata, determinar qué objeto es y ajustar la posición de la caja.

Evolución de la serie R-CNN:

ModeloMejora principalVelocidad
R-CNNUsar CNN en lugar de características tradicionalesLenta (decenas de segundos por imagen)
Fast R-CNNROI Pooling, cálculo de características compartidoMedia (unos segundos por imagen)
Faster R-CNNRPN(Region Proposal Network)Rápida (cientos de milisegundos por imagen)
Mask R-CNNAñadir rama de segmentaciónMedio

Detección de una etapa: serie YOLO

La idea de la detección en una etapa es:Predecir densamente directamente sobre la imagen, sin generar regiones candidatas por separado.。

YOLO (You Only Look Once) es el representante de la detección en una etapa; es extremadamente rápido y adecuado para aplicaciones en tiempo real.

YOLO divide la imagen en una cuadrícula de S×S, y cada celda se encarga de predecir los objetos cuyo punto central cae en esa celda.

Cada celda predice: B bounding boxes (con confianza) y probabilidades para C categorías.

Detección de extremo a extremo: DETR

DETR (DEtection TRansformer) es un nuevo paradigma propuesto por Facebook AI, que usa Transformer para convertir la detección de objetos en un problema directo de predicción de secuencias.

Su mayor característica es: no necesita supresión de no máximos (NMS), no necesita anchor boxes (Anchor), y la salida es directamente el resultado final.

Práctica: detección de objetos con YOLOv11

Ahora usamos Ultralytics YOLOv11 para hacer un ejemplo completo de detección de objetos.

Ejemplo

# ============================================
# Práctica de detección de objetos con YOLOv11
# Incluye carga del modelo, detección y visualización
# ============================================

import torch
import numpy as np
from PIL import Image, ImageDraw, ImageFont
import matplotlib.pyplot as plt


class SimpleYOLO:
    """Demostración simplificada de YOLO (usando modelo preentrenado)"""

    def __init__(self, model_name: str = "yolo11n.pt"):
        """
Inicializar el modelo YOLO

Parámetros:
model_name: nombre del modelo, yolo11n.pt (nano, pequeño), yolo11s.pt (small, pequeño), etc.
        """

        self.model_name = model_name
        self.model = None
        # Las 80 categorías del conjunto de datos COCO
        self.coco_names = [
            'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
            'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
            'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog',
            'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',
            'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
            'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat',
            'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
            'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
            'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot',
            'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
            'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop',
            'mouse', 'remote', 'keyboard', 'cell phone', 'microwave', 'oven',
            'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
            'scissors', 'teddy bear', 'hair drier', 'toothbrush'
        ]
        # Color para cada categoría
        self.colors = np.random.randint(0, 255, (80, 3))

    def load_model(self):
        """Cargar modelo preentrenado (aquí usamos una implementación simulada para demostrar el concepto)"""
        print(f"Cargando el modelo {self.model_name}...")
        print("Nota: en uso real instale ultralytics y llame:")
        print("  from ultralytics import YOLO")
        print("  model = YOLO('yolo11n.pt')")
        self.model = "pretrained_model_loaded"
        print("¡Modelo cargado!")
        return self

    def predict_dummy(self, image: np.ndarray) -> list:
        """
Simular resultados de detección (para la demostración)
En uso real, llamar model(image)

Devuelve:
Lista de resultados de detección, donde cada elemento es un diccionario:
            {'bbox': [x1, y1, x2, y2], 'class_id': int, 'score': float, 'class_name': str}
        """

        # Aquí simulamos que se han detectado varios objetos
        h, w = image.shape[:2]
        dummy_results = [
            {'bbox': [w*0.1, h*0.2, w*0.3, h*0.6], 'class_id': 0, 'score': 0.92, 'class_name': 'person'},
            {'bbox': [w*0.35, h*0.4, w*0.7, h*0.8], 'class_id': 2, 'score': 0.85, 'class_name': 'car'},
            {'bbox': [w*0.75, h*0.3, w*0.9, h*0.55], 'class_id': 16, 'score': 0.78, 'class_name': 'dog'},
        ]
        return dummy_results

    def visualize(self, image: np.ndarray, results: list) -> np.ndarray:
        """
Dibujar las cajas de detección y las etiquetas en la imagen

Parámetros:
) # 1 = primer plano, 0 = fondo
results: lista de resultados de detección

Devuelve:
Imagen anotada
        """

        if isinstance(image, np.ndarray):
            image = Image.fromarray(image)

        draw = ImageDraw.Draw(image)

        for result in results:
            bbox = result['bbox']
            class_id = result['class_id']
            score = result['score']
            class_name = result['class_name']

            color = tuple(self.colors[class_id % 80].tolist())

            # Dibujar rectángulo
            draw.rectangle(bbox, outline=color, width=3)

            # Fondo de la etiqueta
            label = f"{class_name} {score:.2f}"
            try:
                font = ImageFont.truetype("arial.ttf", 16)
            except:
                font = ImageFont.load_default()

            # Calcular tamaño del texto
            bbox_label = draw.textbbox((0, 0), label, font=font)
            text_w = bbox_label[2] - bbox_label[0]
            text_h = bbox_label[3] - bbox_label[1]

            # Dibujar fondo de la etiqueta
            label_bg = [bbox[0], bbox[1]-text_h-5, bbox[0]+text_w+5, bbox[1]]
            draw.rectangle(label_bg, fill=color)

            # Dibujar texto
            draw.text((bbox[0]+2, bbox[1]-text_h-3), label, fill=(255,255,255), font=font)

        return np.array(image)


# Crear imagen simulada (para demostración)
def create_test_image() -> np.ndarray:
    """Crear una imagen de prueba"""
    h, w = 480, 640
    image = np.zeros((h, w, 3), dtype=np.uint8)
    # Fondo degradado
    image[:, :, 0] = np.linspace(100, 200, w)[np.newaxis, :]
    image[:, :, 1] = np.linspace(150, 100, h)[:, np.newaxis]
    image[:, :, 2] = 180
    return image


# Demostrar el flujo de detección YOLO
print("=" * 60)
print("EJEMPLO YOLOv11 Demostración de detección de objetos")
print("=" * 60)

# Inicialización
detector = SimpleYOLO().load_model()

# Crear imagen de prueba
test_image = create_test_image()
print(f"\nDimensiones de la imagen de entrada: {test_image.shape})

# Simular detección
results = detector.predict_dummy(test_image)
print(f"\nDetectados {len(results)} objetos:)
for i, r in enumerate(results, 1):
    print(f" {i}. {r['class_name']} (confianza: {r['score']:.2f})")

# Visualización
visualized = detector.visualize(test_image, results)
print(f"\nVisualización completada, dimensiones de la imagen de salida: {visualized.shape})


# ============================================
# Código para usar realmente YOLOv11 (requiere instalar ultralytics)
# ============================================
print("\n" + "=" * 60)
print("Ejemplo de código para usar YOLOv11 en la práctica:")
print("=" * 60)
print("""
# Instalación: pip install ultralytics

from ultralytics import YOLO

# 1. Cargar el modelo
model = YOLO('yolo11n.pt') # también se puede usar 'yolo11s.pt', 'yolo11m.pt', etc.

# 2. Predicción
results = model('test_image.jpg') # puede ser ruta de imagen, video, 0 (cámara)

# 3. Procesar resultados
for result in results:
# Cajas de detección
    boxes = result.boxes
# Máscaras de segmentación (si se usa un modelo de segmentación)
    masks = result.masks
# Mostrar resultados
    result.show()
# Guardar resultados
    result.save('result.jpg')

# 4. Entrenamiento (opcional)
# model.train(data='coco128.yaml', epochs=100, imgsz=640)
"""
)

Segmentación de imágenes

La detección de objetos marca los objetos con rectángulos; la segmentación de imágenes requiere precisión a nivel de píxel, indicando a qué objeto pertenece cada píxel.

Segmentación semántica vs segmentación de instancias

La segmentación de imágenes tiene dos grandes ramas: segmentación semántica y segmentación de instancias.

TareaObjetivoEjemploModelo representativo
Segmentación semánticaClasificar cada píxel (sin considerar instancias)Marcar a todas las personas en rojo y a todos los coches en azulFCN、U-Net、DeepLab
Segmentación de instanciasClasificar cada píxel y diferenciar distintas instanciasMarcar a la persona 1 en rojo, a la persona 2 en naranjaMask R-CNN、YOLOv8-Seg
Segmentación panópticaSemántica + instancias, representación unificadaAnotar simultáneamente todas las "cosas" y el "fondo"Panoptic FPN、MaskFormer

Un ejemplo clásico: supongamos que hay dos personas y dos perros.

La segmentación semántica dice: aquí hay "personas" y "perros" (solo clasifica categorías, no cuenta).

La segmentación de instancias dice: aquí hay "persona 1", "persona 2", "perro 1", "perro 2" (cada individuo se distingue).

Segment Anything Model(SAM)

En 2023, Meta AI lanzó SAM (Segment Anything Model), que convirtió la segmentación en una tarea interactiva impulsada por prompts.

La entrada de SAM puede ser: un punto, un cuadro, un texto o una máscara aproximada.

La salida de SAM es: la máscara de segmentación precisa del objeto correspondiente.

La filosofía de diseño de SAM es:Basado en prompts, generalizable y zero-shot。

Ejemplo

# ============================================
# Demostración del concepto de segmentación SAM
# Muestra cómo segmentar usando puntos, cuadros y otros prompts
# ============================================

class SimpleSAM:
    """Versión simplificada de la demostración del concepto SAM"""

    def __init__(self):
        self.image_embedding = None
        print("Inicialización de la demostración del concepto SAM")

    def set_image(self, image: np.ndarray):
        """Codificar la imagen (solo una vez)"""
        print("Codificando la imagen a embedding...")
        self.image_embedding = "image_encoded"
        return self

    def predict_from_point(self, point: tuple, point_label: int = 1):
        """
Segmentar desde un punto

Parámetros:
point: coordenadas (x, y)
point_label: 1 indica primer plano, 0 indica fondo
        """

        print(f"Segmentar desde el punto {point} ({'primer plano' if point_label == 1 else 'fondo'})")
        return "mask_from_point"

    def predict_from_box(self, box: tuple):
        """Segmentar desde un cuadro delimitador"""
        x1, y1, x2, y2 = box
        print(f"Segmentar desde el cuadro [{x1}, {y1}, {x2}, {y2}]")
        return "mask_from_box"

    def predict_from_points(self, points: list, labels: list):
        """Segmentar desde múltiples puntos"""
        print(f"Segmentar desde {len(points)} puntos")
        return "mask_from_points"


# Demostrar el flujo de uso de SAM
print("=" * 60)
print("EJEMPLO Demostración del concepto de segmentación SAM")
print("=" * 60)

sam = SimpleSAM()

# 1. Configurar la imagen (codificar una vez)
test_img = create_test_image()
sam.set_image(test_img)

# 2. Segmentar con diferentes prompts
print()
mask1 = sam.predict_from_point((100, 200), point_label=1)

print()
mask2 = sam.predict_from_box((50, 50, 200, 300))

print()
mask3 = sam.predict_from_points([(100, 100), (150, 150)], [1, 1])


# ============================================
# Ejemplo de código para el uso real de SAM
# ============================================
print("\n" + "=" * 60)
print("Ejemplo de código para usar SAM en la práctica:")
print("=" * 60)
print("""
# Instalación: pip install segment-anything torch torchvision opencv-python

import cv2
import numpy as np
from segment_anything import sam_model_registry, SamPredictor

# 1. Cargar el modelo
# Descargar checkpoint: https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth
sam = sam_model_registry["vit_h"](checkpoint="sam_vit_h_4b8939.pth")
sam.to(device="cuda")
predictor = SamPredictor(sam)

# 2. Configurar la imagen
image = cv2.imread("test_image.jpg")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
predictor.set_image(image)

# 3. Segmentar con un punto como prompt
input_point = np.array([[300, 250]]) # coordenadas del punto de prompt
input_label = np.array(

masks, scores, logits = predictor.predict(
    point_coords=input_point,
    point_labels=input_label,
    multimask_output=True
)

# 4. Visualizar resultados
for i, mask in enumerate(masks):
    color = np.array([30, 144, 255])
    h, w = mask.shape
    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
    cv2.imwrite(f"mask_{i}.jpg", mask_image)
"""
)

Aplicaciones de la segmentación en la industria

La segmentación de imágenes es una tecnología central en muchas aplicaciones industriales:

ÁreaEscenario de aplicaciónTipo de tarea
Imágenes médicasSegmentación de tumores, medición de órganosSegmentación semántica
Conducción autónomaDetección de área transitable y reconocimiento de líneas de carrilSegmentación semántica
Imágenes de teledetecciónClasificación de cobertura terrestre, extracción de edificiosSegmentación semántica
Fabricación inteligenteDetección de defectos, medición de piezasSegmentación de instancias
Edición de videoRecorte de personas, reemplazo de fondoSegmentación de instancias

Modelos de difusión (Diffusion Models)

Los modelos de difusión son la tecnología central de la generación de imágenes con IA; Stable Diffusion, DALL-E 3 y Midjourney se basan en ella.

Proceso de difusión directo (agregar ruido)

La difusión directa es un proceso simple:Añadir gradualmente ruido gaussiano a la imagen hasta convertirla en ruido puro。

Es un proceso determinista; en cada paso solo se añade un poco de ruido, y podemos calcular con precisión la cantidad de ruido en cualquier momento mediante una fórmula matemática.

Ejemplo

# ============================================
# Demostrar el proceso directo del modelo de difusión (añadir ruido)
# ============================================

import numpy as np
import matplotlib.pyplot as plt


class ForwardDiffusion:
    """Demostración del proceso de difusión directa"""

    def __init__(self, num_timesteps: int = 1000):
        self.num_timesteps = num_timesteps

        # Definir el esquema beta (aumento lineal desde beta_start hasta beta_end)
        self.beta_start = 0.0001
        self.beta_end = 0.02
        self.betas = np.linspace(self.beta_start, self.beta_end, num_timesteps)

        # Calcular alpha y alpha_bar
        self.alphas = 1.0 - self.betas
        self.alphas_bar = np.cumprod(self.alphas)

    def q_sample(self, x0: np.ndarray, t: int) -> tuple:
        """
Calcular xt en el tiempo t directamente desde x0

Parámetros:
x0: imagen original (H, W, 3)
t: paso de tiempo (0 <= t < num_timesteps)

Devuelve:
xt: imagen en el tiempo t
noise: el ruido añadido
        """

        sqrt_alpha_bar_t = np.sqrt(self.alphas_bar[t])
        sqrt_one_minus_alpha_bar_t = np.sqrt(1 - self.alphas_bar[t])

        # Generar ruido aleatorio de la misma forma
        noise = np.random.randn(*x0.shape)

        # Calcular xt de una sola vez
        xt = sqrt_alpha_bar_t * x0 + sqrt_one_minus_alpha_bar_t * noise

        return xt, noise


# Crear una imagen de prueba simple: un círculo brillante en el centro
def create_diffusion_test_image():
    h, w = 64, 64
    x = np.linspace(-1, 1, w)
    y = np.linspace(-1, 1, h)
    xx, yy = np.meshgrid(x, y)
    r = np.sqrt(xx**2 + yy**2)
    image = np.exp(-r**2 / 0.1)  # Círculo brillante con distribución gaussiana
    image = (image - image.min()) / (image.max() - image.min())  # Normalizar a [0, 1]
    image = np.stack([image, image*0.8, image*0.5], axis=-1)  # Convertir a 3 canales
    return image


print("=" * 60)
print("EJEMPLO Demostración del proceso de difusión directa")
print("=" * 60)

# Inicializar el proceso de difusión
diffusion = ForwardDiffusion(num_timesteps=1000)

# Crear imagen de prueba
x0 = create_diffusion_test_image()
print(f"Forma de la imagen original: {x0.shape}")

# Mostrar resultados de ruido en diferentes pasos de tiempo
timesteps_to_show = [0, 100, 200, 300, 500, 1000]

print("\nNivel de ruido en diferentes pasos de tiempo:)
for t in timesteps_to_show:
    if t < 1000:
        xt, noise = diffusion.q_sample(x0, t)
        alpha_bar = diffusion.alphas_bar[t]
        print(f" t={t:4d}: alpha_bar={alpha_bar:.4f}, relación señal-ruido={alpha_bar/(1-alpha_bar):.4f}")
    else:
        print(f" t={t:4d}: ruido puro")

print("\nLa fórmula central de la difusión directa:)
print("  q(x_t | x_0) = N(x_t; sqrt(alpha_bar_t) * x0, (1 - alpha_bar_t) * I)")
print("\nEsta fórmula nos permite calcular x_t en cualquier momento t directamente desde x0, ¡sin necesidad de iterar paso a paso!)

Proceso inverso de eliminación de ruido

El proceso inverso es la inversa del proceso directo:Comenzando desde ruido puro, predecir y eliminar el ruido gradualmente, hasta obtener la imagen final.。

Esto es lo que el modelo debe aprender: dado x_t y t, predecir qué ruido se añadió.

Objetivo de entrenamiento: minimizar el error cuadrático medio entre el ruido predicho por el modelo y el ruido real.

Arquitectura U-Net

El núcleo del modelo de difusión es una red U-Net, cuya forma se asemeja a la letra "U": el lado izquierdo reduce la resolución (downsampling) para comprimir, y el lado derecho aumenta la resolución (upsampling) para restaurar.

La clave de U-Net son las conexiones de salto (Skip Connections), que transmiten directamente las características del downsampling a las capas correspondientes del upsampling, preservando la información de detalle.

Muestreo DDPM vs DDIM

Una vez entrenado el modelo, necesitamos muestrear desde el ruido para generar imágenes; diferentes muestreadores varían en velocidad y calidad.

MuestreadorNombre completoNúmero de pasosCaracterísticas
DDPMDenoising Diffusion Probabilistic Models1000Método original, buena calidad pero lento
DDIMDenoising Diffusion Implicit Models50-100Muestreo determinista, rápido
LMSLinear Multistep Method30-50Rápido y de buena calidad
DPM-SolverDPM-Solver10-20Ultra rápido, se obtienen buenos resultados en pocos pasos

Stable Diffusion actualmente usa DPM-Solver++ por defecto; normalmente se obtienen resultados de alta calidad en 20-30 pasos, decenas de veces más rápido que el DDPM original.

Arquitectura de Stable Diffusion

Stable Diffusion no trabaja directamente en el espacio de píxeles, sino en el espacio latente (Latent Space), lo que lo hace más rápido y eficiente.

Stable Diffusion completo consta de tres partes:

1. VAE (Autoencoder Variacional): comprime la imagen en un vector latente, o reconstruye la imagen a partir del vector latente.

2. UNet: la red de denoising central, recibe el vector latente, el paso de tiempo y el embedding del prompt, y predice el ruido.

3. Text Encoder (CLIP): convierte el prompt de texto en un embedding, indicando al modelo qué generar.

Ejemplo

# ============================================
# Demostración conceptual de Stable Diffusion
# Muestra el flujo completo de generación
# ============================================

class SimpleStableDiffusion:
    """Demostración conceptual simplificada de Stable Diffusion"""

    def __init__(self):
        print("Inicialización de la demostración conceptual de Stable Diffusion")

    def encode_text(self, prompt: str):
        """Codificar el prompt de texto"""
        print(f"Codificar prompt: '{prompt}'")
        return "text_embedding"

    def encode_image(self, image: np.ndarray):
        """VAE codifica la imagen al espacio latente"""
        print("Codificando imagen al espacio latente (codificador VAE)")
        return "latent_code"

    def decode_latent(self, latent: str):
        """VAE decodifica la imagen desde el espacio latente"""
        print("Decodificando imagen desde el espacio latente (decodificador VAE)")
        return "decoded_image"

    def denoise_step(self, latent: str, text_embedding: str, t: int):
        """Denoising de un paso"""
        print(f" Paso de denoising t={t}")
        return "denoised_latent"

    def generate(self, prompt: str, num_inference_steps: int = 50):
        """Flujo completo de generación"""
        print("=" * 60)
        print(f"Iniciando generación: '{prompt}'")
        print("=" * 60)

        # 1. Codificar el texto
        text_emb = self.encode_text(prompt)

        # 2. Comenzar desde ruido aleatorio
        print("\nInicializando ruido aleatorio...")
        latent = "random_noise"

        # 3. Denoising gradual
        print(f"\nIniciando bucle de denoising ({num_inference_steps} pasos):")
        for t in reversed(range(num_inference_steps)):
            latent = self.denoise_step(latent, text_emb, t)

        # 4. Decodificar para obtener la imagen
        print("\nDecodificando vector latente a imagen...")
        image = self.decode_latent(latent)

        print("\n"¡Generación completada!")
        return image


# Demostrar el flujo de generación
sd = SimpleStableDiffusion()
image = sd.generate(
    prompt="Un lindo gato naranja en el jardín",
    num_inference_steps=20
)


# ============================================
# Ejemplo de código usando Stable Diffusion en la práctica
# ============================================
print("\n" + "=" * 60)
print("Ejemplo de código usando Stable Diffusion en la práctica:")
print("=" * 60)
print("""
# Instalación: pip install diffusers transformers accelerate torch

from diffusers import StableDiffusionPipeline
import torch

# 1. Cargar el modelo
model_id = "runwayml/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16
)
pipe = pipe.to("cuda")

# 2. Texto a imagen
prompt = "a cute orange cat in a garden"
image = pipe(prompt).images[0]

# 3. Guardar el resultado
image.save("cat_garden.png")

# 4. Imagen a imagen
from diffusers import StableDiffusionImg2ImgPipeline
from PIL import Image

img_pipe = StableDiffusionImg2ImgPipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16
).to("cuda")

init_image = Image.open("input.jpg").convert("RGB")
init_image = init_image.resize((512, 512))

image = img_pipe(
    prompt="make it look like a painting",
    image=init_image,
strength=0.75 # grado de cambio
).images[0]
image.save("painted.png")

# 5. Inpainting (modificación local)
from diffusers import StableDiffusionInpaintPipeline

inpaint_pipe = StableDiffusionInpaintPipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16
).to("cuda")

image = inpaint_pipe(
    prompt="put a hat on the cat",
    image=init_image,
mask_image=mask_image # máscara, las áreas blancas son las que se modificarán
).images[0]
"""
)

CLIP: fundamentos de la alineación multimodal

CLIP (Contrastive Language-Image Pre-training) es un trabajo publicado por OpenAI en 2021; por primera vez alineó texto e imágenes en un mismo espacio vectorial.

Principios del aprendizaje contrastivo

El método de entrenamiento de CLIP es el aprendizaje contrastivo:Hacer que los pares correctos de imagen-texto tengan alta similitud y los incorrectos tengan baja similitud。

Durante el entrenamiento, un batch contiene N imágenes y N textos (correspondencia uno a uno), formando N×N pares posibles de imagen-texto.

La diagonal son los pares positivos coincidentes; el resto son pares negativos no coincidentes.

El objetivo de entrenamiento es: hacer que la similitud de los positivos sea lo más alta posible y la de los negativos lo más baja posible.

Entrenamiento de alineación imagen-texto

CLIP contiene dos codificadores:

  • 1. Image Encoder: codifica la imagen en un vector (puede ser ResNet o ViT).

  • 2. Text Encoder: codifica el texto en un vector (Transformer).

Después de proyectar ambos vectores en el mismo espacio, se calcula el grado de coincidencia imagen-texto mediante la similitud coseno.

Ejemplo

# ============================================
# Demostración conceptual de CLIP: aprendizaje contrastivo y alineación imagen-texto
# ============================================

import torch
import torch.nn.functional as F


class SimpleCLIP:
    """Demostración conceptual simplificada de CLIP"""

    def __init__(self, embed_dim: int = 512):
        self.embed_dim = embed_dim
        # Simulación simple: no es codificación real, solo proyección aleatoria
        print("Inicialización de la demostración conceptual de CLIP")
        print(f"Dimensión del embedding: {embed_dim}")

    def encode_image(self, image: str) -> torch.Tensor:
        """Codificación de imagen simulada"""
        # En la práctica aquí sería un Vision Transformer o ResNet
        return torch.randn(1, self.embed_dim)

    def encode_text(self, text: str) -> torch.Tensor:
        """Codificación de texto simulada"""
        # En la práctica aquí sería un Text Transformer
        return torch.randn(1, self.embed_dim)

    def compute_similarity(self, image_emb: torch.Tensor, text_emb: torch.Tensor) -> float:
        """Calcular la similitud coseno"""
        image_emb = F.normalize(image_emb, dim=-1)
        text_emb = F.normalize(text_emb, dim=-1)
        return (image_emb @ text_emb.T).item()


# Demostrar el flujo de inferencia de CLIP
print("=" * 60)
print("Demostración de clasificación zero-shot de EJEMPLO CLIP")
print("=" * 60)

clip = SimpleCLIP(embed_dim=512)

# Supongamos que hay una imagen
print("\n1. Codificando la imagen...")
image_emb = clip.encode_image("Una foto de un gato")

# Supongamos que hay varias categorías candidatas
candidates = ["Una foto de un perro", "Una foto de un gato", "Un automóvil", "Una persona"]
print(f"\n2. Codificando los textos candidatos: {candidates}")

# Calcular la similitud
print("\n3. Calculando la similitud imagen-texto:")
for text in candidates:
    text_emb = clip.encode_text(text)
    sim = clip.compute_similarity(image_emb, text_emb)
    print(f" '{text}' → similitud: {sim:.3f}")

print("\n(En la práctica, 'Una foto de un gato' tendría la similitud más alta)")


# ============================================
# Ejemplo de código usando CLIP en la práctica
# ============================================
print("\n" + "=" * 60)
print("Ejemplo de código usando CLIP en la práctica:")
print("=" * 60)
print("""
# Instalación: pip install clip torch torchvision

import clip
import torch
from PIL import Image

# 1. Cargar el modelo
device = "cuda" if torch.cuda.is_available() else "cpu"
model, preprocess = clip.load("ViT-B/32", device=device)

# 2. Preparar la imagen
image = preprocess(Image.open("cat.jpg")).unsqueeze(0).to(device)

# 3. Preparar el texto
text = clip.tokenize([
    "a photo of a dog",
    "a photo of a cat",
    "a photo of a car",
    "a photo of a person"
]).to(device)

# 4. Inferencia
with torch.no_grad():
    image_features = model.encode_image(image)
    text_features = model.encode_text(text)

    logits_per_image, logits_per_text = model(image, text)
    probs = logits_per_image.softmax(dim=-1).cpu().numpy()

# 5. Mostrar el resultado
print("Probabilidades predichas:")
for i, p in enumerate(probs[0]):
    print(f"  {i+1}. {p:.2%}")
"""
)

Capacidad de clasificación Zero-Shot

La capacidad más emocionante de CLIP es la clasificación Zero-Shot:No necesita entrenamiento en el conjunto de datos objetivo; puede clasificar directamente.。

Un modelo entrenado tradicionalmente en ImageNet solo puede clasificar las 1000 clases de ImageNet; para añadir clases nuevas hay que reentrenarlo.

CLIP puede usar cualquier texto para describir categorías, por ejemplo: "Una foto de un gato", "Un gato naranja sentado en el césped", "Un dibujo de un gato".

La importancia de CLIP no solo radica en la clasificación zero-shot, sino en que estableció una interfaz universal de "visión-lenguaje"; muchos modelos posteriores (como Stable Diffusion y los modelos de visión-lenguaje) se basan en ella.


Modelo de lenguaje visual (VLM)

El modelo de visión-lenguaje (Vision-Language Model, VLM) combina la comprensión de imágenes y la generación de lenguaje, permitiendo al modelo "ver y hablar".

Arquitectura LLaVA

LLaVA (Large Language and Vision Assistant) es un VLM de código abierto; su diseño es simple y claro, muy adecuado para aprender desde cero.

La arquitectura de LLaVA se divide en tres partes:

  • 1. Vision Encoder: el codificador visual de CLIP, convierte la imagen en un embedding.

  • 2. Projection Layer: proyecta el embedding visual a la misma dimensión que la entrada del LLM.

  • 3. LLM: un modelo de lenguaje grande (como Vicuna, LLaMA) que recibe la entrada combinada de imagen y texto y genera la respuesta.

El entrenamiento consta de dos pasos:

  • 1. Fase de preentrenamiento: solo se entrena la capa de proyección, usando muchos pares de imagen-texto para alinear.

  • 2. Fase de ajuste por instrucciones: se entrena todo el modelo con un conjunto de datos de instrucciones visuales (como LLaVA-Instruct).

Conexión entre el Encoder visual y el LLM

La clave para conectar visión y lenguaje es:representar la imagen como una secuencia de tokens que el modelo de lenguaje pueda entender.。

Hay varias formas comunes de conexión:

MétodoCaracterísticaModelo representativo
Token especialUsar un token [IMG] para representar toda la imagenModelos tempranos
Concatenación de secuenciasConcatenar directamente los embeddings de los parches de imagen antes del textoLLaVA、GPT-4V
Atención cruzadaAñadir atención cruzada sobre las características visuales en el LLMBLIP-2、Flamingo

Ejemplo

# ============================================
# Demostración conceptual del modelo de lenguaje visual (VLM)
# Muestra cómo concatenar la entrada visual y la de lenguaje
# ============================================

class SimpleVLM:
    """Versión simplificada del modelo de lenguaje visual"""

    def __init__(self, vocab_size: int = 50000, hidden_size: int = 768):
        self.vocab_size = vocab_size
        self.hidden_size = hidden_size
        print("Inicialización de VLM simplificado")

    def encode_vision(self, image: str) -> torch.Tensor:
        """Codificar la imagen como secuencia"""
        # Supongamos que hay 256 tokens visuales
        return torch.randn(1, 256, self.hidden_size)

    def encode_text(self, text: str) -> torch.Tensor:
        """Codificar el texto como secuencia"""
        # Supongamos que el texto tiene 16 tokens
        return torch.randn(1, 16, self.hidden_size)

    def generate(self, image: str, question: str) -> str:
        """Concatenar imagen y texto para generar respuesta"""
        print("=" * 60)
        print(f"Pregunta: {question}")
        print("=" * 60)

        # 1. Codificar imagen y texto
        print("\n"1. Codificando imagen...")
        vision_emb = self.encode_vision(image)

        print("2. Codificando texto...")
        text_emb = self.encode_text(question)

        # 3. Concatenar: [secuencia visual] + [secuencia de texto]
        print("\n3. Concatenando secuencias visual y de texto...")
        print(f" Forma del embedding visual: {vision_emb.shape}")
        print(f" Forma del embedding de texto: {text_emb.shape}")
        combined = torch.cat([vision_emb, text_emb], dim=1)
        print(f" Forma tras concatenar: {combined.shape}")

        # 4. El LLM genera la respuesta
        print("\n4. El LLM genera la respuesta...")

        return "Es un gato naranja adorable, parece muy feliz."


# Demostración de preguntas y respuestas de VLM
vlm = SimpleVLM()
answer = vlm.generate(
    image="Una foto de un gato naranja",
    question="¿Qué hay en esta imagen? Por favor descríbela."
)

print(f"\nRespuesta: {answer}")


# ============================================
# Ejemplo de código de uso real de LLaVA
# ============================================
print("\n" + "=" * 60)
print("Ejemplo de código de uso real de LLaVA:")
print("=" * 60)
print("""
# LLaVA requiere bastante memoria de GPU; se recomienda usar las bibliotecas transformers o llava

from transformers import AutoProcessor, AutoModelForVisionAndLanguageGeneration
import torch
from PIL import Image

# 1. Cargar el modelo y el procesador
model_id = "llava-hf/llava-1.5-7b-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForVisionAndLanguageGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

# 2. Preparar la entrada
image = Image.open("cat.jpg")
prompt = "USER: <image>\\n¿Qué hay en esta imagen? Por favor descríbela. ASSISTANT:"

inputs = processor(images=image, text=prompt, return_tensors="pt").to("cuda")

# 3. Generar
with torch.no_grad():
    output = model.generate(**inputs, max_new_tokens=500)
answer = processor.decode(output[0], skip_special_tokens=True)

print(answer)
"""
)

Práctica: Proyecto completo de clasificación de imágenes + detección de objetos

Ahora integremos los conocimientos aprendidos anteriormente y hagamos un proyecto práctico completo.

Ejemplo

# ============================================
# Proyecto práctico: pipeline completo de IA visual
# Incluye clasificación de imágenes, detección de objetos y visualización de resultados
# ============================================

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
import numpy as np
from PIL import Image
import json
from pathlib import Path


class VisionPipeline:
    """
Pipeline completo de IA visual

Funciones:
1. Clasificación de imágenes
2. Detección de objetos
3. Resumen y visualización de resultados
    """


    def __init__(self, device: str = "cpu"):
        self.device = device
        self.classifier = None
        self.detector = None
        print(f"Inicialización de EJEMPLO Vision Pipeline (dispositivo: {device})")

    def build_classifier(self, num_classes: int = 10):
        """Construir el clasificador de imágenes"""
        print("\nConstruyendo el clasificador de imágenes...")
        # Usar el SimpleCNN definido anteriormente
        self.classifier = SimpleCNN(num_classes=num_classes).to(self.device)
        print("¡Clasificador construido!")
        return self

    def build_detector(self):
        """Construir el detector de objetos"""
        print("\nConstruyendo el detector de objetos...")
        self.detector = SimpleYOLO()
        print("¡Detector construido!")
        return self

    def load_pretrained_weights(self, classifier_path: str = None):
        """Cargar los pesos preentrenados"""
        if classifier_path and self.classifier:
            print(f"\nCargando pesos del clasificador: {classifier_path}")
            # En la práctica: self.classifier.load_state_dict(torch.load(classifier_path))
        return self

    def classify_image(self, image: np.ndarray) -> tuple:
        """
Clasificación de imágenes

Devuelve:
            (pred_class_id, pred_class_name, confidence)
        """

        if self.classifier is None:
            raise ValueError("Primero construya el clasificador: build_classifier()")

        # Preprocesamiento
        if isinstance(image, np.ndarray):
            if image.ndim == 2:  # Imagen en escala de grises
                image = np.stack([image]*3, axis=-1)
            image = torch.from_numpy(image).permute(2, 0, 1).float() / 255.0
            image = F.interpolate(image.unsqueeze(0), size=(32, 32), mode='bilinear')
            image = image.to(self.device)

        # Inferencia
        self.classifier.eval()
        with torch.no_grad():
            logits = self.classifier(image)
            probs = F.softmax(logits, dim=-1)
            confidence, pred_idx = probs.max(dim=-1)

        # Devolver resultado
        class_names = [
            'airplane', 'automobile', 'bird', 'cat', 'deer',
            'dog', 'frog', 'horse', 'ship', 'truck'
        ]
        pred_class = class_names[pred_idx.item()]

        return pred_idx.item(), pred_class, confidence.item()

    def detect_objects(self, image: np.ndarray) -> list:
        """Detección de objetos"""
        if self.detector is None:
            raise ValueError("Primero construya el detector: build_detector()")

        # Usar detección simulada
        return self.detector.predict_dummy(image)

    def process_image(self, image: np.ndarray) -> dict:
        """
Procesar una imagen por completo

Devuelve:
Un diccionario con todos los resultados
        """

        print("\n" + "=" * 60)
        print("Comenzar a procesar la imagen")
        print("=" * 60)

        results = {}

        # 1. Clasificación de imágenes
        if self.classifier is not None:
            print("\n[1/3] Ejecutando clasificación de imágenes...")
            class_id, class_name, conf = self.classify_image(image)
            results['classification'] = {
                'class_id': class_id,
                'class_name': class_name,
                'confidence': conf
            }
            print(f" → Resultado de clasificación: {class_name} (confianza: {conf:.2%})")

        # 2. Detección de objetos
        if self.detector is not None:
            print("\n[2/3] Ejecutando detección de objetos...")
            detections = self.detect_objects(image)
            results['detections'] = detections
            print(f" → Se detectaron {len(detections)} objetos:")
            for det in detections:
                print(f"      - {det['class_name']} ({det['score']:.2f})")

        # 3. Visualización
        print("\n[3/3] Generando visualización...")
        if self.detector is not None:
            vis_image = self.detector.visualize(image, detections)
            results['visualization'] = vis_image
            print(" → Visualización completada")

        print("\n" + "=" * 60)
        print("¡Procesamiento de imagen completado!")
        print("=" * 60)

        return results

    def save_results(self, results: dict, output_dir: str = "output"):
        """Guardar resultados en archivo"""
        output_path = Path(output_dir)
        output_path.mkdir(exist_ok=True)

        # Guardar resultado JSON
        json_result = {
            'classification': results.get('classification'),
            'detections': [
                {k: v for k, v in det.items() if k != 'bbox'}
                for det in results.get('detections', [])
            ]
        }
        with open(output_path / "results.json", "w") as f:
            json.dump(json_result, f, indent=2, ensure_ascii=False)

        # Guardar imagen de visualización
        if 'visualization' in results:
            vis = Image.fromarray(results['visualization'])
            vis.save(output_path / "visualization.jpg")

        print(f"\nResultados guardados en: {output_path}/")


# Ejemplo completo de entrenamiento
class SimpleDataset(Dataset):
    """Conjunto de datos simulado simple"""

    def __init__(self, num_samples: int = 100):
        self.num_samples = num_samples
        # Generar datos ficticios
        self.images = torch.randn(num_samples, 3, 32, 32)
        self.labels = torch.randint(0, 10, (num_samples,))

    def __len__(self):
        return self.num_samples

    def __getitem__(self, idx):
        return self.images[idx], self.labels[idx]


def train_classifier(pipeline: VisionPipeline, num_epochs: int = 5):
    """Flujo completo de entrenamiento del clasificador"""
    print("\n" + "=" * 60)
    print("Comenzar a entrenar el clasificador")
    print("=" * 60)

    # 1. Preparar datos
    print("\nPreparando conjunto de datos...")
    train_dataset = SimpleDataset(1000)
    val_dataset = SimpleDataset(200)

    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
    val_loader = DataLoader(val_dataset, batch_size=32)

    print(f"Conjunto de entrenamiento: {len(train_dataset)} muestras")
    print(f"Conjunto de validación: {len(val_dataset)} muestras")

    # 2. Optimizador y función de pérdida
    optimizer = torch.optim.Adam(pipeline.classifier.parameters(), lr=1e-3)
    criterion = nn.CrossEntropyLoss()

    # 3. Bucle de entrenamiento
    print("\nComenzando entrenamiento...")
    for epoch in range(num_epochs):
        pipeline.classifier.train()
        total_loss = 0.0
        correct = 0
        total = 0

        for images, labels in train_loader:
            images, labels = images.to(pipeline.device), labels.to(pipeline.device)

            optimizer.zero_grad()
            outputs = pipeline.classifier(images)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

            total_loss += loss.item()
            _, predicted = outputs.max(1)
            total += labels.size(0)
            correct += predicted.eq(labels).sum().item()

        train_acc = correct / total
        avg_loss = total_loss / len(train_loader)

        # Validación
        pipeline.classifier.eval()
        correct = 0
        total = 0
        with torch.no_grad():
            for images, labels in val_loader:
                images, labels = images.to(pipeline.device), labels.to(pipeline.device)
                outputs = pipeline.classifier(images)
                _, predicted = outputs.max(1)
                total += labels.size(0)
                correct += predicted.eq(labels).sum().item()

        val_acc = correct / total

        print(f"Epoch {epoch+1}/{num_epochs} - "
              f"Pérdida: {avg_loss:.4f}, "
              f"Precisión de entrenamiento: {train_acc:.2%}, "
              f"Precisión de validación: {val_acc:.2%}")

    print("\n¡Entrenamiento completado!")


# ============================================
# Ejecutar el proyecto práctico completo
# ============================================

print("=" * 60)
print("Proyecto práctico completo de IA visual de EJEMPLO")
print("=" * 60)

# 1. Crear el pipeline
pipeline = VisionPipeline(device="cuda" if torch.cuda.is_available() else "cpu")

# 2. Construir el modelo
pipeline.build_classifier(num_classes=10)
pipeline.build_detector()

# 3. Entrenar el clasificador
train_classifier(pipeline, num_epochs=3)

# 4. Procesar la imagen
test_image = create_test_image()
results = pipeline.process_image(test_image)

# 5. Guardar resultados
pipeline.save_results(results, output_dir="ejemplo_output")

print("\n" + "=" * 60)
print("¡Proyecto completado!")
print("=" * 60)
print("\nSugerencias para el siguiente paso de aprendizaje:")
print(" 1. Intenta entrenar en un conjunto de datos real (como CIFAR-10)")
print(" 2. Usa un modelo preentrenado para fine-tuning")
print(" 3. Prueba arquitecturas de modelo más complejas")
print(" 4. Despliega en aplicaciones reales")
Otras extensiones