Procesamiento de imágenes con IA: guía completa

El procesamiento de imágenes con Inteligencia Artificial ha revolucionado la visión artificial. Esta guía explora las técnicas modernas y sus aplicaciones.

1. Principios fundamentales

Redes neuronales convolucionales (CNN)

# Ejemplo de implementación de una CNN simple
import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64 * 4 * 4, 512)
        self.fc2 = nn.Linear(512, 10)
        
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = self.pool(torch.relu(self.conv3(x)))
        x = x.view(-1, 64 * 4 * 4)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

Preprocesamiento de imágenes

# Ejemplo de preprocesamiento de imágenes
import cv2
import numpy as np
from torchvision import transforms

def preprocess_image(image_path):
    # Lectura de la imagen
    image = cv2.imread(image_path)
    
    # Redimensionamiento
    image = cv2.resize(image, (224, 224))
    
    # Normalización
    image = image.astype(np.float32) / 255.0
    
    # Transformación en tensor
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406],
                           std=[0.229, 0.224, 0.225])
    ])
    
    return transform(image)

2. Aplicaciones prácticas

Clasificación de imágenes

# Ejemplo de clasificación de imágenes con ResNet
from torchvision.models import resnet50
from torchvision import transforms

def classify_image(image_path):
    # Carga del modelo preentrenado
    model = resnet50(pretrained=True)
    model.eval()
    
    # Preparación de la imagen
    transform = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406],
                           std=[0.229, 0.224, 0.225])
    ])
    
    image = transform(Image.open(image_path)).unsqueeze(0)
    
    # Predicción
    with torch.no_grad():
        outputs = model(image)
        _, predicted = torch.max(outputs, 1)
    
    return predicted.item()

Detección de objetos

# Ejemplo de detección de objetos con YOLOv5
from PIL import Image
import torch

def detect_objects(image_path):
    # Carga del modelo YOLOv5
    model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
    
    # Detección
    results = model(image_path)
    
    # Procesamiento de los resultados
    detections = []
    for pred in results.xyxy[0]:
        x1, y1, x2, y2, conf, cls = pred
        detections.append({
            'classe': results.names[int(cls)],
            'confiance': float(conf),
            'boîte': [float(x1), float(y1), float(x2), float(y2)]
        })
    
    return detections

3. Segmentación de imágenes

Segmentación semántica

# Ejemplo de segmentación semántica con U-Net
import torch.nn as nn

class UNet(nn.Module):
    def __init__(self):
        super().__init__()
        # Encoder
        self.enc1 = self.conv_block(3, 64)
        self.enc2 = self.conv_block(64, 128)
        self.enc3 = self.conv_block(128, 256)
        
        # Decoder
        self.dec3 = self.conv_block(256, 128)
        self.dec2 = self.conv_block(128, 64)
        self.dec1 = self.conv_block(64, 32)
        
        # Capa final
        self.final = nn.Conv2d(32, 1, kernel_size=1)
        
    def conv_block(self, in_channels, out_channels):
        return nn.Sequential(
            nn.Conv2d(in_channels, out_channels, 3, padding=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels, 3, padding=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )

Segmentación de instancias

# Ejemplo de segmentación de instancias con Mask R-CNN
from torchvision.models.detection import maskrcnn_resnet50_fpn

def instance_segmentation(image_path):
    # Carga del modelo
    model = maskrcnn_resnet50_fpn(pretrained=True)
    model.eval()
    
    # Preparación de la imagen
    image = Image.open(image_path)
    transform = transforms.Compose([
        transforms.ToTensor()
    ])
    image_tensor = transform(image)
    
    # Predicción
    with torch.no_grad():
        prediction = model([image_tensor])
    
    return prediction[0]

4. Aplicaciones avanzadas

Reconocimiento facial

# Ejemplo de reconocimiento facial con FaceNet
import face_recognition

def face_recognition_system(image_path, known_faces):
    # Carga de la imagen
    image = face_recognition.load_image_file(image_path)
    
    # Detección de los rostros
    face_locations = face_recognition.face_locations(image)
    face_encodings = face_recognition.face_encodings(image, face_locations)
    
    # Comparación con los rostros conocidos
    results = []
    for face_encoding in face_encodings:
        matches = face_recognition.compare_faces(known_faces, face_encoding)
        results.append(matches)
    
    return results

Generación de imágenes

# Ejemplo de generación de imágenes con GAN
import torch.nn as nn

class Generator(nn.Module):
    def __init__(self, latent_dim):
        super().__init__()
        self.main = nn.Sequential(
            nn.ConvTranspose2d(latent_dim, 512, 4, 1, 0, bias=False),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            nn.ConvTranspose2d(512, 256, 4, 2, 1, bias=False),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            nn.ConvTranspose2d(256, 128, 4, 2, 1, bias=False),
            nn.BatchNorm2d(128),
            nn.ReLU(True),
            nn.ConvTranspose2d(128, 64, 4, 2, 1, bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            nn.ConvTranspose2d(64, 3, 4, 2, 1, bias=False),
            nn.Tanh()
        )
    
    def forward(self, x):
        return self.main(x)

5. Optimización y rendimiento

Cuantización del modelo

# Ejemplo de cuantización de un modelo
import torch.quantization

def quantize_model(model):
    # Preparación para la cuantización
    model.eval()
    model.qconfig = torch.quantization.get_default_qconfig('fbgemm')
    
    # Cuantización
    torch.quantization.prepare(model, inplace=True)
    torch.quantization.convert(model, inplace=True)
    
    return model

Optimización del rendimiento

# Ejemplo de optimización del rendimiento
def optimize_image_processing(image_path):
    # Carga de la imagen
    image = cv2.imread(image_path)
    
    # Optimizaciones
    image = cv2.resize(image, (224, 224))
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # Normalización
    image = image.astype(np.float32) / 255.0
    
    # Aumento de datos
    transform = transforms.Compose([
        transforms.RandomHorizontalFlip(),
        transforms.RandomRotation(10),
        transforms.ColorJitter(brightness=0.2, contrast=0.2)
    ])
    
    return transform(image)

Conclusión

El procesamiento de imágenes con IA ofrece posibilidades inmensas:

• Clasificación de imágenes
• Detección de objetos
• Segmentación de imágenes
• Reconocimiento facial
• Generación de imágenes

Puntos clave que debes recordar:

• Comprender las arquitecturas CNN
• Dominar el preprocesamiento de imágenes
• Optimizar el rendimiento
• Gestionar la memoria de forma eficiente
• Seguir las buenas prácticas