Como criar um detetor de anomalias em imagens médicas em Azure AI & Machine Learning

Este tutorial mostra como criar um detetor de anomalias em imagens médicas usando Azure AI & Machine Learning, útil para sinalizar imagens que precisam de revisão clínica. Explica o porquê do método de deteção one-class (apenas exemplos normais) e dá um passo a passo prático para treinar e validar um modelo simples.

Pré‑requisitos

• Conta Azure com subscrição ativa e permissões para criar recursos.
• Azure Machine Learning workspace criado.
• Python 3.8+ instalado localmente e pip.
• Imagens médicas normais (ex.: radiografias/ultrassons) em formato PNG/JPEG para treino.
• Familiaridade básica com comandos CLI e Jupyter Notebook.

Passo 1: Preparar o ambiente no Azure ML

Cria um Compute Instance ou Compute Cluster no Azure Machine Learning para treinar o modelo. O objetivo é ter um ambiente com GPU opcional para acelerar o treino. Também cria um datastore para as imagens.

# 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

Passo 2: Organizar dados (apenas imagens normais)

Para deteção de anomalias com abordagem one-class, treina-se com imagens normais. Coloca as imagens numa pasta local organizada e faz upload para o datastore do 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

Passo 3: Escolher a abordagem e modelo

Uma solução simples e eficiente é usar um autoencoder baseado em CNN: o modelo aprende a reconstruir imagens normais; imagens anómalas apresentam erro de reconstrução maior. Explicação: o autoencoder aprende padrões normais e falha em reconstruir o que é 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)

Passo 4: Treinar no Azure ML

Empacota o script de treino e submete um experimento no Azure ML. Configura o ambiente (conda/conda_dependencies.yml) e usa o compute criado.

# 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)

Passo 5: Calcular limiar de anomalia

Depois de treinar, calcula o erro médio de reconstrução nas imagens de validação normais; define um limiar (por exemplo média + 3*std) para classificar anomalias.

# Código de exemplo 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)

Passo 6: Fazer inferência e detetar anomalias

Para uma nova imagem, normaliza, faz predict, calcula o erro de reconstrução e compara com o limiar. Se o erro for maior, marca como potencial anomalia.

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 o resultado

Valida com um conjunto de imagens rotuladas (normais e anómalas) e calcula métricas simples: confusion matrix, precision, recall. Visualiza imagens com maior erro e respetivas reconstruções para confirmar se as anomalias são plausíveis.

# 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))

Conclusão

Com um autoencoder simples no Azure AI & Machine Learning é possível criar um detetor de anomalias em imagens médicas para triagem inicial. Próximos passos incluem melhorar o pré‑processamento (data augmentation, normalização de intensidade), experimentar modelos mais avançados (Variational Autoencoder, GANs) e integrar o endpoint de inferência para uso clínico. Dica: testa vários limiares e valida com especialistas clínicos antes de produção — que limiar te parece mais seguro para a tua aplicação?