Como criar um classificador de imagens por transferência de aprendizagem em Azure ML

Este tutorial mostra como criar um classificador de imagens usando transferência de aprendizagem em Azure AI & Machine Learning, útil para acelerar o treino com poucas imagens e obter um modelo pronto para inferência. Explica o porquê das escolhas e um passo a passo prático para treinar e implantar usando uma compute instance/cluster.

Pré-requisitos

• Conta Azure com subscrição activa e permissões para criar recursos.
• Workspace de Azure Machine Learning criado.
• Imagens organizadas em pastas por classe (ex.: data/train/).
• Azure CLI e Azure ML SDK para Python instalados (ou usar o Azure ML Studio).
• Noções básicas de Python e comandos de terminal.

Passo 1: Porque usar transferência de aprendizagem

A transferência de aprendizagem permite aproveitar redes pré-treinadas (ex.: ResNet, EfficientNet) para tarefas específicas com menos dados e menos tempo de treino. Em Azure ML, isto integra-se bem com o compute e com pipelines, e reduz o overfitting quando tens poucas imagens.

Passo 2: Preparar o ambiente e os dados no Workspace

Cria um recurso de compute (Compute Instance para desenvolvimento, Compute Cluster para treino) e regista os dados no datastore do Workspace. Organiza as imagens em 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/'))

Passo 3: Escrever o script de treino com transferência

Cria um ficheiro train.py que use PyTorch ou TensorFlow. Aqui um exemplo mínimo com PyTorch e uma base pré-treinada (ResNet18). O script faz load das imagens, substitui a cabeça final e treina apenas os pesos finais.

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

Passo 4: Criar um Experimento e submeter o treino no Azure ML

Empacota o script num Estimator/ScriptRunConfig e submete-o para o compute. Isto permite controlar o ambiente, as dependências e os 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)

Passo 5: Registar e implementar o modelo

Depois do treino, regista o modelo no Workspace e cria uma image/container para inferência ou usa um endpoint do Azure ML para 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 um deploy rápido podes usar os endpoints online do Azure ML (ex.: ACI) via SDK/Studio

Verificar o resultado

Faz uma inferência de teste carregando o modelo registado num ambiente similar ao de produção. Confirma que as previsões fazem sentido e que a acurácia em dados de validação é aceitável. Verifica os logs do run e as métricas no Studio para erros comuns: falta de GPU, paths incorrectos, incompatibilidade de versões.

Conclusão

Concluíste um fluxo completo: preparar dados, escrever um script de transferência de aprendizagem, submeter o treino em Azure ML e registar o modelo para deploy. Próximos passos: experimentar diferentes backbones (EfficientNet), ajustar a learning rate e o congelamento de camadas, e criar um endpoint para inferência em produção. Dica: começa por treinar poucos epochs e valida frequentemente para evitar overfitting — qual é a tua classe mais difícil de distinguir?