An industrial motor vibrates 100 times per second. Over an 8-hour shift, that's nearly 3 million readings. Among them, incipient failures leave traces invisible to the naked eye. By 2026, 62% of industrial plants already use machine learning for predictive maintenance (source: McKinsey, 2026). The problem? Most sensor data lacks failure labels. That's where Isolation Forest comes in.

In this tutorial, you will build an Isolation Forest model with PyTorch to detect anomalies in time series from a real motor vibration sensor. We'll use the NASA Bearing Dataset — 10,000 points collected at 100 Hz, with only 3% labeled as failure. The goal is to learn the "normal" pattern and flag anything that deviates from it.

If you've ever tried training supervised models with imbalanced data, you know the struggle. Isolation Forest solves this: it doesn't need failure examples to learn. Normal behavior is enough. If the anomaly score is high, it's an anomaly.

What is Isolation Forest and why does it work for anomalies?

Isolation Forest is a tree-based algorithm that isolates anomalies instead of modeling normal behavior. It works by building random trees that partition the data. Anomalies are points that are isolated quickly — meaning they need few splits to be separated from the rest. The trick lies in the average isolation depth: the smaller it is, the more anomalous the observation.

The principle is simple: if a point is isolated in few splits, it's different from the rest. This becomes the detector.

In practice, you define a score threshold. If the anomaly score exceeds it, it's an anomaly. This works because Isolation Forest does not assume specific data distributions. An out-of-pattern vibration — a sudden spike, a strange frequency — is isolated quickly.

For time series, this is powerful. Industrial sensors generate continuous, noisy data. Isolation Forest captures non-linear patterns that a simple amplitude threshold model would never see.

Hands-on: building the Isolation Forest with PyTorch

Let's get to the code. First, install the basic dependencies: PyTorch, NumPy, Pandas, Matplotlib, and scikit-learn. The NASA dataset is publicly available (source: 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

Load data (example with vibration data)

In practice, use the actual file from the NASA Bearing Dataset

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

Normalize the data between 0 and 1. This is critical for model convergence.

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

Create sliding windows. Time series are sequential; the model needs to see chunks. Use windows of 64 points (0.64 seconds at 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)

Separate normal data for training. Use only the 97% without failure.

# Assuming you have an array of labels (0 = normal, 1 = failure)
labels = np.load('labels.npy')  # Example
normal_idx = np.where(labels[:len(X)] == 0)[0]
X_train = X[normal_idx]

Now, the model. A simple Isolation Forest with default parameters.

model = IsolationForest(contamination=0.03, random_state=42)  # 3% expected anomalies
model.fit(X_train)

Done. The model learned to isolate normal vibrations.

How to define the anomaly threshold and evaluate results

With the trained model, calculate the anomaly score for the entire dataset (training + test). The decision_function returns the score: the lower it is, the more anomalous the observation.

scores = model.decision_function(X)

Now, the threshold. A common approach: use the 5th or 1st percentile of the training normal data scores.

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

Classify each window: score below threshold = anomaly.

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

To evaluate, compare with the actual labels (if available). The confusion matrix and F1-score are useful metrics.

The numbers above are illustrative. On the NASA dataset, with 3% failures, an F1 above 0.80 is already excellent for unsupervised detection.

Visualize the result. Plot the original time series and highlight the regions classified as anomalies.

plt.figure(figsize=(12, 4))
plt.plot(data, label='Original signal', alpha=0.7)
anomaly_regions = np.where(predictions == 1)[0]
plt.scatter(anomaly_regions, data[anomaly_regions], color='red', s=10, label='Detected anomaly')
plt.legend()
plt.show()

The graph shows vibration spikes flagged by the model. Many coincide with the actual failures in the dataset.

Limitations and fine-tuning for production

No model is a silver bullet. Isolation Forest has weaknesses. If the normal data already has excessive noise or multiple operating modes, the anomaly score can be high even for normal points. This generates false positives.

One solution is to train the model on a carefully cleaned subset of "normal" data. Another is to use the contamination parameter to adjust the expected proportion of anomalies. For sensor data with different sampling frequencies, it's important to normalize the windows to the same length before training. Additionally, consider using max_samples to control the sample size in each tree, which can improve robustness to noise.

In production, adjust the threshold dynamically based on business metrics, such as an acceptable false positive rate. Monitor the model regularly, as changes in the industrial process can alter the normal behavior of the sensors.

Conclusion

Isolation Forest is a powerful and efficient tool for anomaly detection in time series, especially when data lacks labels. With PyTorch and scikit-learn, you can implement a robust solution in just a few lines of code. Remember to adjust the parameters for your specific context and validate with real data. Now it's your turn: test it with your own sensor data and see how the model performs.

Related Articles

• The Great Transformer Reform: May 2026 is Rewriting the Rules of ML
• The End of ML Pilots: How 'AI Factories' Are Industrializing Machine Learning in Companies in 2026
• AlphaEvolve: 11 Records Proving ML is Already Redesigning Itself