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.
| Arquitectura | Año | Innovación principal | Características |
|---|---|---|---|
| AlexNet | 2012 | Activación ReLU, Dropout, aumento de datos | Iniciador de la era del aprendizaje profundo, siendo el primero en superar significativamente a los métodos tradicionales en ImageNet. |
| VGG | 2014 | Uso uniforme de núcleos de convolución pequeños de 3×3 | Estructura simple y elegante, fácil de entender e implementar |
| ResNet | 2015 | Conexión residual (Skip Connection) | Resuelve el problema de la desaparición del gradiente en redes profundas, permitiendo redes de más de cien capas. |
| EfficientNet | 2019 | Método de escalado compuesto | Escala 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ística | CNN | ViT |
|---|---|---|
| Sesgo inductivo | Fuerte (localidad, invariancia a traslaciones) | Débil (aprendido de los datos) |
| Requisitos de datos | Funciona incluso con pocos datos | Necesita muchos datos para aprovechar sus ventajas |
| Eficiencia computacional | Generalmente más rápido, con optimización de hardware madura | Muchos parámetros y cómputo intensivo |
| Interpretabilidad | Fácil visualizar los kernels de convolución | Los mapas de atención son interpretables, pero el conjunto es más difícil |
| Dependencias de largo alcance | Necesita varias capas para establecerse | Soporta de forma natural un campo receptivo global |
| Escenarios de aplicación | Datos limitados, alta exigencia de tiempo real | Grandes 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:
| Modelo | Mejora principal | Velocidad |
|---|---|---|
| R-CNN | Usar CNN en lugar de características tradicionales | Lenta (decenas de segundos por imagen) |
| Fast R-CNN | ROI Pooling, cálculo de características compartido | Media (unos segundos por imagen) |
| Faster R-CNN | RPN(Region Proposal Network) | Rápida (cientos de milisegundos por imagen) |
| Mask R-CNN | Añadir rama de segmentación | Medio |
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.
| Tarea | Objetivo | Ejemplo | Modelo representativo |
|---|---|---|---|
| Segmentación semántica | Clasificar cada píxel (sin considerar instancias) | Marcar a todas las personas en rojo y a todos los coches en azul | FCN、U-Net、DeepLab |
| Segmentación de instancias | Clasificar cada píxel y diferenciar distintas instancias | Marcar a la persona 1 en rojo, a la persona 2 en naranja | Mask R-CNN、YOLOv8-Seg |
| Segmentación panóptica | Semántica + instancias, representación unificada | Anotar 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:
| Área | Escenario de aplicación | Tipo de tarea |
|---|---|---|
| Imágenes médicas | Segmentación de tumores, medición de órganos | Segmentación semántica |
| Conducción autónoma | Detección de área transitable y reconocimiento de líneas de carril | Segmentación semántica |
| Imágenes de teledetección | Clasificación de cobertura terrestre, extracción de edificios | Segmentación semántica |
| Fabricación inteligente | Detección de defectos, medición de piezas | Segmentación de instancias |
| Edición de video | Recorte de personas, reemplazo de fondo | Segmentació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.
| Muestreador | Nombre completo | Número de pasos | Características |
|---|---|---|---|
| DDPM | Denoising Diffusion Probabilistic Models | 1000 | Método original, buena calidad pero lento |
| DDIM | Denoising Diffusion Implicit Models | 50-100 | Muestreo determinista, rápido |
| LMS | Linear Multistep Method | 30-50 | Rápido y de buena calidad |
| DPM-Solver | DPM-Solver | 10-20 | Ultra 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étodo | Característica | Modelo representativo |
|---|---|---|
| Token especial | Usar un token [IMG] para representar toda la imagen | Modelos tempranos |
| Concatenación de secuencias | Concatenar directamente los embeddings de los parches de imagen antes del texto | LLaVA、GPT-4V |
| Atención cruzada | Añadir atención cruzada sobre las características visuales en el LLM | BLIP-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")