Diagnóstico de Fallos en Cálculos de Ponderación

En el desarrollo de un sistema de fusión de imágenes, se encontró que la estrategia de fusión basada en softmax no producía los resultados esperados. Al analizar imágenes específicas y supervisar los mapas de características, se generó un error de advertencia:

RuntimeWarning: invalid value encountered in cast

La inspección reveló que la imagen de salida contenía valores NaN, impidiendo su almacenamiento adecuado. Al depurar la estrategia de fusión, se observó que los pesos calculados eran en su mayoría NaN, causados por un desbordamiento en la operación softmax.

Fenómenos de Desbordamiento

En computación, el desbordamiento (overflow) ocurre cuando un valor excede el límite superior del tipo de datos, mientras que el subdesbordamiento (underflow) sucede cuando es menor al límite inferior. Para números de punto flotante, el subdesbordamiento puede truncar valores muy pequeños a cero debido a la precisión limitada.

Lógica del Cálculo de Softmax

El softmax convierte valores no normalizados en una distribución de probabilidad, asignando pesos positivos que suman uno para una fusión ponderada. Dado dos mapas de características espaciales, mapa_esp1 y mapa_esp2, los pesos se calculan como:

peso_esp1 = exp(mapa_esp1) / (exp(mapa_esp1) + exp(mapa_esp2))
peso_esp2 = exp(mapa_esp2) / (exp(mapa_esp1) + exp(mapa_esp2))

Con tipos de datos torch.float32, el valor máximo representable es aproximadamente 3.4e38. Si los valores de mapa_esp1 exceden 88, la exponenciación produce infinito (inf), llevando a divisiones indeterminadas y resultados NaN.

Implementación Inicial y Problemas

# Ejemplo de valores problemáticos
mapa_esp1 = tensor([[[[1098.9207, ...], ...]]])
# Esto causa exponenciación de valores grandes, resultando en inf.

Solución con Resta del Máximo

Para mejorar la estabilidad numérica, se resta el valor máximo antes de la exponenciación:

max_valor = torch.max(torch.cat((mapa_esp1, mapa_esp2), dim=0))
exp_ajustada1 = torch.exp(mapa_esp1 - max_valor)
exp_ajustada2 = torch.exp(mapa_esp2 - max_valor)
peso_esp1 = exp_ajustada1 / (exp_ajustada1 + exp_ajustada2 + 1e-8)
peso_esp2 = exp_ajustada2 / (exp_ajustada1 + exp_ajustada2 + 1e-8)

Esto evita el desbordamiento superior, ya que el mayor exponente es cero. Sin embargo, si los valores originales son significativamente menores que el máximo, la resta resulta en exponentes muy negativos, causando subdesbordamiento. Los pesos se vuelven cero, como se observa en la salida:

peso_esp1 = tensor([[0., 0., ...], ...])

Normalización para Estabilidad Completa

Se aplicó normalización min-max a los mapas antes del softmax para restringir los valores al rango (0,1), evitando ambos desbordamientos:

min1, max1 = mapa_esp1.min(), mapa_esp1.max()
min2, max2 = mapa_esp2.min(), mapa_esp2.max()
mapa_norm1 = (mapa_esp1 - min1) / (max1 - min1 + 1e-8)
mapa_norm2 = (mapa_esp2 - min2) / (max2 - min2 + 1e-8)
peso_esp1 = torch.exp(mapa_norm1) / (torch.exp(mapa_norm1) + torch.exp(mapa_norm2) + 1e-8)
peso_esp2 = torch.exp(mapa_norm2) / (torch.exp(mapa_norm1) + torch.exp(mapa_norm2) + 1e-8)

Esto garantizó resultados numéricamente estables y coherentes.

Estrategia de Fusión Basada en Gradientes

Para resaltar características defectuosas en imágenes, se diseñó una estrategia de fusión que enfatiza regiones con grandes cambios de intensidad, típicamente asociados a defectos. Se implementó usando el operador de Sobel para calcular gradientes en direcciones x e y, y luego ponderar la fusión según la intensidad del gradiente.

def calcular_gradiente_intensidad(tensor_entrada):
    kernel_x = torch.tensor([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=torch.float32, device=tensor_entrada.device).view(1, 1, 3, 3)
    kernel_y = torch.tensor([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], dtype=torch.float32, device=tensor_entrada.device).view(1, 1, 3, 3)
    # Expandir kernels para canales múltiples
    canales = tensor_entrada.shape[1]
    kernel_x = kernel_x.repeat(canales, 1, 1, 1)
    kernel_y = kernel_y.repeat(canales, 1, 1, 1)
    grad_x = F.conv2d(tensor_entrada, kernel_x, padding=1, groups=canales)
    grad_y = F.conv2d(tensor_entrada, kernel_y, padding=1, groups=canales)
    intensidad_grad = torch.sqrt(grad_x ** 2 + grad_y ** 2 + 1e-8)
    return intensidad_grad

def fusion_por_gradientes(tensor_a, tensor_b):
    grad_a = calcular_gradiente_intensidad(tensor_a)
    grad_b = calcular_gradiente_intensidad(tensor_b)
    peso_a = grad_a / (grad_a + grad_b + 1e-8)
    peso_b = grad_b / (grad_a + grad_b + 1e-8)
    tensor_fusionado = peso_a * tensor_a + peso_b * tensor_b
    return tensor_fusionado

Los resultados mostraron mayor contraste en áreas defectuosas, pero también afectaron bordes con reflejos, indicando la necesidad de optimizaciones adicinoales.

Arquitectura MEF-NET para Fusión Multi-Exposición

MEF-NET es un modelo de aprendizaje profundo para fusión rápida de imágenes con múltiples exposiciones. Consta de un submuestreador bilineal, una red de agregación de contexto (CAN), un filtro guiado y un módulo de fusión ponderada.

Predicción de Mapas de Peso en Baja Resolución con CAN

La CAN toma secuencias de entrada submuestreadas y genera mapas de peso de baja resloución. Está diseñada como una red totalmente convolucional para manejar tamaños espaciales y números de exposición variables. Sus capas incluyen convoluciones con normalización adaptativa:

La normalización adaptativa se define como:

AN(z) = lambda_n * z + lambda_n_prima * IN(z)

Donde lambda_n y lambda_n_prima son escalares aprendibles, e IN es la normalización de instancias. Se utiliza LReLU como no linealidad para preservar estructuras locales.

Submuestreo Guiado para Mapas de Alta Resolución

El filtro guiado asume un modelo lineal local entre la guía I y la salida Q:

Q(i) = a_omega * I(i) + b_omega, para todo i en omega

Los coeficientes a_omega y b_omega se calculan minimizando el error de reconstrucción con regularización. En MEF-NET, los mapas de baja resolución se usan para obtener A_k y B_k, que se submuestrean bilinealmente para generar mapas de peso de alta resolución W_k. Estos se normalizan para sumar uno en cada posición espacial.

Función de Pérdida MEF-SSIM

MEF-SSIM evalúa la calidad de la imagen fusionada descomponiendo parches en componentes de intensidad, contraste y estructura. La intensión deseada se pondera según promedios globales y locales, el contraste se toma como el máximo entre exposiciones, y la estructura se promedia con pesos basados en normas infinitas. La métrica se calcula como:

MEF-SSIM({X_k}, Y) = (1/M) * sum_{i=1}^{M} S({R_i X_k}, R_i Y)

Donde S sigue una fórmula similar a SSIM, usando medias, varianzas y covarianzas locales. La optimización se realiza en componentes de luminancia en formato Y'CbCr.