Como detetar avarias em máquinas com Azure ML e sensores IoT: passo a passo

João Barros 01 de September de 2026 4 min de leitura

Este tutorial mostra como detetar avarias em máquinas usando Azure AI & Machine Learning e dados de sensores IoT. A tarefa é útil para manutenção preditiva: prever avarias antes de acontecerem reduz custos e tempo de paragem.

Pré-requisitos

Conta Azure com permissões para criar recursos (Resource Group, Storage, Machine Learning workspace).
Azure Machine Learning workspace criado.
Conjunto de dados de sensores IoT (CSV) com carimbos temporais, leituras e etiqueta de avaria (0/1) ou janela de avaria.
Python 3.8+ local com bibliotecas: pandas, scikit-learn, azure-ai-ml (opcional para deploy).

Passo 1: Preparar dados de sensores e compreender o objetivo

O objetivo é transformar séries temporais de múltiplos sensores por máquina em features que permitam prever uma avaria (classificação binária). Comece por carregar os dados, explorar missing values e garantir um rótulo claro: por exemplo, a variável "failure" = 1 nas janelas de 24 horas antes da avaria.

import pandas as pd
df = pd.read_csv('sensores.csv', parse_dates=['timestamp'])
# Exemplo de colunas: timestamp, machine_id, temp, vibration, pressure, failure
print(df.head())
print(df.isna().sum())

Passo 2: Criar features temporais e agregadas

Máquinas produzem séries: em vez de usar cada ponto, agregue por janela (ex.: 1 hora) por máquina. Calcule média, desvio-padrão, máximo, mínimo e tendência (slope) para cada sensor. Estas features são mais estáveis para modelos tradicionais como RandomForest.

import numpy as np
# Agrupar por janela de 1h
df = df.set_index('timestamp')
window = '1H'
agg = df.groupby('machine_id').resample(window).agg({
    'temp':['mean','std','min','max'],
    'vibration':['mean','std','min','max'],
    'pressure':['mean','std']
})
agg.columns = ['_'.join(col).strip() for col in agg.columns.values]
agg = agg.reset_index()
# Juntar label: se existir uma avaria nas próximas 24h
agg['failure_label'] = 0
# Aqui simplificamos: se algum failure==1 na próxima janela de 24h -> label=1
# Implementação real requer janelas deslocadas (lead time)

Passo 3: Dividir treino/validação e tratar o desequilíbrio

Separar conjuntos garantindo que máquinas no treino podem não aparecer na validação (evita data leak). Avarias são raras: aplicar oversampling (SMOTE) ou class_weight no modelo.

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
X = agg.drop(['machine_id','timestamp','failure_label'], axis=1)
y = agg['failure_label']
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)

Passo 4: Treinar um modelo simples e explicar porquê

RandomForest funciona bem como baseline: lida com não linearidades e não requer muito tuning. Use class_weight='balanced' para lidar com classes desbalanceadas. Sempre validar com métricas adequadas (recall, F1) — em manutenção preditiva o recall é importante para detectar avarias.

from sklearn.metrics import classification_report, confusion_matrix
model = RandomForestClassifier(n_estimators=100, class_weight='balanced', random_state=42)
model.fit(X_train.fillna(0), y_train)
pred = model.predict(X_val.fillna(0))
print(classification_report(y_val, pred))
print(confusion_matrix(y_val, pred))

Passo 5: Interpretabilidade e análise das features

Saber quais features mais contribuem ajuda a validar o modelo e a ganhar confiança. Use feature_importances_ do RandomForest ou SHAP para análises mais detalhadas.

importances = model.feature_importances_
feat_names = X_train.columns
imp_df = pd.DataFrame({'feature':feat_names,'importance':importances}).sort_values('importance',ascending=False)
print(imp_df.head(10))

Passo 6: Preparar para deploy com Azure Machine Learning

Registe o modelo no Azure Machine Learning workspace e crie um endpoint para previsões em tempo real ou batch. O exemplo usa azure-ai-ml para registo; a configuração de compute e do endpoint depende do seu workspace.

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential
from azure.ai.ml.entities import Model

credential = DefaultAzureCredential()
ml_client = MLClient(credential, subscription_id='SUA_SUBSCRIPTION', resource_group_name='RG', workspace_name='MLWorkspace')

# Guardar modelo localmente e registar
import joblib
joblib.dump(model, 'rf_model.joblib')
model_entity = Model(path='rf_model.joblib', name='rf_predictive_maintenance')
ml_client.models.create_or_update(model_entity)

Verificar o resultado

Valide a performance no conjunto de validação: verifique métricas (recall, precision, F1) e a matriz de confusão. No deploy, teste o endpoint com payloads de exemplo (features agregadas) e confirme que a resposta é plausível. Monitorize taxas de predição e drift das features.

Conclusão

Construiu um fluxo de manutenção preditiva: transformação de séries temporais em features, treino de um modelo baseline, análise de features e registo no Azure Machine Learning. Próximos passos: experimentar modelos de séries temporais (LSTM, Transformers), pipeline de ingestão em tempo real com IoT Hub e monitorização de drift. Dica: comece com janelas e labels simples, depois refine o lead time e o balanceamento conforme os resultados.