Como detetar e classificar imagens industriais com Azure AI Vision: passo a passo

Este tutorial mostra como usar Azure AI Vision para detetar e classificar defeitos em imagens industriais (por exemplo, riscadas ou fissuras). A abordagem é útil para automatizar a inspeção visual, reduzir o erro humano e integrar modelos de visão em pipelines de produção.

Pré-requisitos

• Conta Azure com subscrição ativa e permissões para criar recursos.
• Recurso Azure AI Vision (ou Azure OpenAI Vision) criado e chave/endpoint disponíveis.
• Python 3.8+ instalado localmente e pip.
• Conjunto de imagens rotuladas para treino (pasta com subpastas por classe: ok, defeito).
• Conhecimentos básicos de Python e linha de comandos.

Passo 1: Preparar os dados e estrutura de pastas

Organize as imagens em duas pastas principais: train/ok, train/defeito, e opcionalmente validation/ok, validation/defeito. Imagens pequenas (224x224) tornam o treino mais rápido. Verifique formatos comuns (.jpg, .png).

# Estrutura de exemplo
dataset/
  train/
    ok/
      img001.jpg
      img002.jpg
    defeito/
      img101.jpg
  validation/
    ok/
    defeito/

Passo 2: Criar e configurar o recurso Azure AI Vision

No Portal Azure crie um recurso 'Azure AI Vision' (ou similar). Guarde o endpoint e a chave. Vai precisar destes para chamadas de inferência e, se usar treino no serviço, para upload dos dados.

Passo 3: Treinar um modelo de classificação local (opcional) com PyTorch/fastai

Se preferir treinar localmente antes de usar no Azure, um fluxo simples com fastai acelera o processo. Isto gera um modelo que pode ser convertido e publicado.

pip install fastai==2.7.12 torchvision pillow --quiet

from fastai.vision.all import *
path = Path('dataset')
dls = ImageDataLoaders.from_folder(path/'train', valid_pct=0.2, item_tfms=Resize(224))
learn = cnn_learner(dls, resnet18, metrics=accuracy)
learn.fine_tune(3)
learn.export('model.pkl')

Passo 4: Converter e empacotar o modelo para inferência (ONNX)

Converter para ONNX permite o deploy em vários serviços. Abaixo um exemplo mínimo de exportação para ONNX a partir de um modelo PyTorch/fastai.

import torch
from torchvision import models

# exemplo com um modelo simples do PyTorch
model = models.resnet18(pretrained=False)
model.eval()
dummy_input = torch.randn(1,3,224,224)
torch.onnx.export(model, dummy_input, 'model.onnx', opset_version=11)

Passo 5: Desencadear o modelo para inferência (Azure)

Existem várias opções: usar Azure Machine Learning para endpoints ou usar Azure Container Instances com um serviço que serve ONNX. Para simplicidade, mostraremos como fazer inferência direta com o serviço Azure AI Vision para deteção/classificação quando disponível (API de análise/assessment) ou chamar um endpoint de modelo alojado.

# Exemplo de chamada HTTP simples para um endpoint de inferência básico
import requests

endpoint = 'https://.cognitiveservices.azure.com/vision/models//analyze'
key = ''
image_path = 'dataset/validation/defeito/img101.jpg'
with open(image_path, 'rb') as f:
    img_data = f.read()

headers = {'Ocp-Apim-Subscription-Key': key, 'Content-Type': 'application/octet-stream'}
resp = requests.post(endpoint, headers=headers, data=img_data)
print(resp.status_code, resp.text)

Passo 6: Fazer inferência em lote e avaliar métricas

Execute a inferência em todas as imagens de validação e calcule accuracy, precision e recall para identificar pontos fracos (classes desbalanceadas, falsos positivos).

import os
from sklearn.metrics import classification_report

y_true = []
y_pred = []
for cls in ['ok','defeito']:
    folder = f'dataset/validation/{cls}'
    for fname in os.listdir(folder):
        path = os.path.join(folder, fname)
        # chamar a função que faz a request e retorna a classe predita
        pred = inferir_imagem(path)  # implemente conforme exemplo anterior
        y_true.append(cls)
        y_pred.append(pred)

print(classification_report(y_true, y_pred))

Verificar o resultado

Confirme que as previsões correspondem às etiquetas de validação. Verifique a matriz de confusão e as métricas: uma accuracy acima de 85% é um bom alvo inicial, mas depende do caso. Teste imagens novas do processo produtivo e avalie falsos negativos (muito críticos na inspeção).

Conclusão

Com Azure AI Vision e um ciclo simples de treino/inferência é possível automatizar a inspeção visual industrial. Próximos passos: melhorar os dados (aumentos, mais imagens), testar Azure Machine Learning para deploy gerido e monitorizar a deriva. Dica: comece por verificar classes desbalanceadas e aumente imagens sinteticamente antes de complicar o modelo — que problema de inspeção pretende resolver primeiro?