Cómo crear un detector de anomalías en imágenes médicas en Azure AI & Machine Learning

João Barros 19 de October de 2026 5 min de lectura

Este tutorial muestra cómo crear un detector de anomalías en imágenes médicas usando Azure AI & Machine Learning, útil para señalar imágenes que necesitan revisión clínica. Explica por qué el método de detección one-class (solo ejemplos normales) y ofrece un paso a paso práctico para entrenar y validar un modelo simple.

Prerequisitos

Cuenta Azure con suscripción activa y permisos para crear recursos.
Azure Machine Learning workspace creado.
Python 3.8+ instalado localmente y pip.
Imágenes médicas normales (p. ej.: radiografías/ultrasonidos) en formato PNG/JPEG para entrenamiento.
Familiaridad básica con comandos CLI y Jupyter Notebook.

Paso 1: Preparar el entorno en Azure ML

Crea un Compute Instance o Compute Cluster en Azure Machine Learning para entrenar el modelo. El objetivo es disponer de un entorno con GPU opcional para acelerar el entrenamiento. También crea un datastore para las imágenes.

# Exemplo mínimo com Azure CLI
az ml workspace show -n  -g 
# Criar compute cluster (exemplo)
az ml compute create -n gpu-cluster --type amlcompute --size STANDARD_NC6 --min-instances 0 --max-instances 4

Paso 2: Organizar datos (solo imágenes normales)

Para detección de anomalías con enfoque one-class, se entrena con imágenes normales. Coloca las imágenes en una carpeta local organizada y haz upload al datastore del workspace.

mkdir -p data/train/normal
# copiar imagens para data/train/normal
az ml datastore upload -n workspaceblobstore -p data/train --target-path data/train --overwrite

Paso 3: Elegir el enfoque y el modelo

Una solución simple y eficaz es usar un autoencoder basado en CNN: el modelo aprende a reconstruir imágenes normales; las imágenes anómalas presentan un error de reconstrucción mayor. Explicación: el autoencoder aprende patrones normales y falla en reconstruir lo que es diferente.

# Exemplo de arquitetura mínima em Keras (ficheiro train_autoencoder.py)
from tensorflow import keras
from tensorflow.keras import layers

def build_autoencoder(input_shape=(128,128,1)):
    inputs = keras.Input(shape=input_shape)
    x = layers.Conv2D(32, 3, activation='relu', padding='same')(inputs)
    x = layers.MaxPool2D(2, padding='same')(x)
    x = layers.Conv2D(64, 3, activation='relu', padding='same')(x)
    encoded = layers.MaxPool2D(2, padding='same')(x)

    x = layers.Conv2DTranspose(64, 3, strides=2, activation='relu', padding='same')(encoded)
    x = layers.Conv2DTranspose(32, 3, strides=2, activation='relu', padding='same')(x)
    decoded = layers.Conv2D(1, 3, activation='sigmoid', padding='same')(x)

    return keras.Model(inputs, decoded)

Paso 4: Entrenar en Azure ML

Empaqueta el script de entrenamiento y envía un experimento en Azure ML. Configura el entorno (conda/conda_dependencies.yml) y usa el compute creado.

# Exemplo de submissão com SDK (snippet)
from azureml.core import Workspace, Experiment, ScriptRunConfig, Environment
ws = Workspace.from_config()
env = Environment.from_conda_specification(name='ae-env', file_path='conda_dependencies.yml')
src = ScriptRunConfig(source_directory='.', script='train_autoencoder.py', compute_target='gpu-cluster', environment=env)
exp = Experiment(ws, 'ae_medical_images')
run = exp.submit(src)
run.wait_for_completion(show_output=True)

Paso 5: Calcular umbral de anomalía

Tras entrenar, calcula el error medio de reconstrucción en las imágenes de validación normales; define un umbral (por ejemplo media + 3*std) para clasificar anomalías.

# Código de ejemplo para calcular erro de reconstrução
import numpy as np
from tensorflow.keras.models import load_model

model = load_model('outputs/autoencoder.h5')
# carregar validação normal como array: X_val (N, H, W, 1)
recon = model.predict(X_val)
mse = np.mean((X_val - recon)**2, axis=(1,2,3))
threshold = mse.mean() + 3*mse.std()
print('Threshold:', threshold)

Paso 6: Hacer inferencia y detectar anomalías

Para una nueva imagen, normaliza, hace predict, calcula el error de reconstrucción y lo compara con el umbral. Si el error es mayor, la marca como potencial anomalía.

def is_anomaly(img, model, threshold):
    # img: array 1,H,W,1 normalizado 0-1
    recon = model.predict(img)
    err = np.mean((img - recon)**2)
    return err > threshold, err

# exemplo
an, err = is_anomaly(X_new[0:1], model, threshold)
print('Anomaly:', an, 'Error:', err)

Verificar el resultado

Valida con un conjunto de imágenes etiquetadas (normales y anómalas) y calcula métricas simples: matriz de confusión, precision, recall. Visualiza las imágenes con mayor error y sus respectivas reconstrucciones para confirmar si las anomalías son plausibles.

# Exemplo rápido de avaliação
from sklearn.metrics import confusion_matrix, precision_score, recall_score
preds = [is_anomaly(x[None,...], model, threshold)[0] for x in X_test]
cm = confusion_matrix(y_test, preds)
print('Confusion matrix:\n', cm)
print('Precision:', precision_score(y_test, preds))
print('Recall:', recall_score(y_test, preds))

Conclusión

Con un autoencoder simple en Azure AI & Machine Learning es posible crear un detector de anomalías en imágenes médicas para cribado inicial. Los siguientes pasos incluyen mejorar el preprocesamiento (data augmentation, normalización de intensidad), probar modelos más avanzados (Variational Autoencoder, GANs) e integrar el endpoint de inferencia para uso clínico. Consejo: prueba varios umbrales y valida con especialistas clínicos antes de producción — ¿qué umbral te parece más seguro para tu aplicación?