Introudcción al problema

La identificación precisa de luces de boyas marítimas presenta desafíos significativos debido a condiciones ambientales variables como cambios de iluminación, niebla, lluvia y fondos complejos. Los métodos tradicionales basados en características manuales como HOG o SIFT tienen limitaciones en robustez y escalabilidad. Se propone un sistema avanzado de detección y clasificación de color utilizando arquitecturas de aprendizaje profundo modernas para abordar estas limitaciones.

Arquitectura del sistema

El sistema integra dos componentes principales: un módulo de detección de objetos basado en Cascade-RCNN para localizar luces de boyas, y un módulo de clasificación de color utilizando HRNetV2P. El flujo de trabajo incluye adquisición de datos, preprocesamiento, entrenamiento del modelo, optimización y despliegue en dispositivos de cómputo perimetral.

Preprocesamiento de datos

Se construyó un conjunto de datos con aproximadamente 8,000 imágenes de luces de boyas en colores rojo, verde y blanco, capturadas bajo diversas condiciones ambientales. Las anotaciones incluyen cuadros delimitadores y etiquetas de color. Se aplicaron técnicas de aumento de datos para mejorar la generalización:

• Transformaciones aleatorias de brillo, contraste y saturación.
• Volteos horizontales y rotaciones limitadas.
• Recortes y escalados aleatorios.

Ejemplo de código para aumento de datos con lógica modificada:

import cv2
import random
import numpy as np

def aplicar_aumento(imagen, anotacion):
    # Transformación de brillo aleatorio
    factor_brillo = random.uniform(0.8, 1.2)
    imagen_mod = np.clip(imagen * factor_brillo, 0, 255).astype(np.uint8)
    
    # Volteo horizontal con probabilidad del 50%
    if random.random() < 0.5:
        imagen_mod = cv2.flip(imagen_mod, 1)
        anotacion[0] = imagen_mod.shape[1] - anotacion[0] - anotacion[2]
    
    # Rotación aleatoria dentro de [-10, 10] grados
    angulo = random.uniform(-10, 10)
    centro = (imagen_mod.shape[1] // 2, imagen_mod.shape[0] // 2)
    matriz_rot = cv2.getRotationMatrix2D(centro, angulo, 1.0)
    imagen_mod = cv2.warpAffine(imagen_mod, matriz_rot, (imagen_mod.shape[1], imagen_mod.shape[0]))
    
    return imagen_mod, anotacion

Modelo de detección: Cascade-RCNN

Cascade-RCNN emplea una serie de detectores en cascada que incrementan gradualmente el umbral de IoU, mejorando la precisión de localización para objetos de diferentes escalas. Se utilizó ResNet50 como red de extracción de características, seguido de una Red de Propuesta de Regiones (RPN) y cabezales de detección en cascada.

Implementación simplificada con nombres de variables alterados:

import torch.nn as nn

class RedDeteccionCascada(nn.Module):
    def __init__(self, red_base, num_clases):
        super(RedDeteccionCascada, self).__init__()
        self.red_extraccion = red_base
        self.generador_propuestas = CabezaRPN(red_base.canales_salida)
        self.cabezal_cascada = CabezalRoICascada(red_base.canales_salida, num_clases)
    
    def forward(self, entradas_imagen, objetivos=None):
        caracteristicas = self.red_extraccion(entradas_imagen.tensores)
        propuestas, perdidas_prop = self.generador_propuestas(entradas_imagen, caracteristicas, objetivos)
        detecciones, perdidas_det = self.cabezal_cascada(caracteristicas, propuestas, entradas_imagen.tamano_imagen, objetivos)
        return detecciones, perdidas_det

Modelo de clasificación: HRNetV2P

HRNetV2P mantiene representaciones de alta resolución durante todo el proceso, capturando detalles finos para la clasificación de color. Se añadió una capa de conversión al espacio de color HSV para resaltar características cromáticas. La red se entrena para distinguir entre las tres categorías de color objetivo.

Definición de la red con estructura modificada:

class RedClasificacionColor(nn.Module):
    def __init__(self, num_categorias):
        super(RedClasificacionColor, self).__init__()
        self.capas_convolucionales = nn.ModuleList([
            nn.Conv2d(3, 32, 3, stride=2, padding=1),
            nn.Conv2d(32, 64, 3, stride=2, padding=1),
            nn.Conv2d(64, 128, 3, stride=1, padding=1)
        ])
        self.modulos_alta_res = nn.ModuleList([
            ModuloAltaResolucion(32, 32, 4),
            ModuloAltaResolucion(64, 64, 3),
            ModuloAltaResolucion(128, 128, 2)
        ])
        self.capa_final = nn.Conv2d(128, num_categorias, 1)
    
    def forward(self, x):
        for conv in self.capas_convolucionales:
            x = conv(x)
        for modulo in self.modulos_alta_res:
            x = modulo(x)
        return self.capa_final(x)

Entrenamiento y optimización

Se empleó una estrategia de entrenamiento en dos fases: primero, ajuste fino de la red de extracción de características usando pesos preentrenados; segundo, entrenamiento integral del sistema completo. Se utilizó la pérdida Focal para manejar el desbalance de clases y Smooth L1 Loss para la regresión de cuadros delimitadores.

Para el despliegue en dispositivos de cómputo perimetral (ej. NVIDIA Jetson Nano), se aplicaron técnicas de compresión del modelo:

• Poda estructurada: Eliminación de neuronas con normas L1 bajas.
• Cuantización a INT8: Reducción de precisión de 32 a 8 bits.

Función de poda con lógica alternativa:

import torch

def reducir_modelo(modelo, proporcion_poda=0.3):
    for nombre, capa in modelo.named_modules():
        if isinstance(capa, torch.nn.Conv2d):
            pesos = capa.weight.data
            normas_l1 = pesos.abs().sum(dim=[1, 2, 3])
            num_eliminar = int(len(normas_l1) * proporcion_poda)
            _, indices = torch.topk(normas_l1, num_eliminar, largest=False)
            mascara = torch.ones_like(pesos)
            mascara[indices, :, :, :] = 0
            capa.weight.data *= mascara
    return modelo

Evaluación del rendimiento

El sistema se evaluó en condiciones variadas de iluminación y clima. Los resultados demostraron alta precisión y velocidad en tiempo real:

El despliegue final en hardware perimetral logró una velocidad promedio de 15 FPS con una precisión superior al 85% mAP en la mayoría de escenarios, cumpliendo con requisitos de aplicaciones en tiempo real para monitoreo marítimo.

Implementaciones futuras incluirán integración con sensores infrarrojos para mejorar la robustez nocturna y técnicas de aprendizaje federado para actualizaciones colaborativas del modelo.