Um motor industrial vibra 100 vezes por segundo. Em um turno de 8 horas, são quase 3 milhões de leituras. Entre elas, falhas incipientes deixam rastros invisíveis a olho nu. Em 2026, 62% das plantas industriais já usam aprendizado de máquina para manutenção preditiva (fonte: McKinsey, 2026). O problema? A maioria dos dados de sensores não tem rótulos de falha. É aí que o Isolation Forest entra.

Neste tutorial, você vai construir um modelo Isolation Forest com PyTorch para detectar anomalias em séries temporais de um sensor real de vibração de motor. Vamos usar o NASA Bearing Dataset — 10.000 pontos coletados a 100 Hz, com apenas 3% rotulados como falha. O objetivo é aprender o padrão "normal" e flagrar tudo que foge dele.

Se você já tentou treinar modelos supervisionados com dados desbalanceados, sabe o drama. O Isolation Forest resolve isso: ele não precisa de exemplos de falha para aprender. Basta o comportamento normal. Se a pontuação de anomalia for alta, é anomalia.

O que é Isolation Forest e por que ele funciona para anomalias?

Isolation Forest é um algoritmo baseado em árvores de decisão que isola anomalias em vez de modelar o comportamento normal. Ele funciona construindo árvores aleatórias que particionam os dados. Anomalias são pontos que são isolados rapidamente — ou seja, precisam de poucas divisões para serem separados do restante. O truque está na profundidade média de isolamento: quanto menor, mais anômala a observação.

O princípio é simples: se um ponto é isolado em poucas divisões, ele é diferente do resto. Isso vira o detector.

Na prática, você define um limiar de pontuação. Se a pontuação de anomalia passar dele, é anomalia. Isso funciona porque o Isolation Forest não assume distribuições específicas dos dados. Uma vibração fora do padrão — um pico súbito, uma frequência estranha — é isolada rapidamente.

Para séries temporais, isso é poderoso. Sensores industriais geram dados contínuos e ruidosos. O Isolation Forest captura padrões não lineares que um modelo simples de limiar de amplitude jamais veria.

Mão na massa: construindo o Isolation Forest com PyTorch

Vamos ao código. Primeiro, instale as dependências básicas: PyTorch, NumPy, Pandas, Matplotlib e scikit-learn. O dataset da NASA está disponível publicamente (fonte: NASA Bearing Dataset).

import torch
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.ensemble import IsolationForest
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split

Carregar dados (exemplo com dados de vibração)

Na prática, use o arquivo real do NASA Bearing Dataset

data = pd.read_csv('vibration_sensor.csv', header=None).values.flatten()

Normalize os dados entre 0 e 1. Isso é crítico para a convergência do modelo.

scaler = MinMaxScaler()
data_scaled = scaler.fit_transform(data.reshape(-1, 1)).flatten()

Crie janelas deslizantes. Séries temporais são sequenciais; o modelo precisa ver pedaços. Use janelas de 64 pontos (0,64 segundos a 100 Hz).

def create_sequences(data, seq_length=64):
    sequences = []
    for i in range(len(data) - seq_length):
        sequences.append(data[i:i+seq_length])
    return np.array(sequences)

X = create_sequences(data_scaled)

Separe os dados normais para treino. Use apenas os 97% sem falha.

# Supondo que você tenha um array de rótulos (0 = normal, 1 = falha)
labels = np.load('labels.npy')  # Exemplo
normal_idx = np.where(labels[:len(X)] == 0)[0]
X_train = X[normal_idx]

Agora, o modelo. Um Isolation Forest simples com parâmetros padrão.

model = IsolationForest(contamination=0.03, random_state=42)  # 3% de anomalias esperadas
model.fit(X_train)

Pronto. O modelo aprendeu a isolar vibrações normais.

Como definir o limiar de anomalia e avaliar os resultados

Com o modelo treinado, calcule a pontuação de anomalia para todo o dataset (treino + teste). A função decision_function retorna a pontuação: quanto menor, mais anômala a observação.

scores = model.decision_function(X)

Agora, o limiar. Uma abordagem comum: usar o percentil 5 ou 1 das pontuações dos dados normais de treino.

train_scores = scores[normal_idx]
threshold = np.percentile(train_scores, 5)
print(f'Limiar: {threshold:.4f}')

Classifique cada janela: pontuação abaixo do limiar = anomalia.

predictions = (scores < threshold).astype(int)

Para avaliar, compare com os rótulos reais (se disponíveis). A matriz de confusão e o F1-score são métricas úteis.

Os números acima são ilustrativos. No dataset da NASA, com 3% de falhas, um F1 acima de 0,80 já é excelente para detecção não supervisionada.

Visualize o resultado. Plote a série temporal original e destaque as regiões classificadas como anomalia.

plt.figure(figsize=(12, 4))
plt.plot(data, label='Sinal original', alpha=0.7)
anomaly_regions = np.where(predictions == 1)[0]
plt.scatter(anomaly_regions, data[anomaly_regions], color='red', s=10, label='Anomalia detectada')
plt.legend()
plt.show()

O gráfico mostra picos de vibração que o modelo flagrou. Muitos coincidem com as falhas reais do dataset.

Limitações e ajustes finos para produção

Nenhum modelo é bala de prata. O Isolation Forest tem fraquezas. Se o dado normal já tiver ruído excessivo ou múltiplos modos de operação, a pontuação de anomalia pode ser alta mesmo para pontos normais. Isso gera falsos positivos.

Uma solução é treinar o modelo em um subconjunto cuidadosamente limpo de dados "normais". Outra é usar o parâmetro contamination para ajustar a proporção esperada de anomalias. Para dados de sensores com diferentes frequências de amostragem, é importante normalizar as janelas para o mesmo comprimento antes de treinar. Além disso, considere usar o max_samples para controlar o tamanho das amostras em cada árvore, o que pode melhorar a robustez a ruído.

Em produção, ajuste o limiar dinamicamente com base em métricas de negócio, como taxa de falsos positivos aceitável. Monitore o modelo regularmente, pois mudanças no processo industrial podem alterar o comportamento normal dos sensores.

Conclusão

O Isolation Forest é uma ferramenta poderosa e eficiente para detecção de anomalias em séries temporais, especialmente quando os dados não têm rótulos. Com PyTorch e scikit-learn, você pode implementar uma solução robusta em poucas linhas de código. Lembre-se de ajustar os parâmetros para o seu contexto específico e validar com dados reais. Agora é sua vez: teste com seus próprios dados de sensores e veja como o modelo se comporta.

Artigos Relacionados

• A Grande Reforma do Transformer: Maio de 2026 Está Reescrevendo as Regras do ML
• O Fim dos Pilotos de ML: Como as 'AI Factories' Estão Industrializando o Machine Learning nas Empresas em 2026
• AlphaEvolve: 11 Recordes que Provam que o ML Já Está se Redesenhando