Cómo crear un clasificador de imágenes mediante transferencia de aprendizaje en Azure ML

Este tutorial muestra cómo crear un clasificador de imágenes usando transferencia de aprendizaje en Azure AI & Machine Learning, útil para acelerar el entrenamiento con pocas imágenes y obtener un modelo listo para inferencia. Explica por qué se toman las decisiones y ofrece un paso a paso práctico para entrenar y desplegar usando una compute instance/cluster.

Requisitos previos

• Cuenta Azure con suscripción activa y permisos para crear recursos.
• Workspace de Azure Machine Learning creado.
• Imágenes organizadas en carpetas por clase (p. ej.: data/train/).
• Azure CLI y Azure ML SDK para Python instalados (o usar el Azure ML Studio).
• Conocimientos básicos de Python y comandos de terminal.

Paso 1: Por qué usar transferencia de aprendizaje

La transferencia de aprendizaje permite aprovechar redes preentrenadas (p. ej.: ResNet, EfficientNet) para tareas específicas con menos datos y menos tiempo de entrenamiento. En Azure ML, esto se integra bien con el compute y con pipelines, y reduce el overfitting cuando tienes pocas imágenes.

Paso 2: Preparar el entorno y los datos en el Workspace

Crea un recurso de compute (Compute Instance para desarrollo, Compute Cluster para entrenamiento) y registra los datos en el datastore del Workspace. Organiza las imágenes en train/val/test.

# Exemplo mínimo para registar dados no Workspace via Python
from azureml.core import Workspace, Dataset
ws = Workspace.from_config()
datastore = ws.get_default_datastore()
# Carrega uma pasta local para o datastore
datastore.upload(src_dir='data', target_path='image-data', overwrite=True)
# Regista como Dataset
dataset = Dataset.File.from_files(path=(datastore, 'image-data/'))

Paso 3: Escribir el script de entrenamiento con transferencia

Crea un archivo train.py que use PyTorch o TensorFlow. Aquí un ejemplo mínimo con PyTorch y una base preentrenada (ResNet18). El script hace load de las imágenes, sustituye la cabeza final y entrena solo los pesos finales.

# train.py (resumo mínimo)
import argparse
from torchvision import models, transforms, datasets
import torch, torch.nn as nn, torch.optim as optim

def main(args):
    transform = transforms.Compose([transforms.Resize((224,224)), transforms.ToTensor()])
    train_ds = datasets.ImageFolder(args.train_dir, transform=transform)
    train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)

    model = models.resnet18(pretrained=True)
    for param in model.parameters():
        param.requires_grad = False
    num_ftrs = model.fc.in_features
    model.fc = nn.Linear(num_ftrs, args.num_classes)

    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model.to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.fc.parameters(), lr=1e-3)

    model.train()
    for epoch in range(args.epochs):
        for imgs, labels in train_loader:
            imgs, labels = imgs.to(device), labels.to(device)
            optimizer.zero_grad()
            outputs = model(imgs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
    # Guarda o modelo
    torch.save(model.state_dict(), args.output_model)

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--train_dir')
    parser.add_argument('--num_classes', type=int)
    parser.add_argument('--epochs', type=int, default=3)
    parser.add_argument('--output_model', default='model.pth')
    args = parser.parse_args()
    main(args)

Paso 4: Crear un Experimento y enviar el entrenamiento en Azure ML

Empaqueta el script en un Estimator/ScriptRunConfig y envíalo al compute. Esto permite controlar el entorno, las dependencias y los logs.

# submit_job.py (resumo usando Azure ML SDK v1)
from azureml.core import Workspace, Experiment, Environment, ScriptRunConfig
ws = Workspace.from_config()
exp = Experiment(ws, 'transfer-learning-images')
env = Environment.from_conda_specification(name='env-tl', file_path='conda_dependencies.yml')
src = ScriptRunConfig(source_directory='.', script='train.py', arguments=['--train_dir','/mnt/data/train','--num_classes', '3','--epochs','5'], compute_target='cpu-cluster', environment=env)
run = exp.submit(src)
run.wait_for_completion(show_output=True)

Paso 5: Registrar e implementar el modelo

Tras el entrenamiento, registra el modelo en el Workspace y crea una image/container para inferencia o usa un endpoint de Azure ML para el deploy.

# registar_model.py
from azureml.core import Workspace, Model
ws = Workspace.from_config()
model = Model.register(ws, model_path='model.pth', model_name='resnet_transfer')
# Para un deploy rápido podes usar os endpoints online do Azure ML (ex.: ACI) via SDK/Studio

Verificar el resultado

Realiza una inferencia de prueba cargando el modelo registrado en un entorno similar al de producción. Confirma que las predicciones tienen sentido y que la precisión en datos de validación es aceptable. Revisa los logs del run y las métricas en el Studio para errores comunes: falta de GPU, rutas incorrectas, incompatibilidad de versiones.

Conclusión

Has completado un flujo completo: preparar datos, escribir un script de transferencia de aprendizaje, enviar el entrenamiento en Azure ML y registrar el modelo para deploy. Próximos pasos: probar diferentes backbones (EfficientNet), ajustar la learning rate y el congelado de capas, y crear un endpoint para inferencia en producción. Consejo: comienza entrenando pocos epochs y valida con frecuencia para evitar overfitting — ¿cuál es tu clase más difícil de distinguir?