Cómo detectar averías en máquinas con Azure ML y sensores IoT: paso a paso

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

Este tutorial muestra cómo detectar averías en máquinas usando Azure AI & Machine Learning y datos de sensores IoT. La tarea es útil para mantenimiento predictivo: predecir averías antes de que ocurran reduce costes y tiempos de parada.

Requisitos previos

Cuenta Azure con permisos para crear recursos (Resource Group, Storage, Machine Learning workspace).
Azure Machine Learning workspace creado.
Conjunto de datos de sensores IoT (CSV) con marcas temporales, lecturas y etiqueta de avería (0/1) o ventana de avería.
Python 3.8+ local con bibliotecas: pandas, scikit-learn, azure-ai-ml (opcional para deploy).

Paso 1: Preparar datos de sensores y comprender el objetivo

El objetivo es transformar series temporales de múltiples sensores por máquina en features que permitan predecir una avería (clasificación binaria). Empiece por cargar los datos, explorar missing values y garantizar una etiqueta clara: por ejemplo, la variable "failure" = 1 en las ventanas de 24 horas antes de la avería.

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

Paso 2: Crear features temporales y agregadas

Las máquinas generan series: en lugar de usar cada punto, agregue por ventana (ej.: 1 hora) por máquina. Calcule media, desviación estándar, máximo, mínimo y tendencia (slope) para cada sensor. Estas features son más estables para modelos tradicionales como RandomForest.

import numpy as np
# Agrupar por ventana 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)

Paso 3: Dividir entrenamiento/validación y tratar el desequilibrio

Separar conjuntos garantizando que máquinas en el entrenamiento pueden no aparecer en la validación (evita data leak). Las averías son raras: aplicar oversampling (SMOTE) o class_weight en el 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)

Paso 4: Entrenar un modelo simple y explicar por qué

RandomForest funciona bien como baseline: maneja no linealidades y no requiere mucho tuning. Use class_weight='balanced' para tratar con clases desbalanceadas. Siempre validar con métricas adecuadas (recall, F1): en mantenimiento predictivo el recall es importante para detectar averías.

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

Paso 5: Interpretabilidad y análisis de las features

Saber qué features contribuyen más ayuda a validar el modelo y a ganar confianza. Use feature_importances_ del RandomForest o SHAP para análisis más detallados.

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

Paso 6: Preparar para deploy con Azure Machine Learning

Registre el modelo en el Azure Machine Learning workspace y cree un endpoint para predicciones en tiempo real o por lotes. El ejemplo usa azure-ai-ml para registro; la configuración de compute y del endpoint depende de su 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 y registrar
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 el resultado

Valide el rendimiento en el conjunto de validación: verifique métricas (recall, precision, F1) y la matriz de confusión. En el deploy, pruebe el endpoint con payloads de ejemplo (features agregadas) y confirme que la respuesta es plausible. Monitorice tasas de predicción y drift de las features.

Conclusión

Ha construido un flujo de mantenimiento predictivo: transformación de series temporales en features, entrenamiento de un modelo baseline, análisis de features y registro en Azure Machine Learning. Próximos pasos: experimentar con modelos de series temporales (LSTM, Transformers), pipeline de ingestión en tiempo real con IoT Hub y monitorización de drift. Consejo: empiece con ventanas y labels simples, luego refine el lead time y el balanceo según los resultados.