Development of AI System for Equipment Failure Prediction
Unexpected compressor failure at 3 AM—unplanned downtime, millions in losses, disrupted deliveries. Traditional threshold monitoring detects deviation only after the limits are exceeded, when repair is inevitable. A Failure Prediction system builds a temporal degradation model and warns 7–30 days in advance, capturing hidden patterns in sensor time series and calculating remaining useful life (RUL).
We develop such systems turnkey: from data collection and labeling to integration with CMMS and automatic maintenance scheduling. The foundation is degradation models, RUL estimation, and machine learning with probability calibration to ensure alerts are accurate, not noise.
What Problems We Solve
Class imbalance. Typical ratio: 1 failure per 50–200 days of normal operation. Without special methods, the model predicts "all is well," ignoring rare events. We use weighted loss functions (scale_pos_weight in XGBoost), synthetic augmentation (SMOTE-Tomek), and cost-sensitive learning with a matrix where missing a failure costs 20 times more than a false alarm.
Choice of prediction horizon. Too short a horizon (1–3 days) leaves no time for reaction; too long (60+ days) introduces high uncertainty. We select the horizon via ROC analysis on historical data: typically 7–30 days is optimal for industrial equipment.
Probability calibration. XGBoost and neural networks often output uncalibrated probabilities. The model might say "70% failure probability," but in reality, a failure occurs only in 30% of such cases. We apply Isotonic Regression (Platt Scaling less often) on a hold-out set—this reduces false alarm rate by 30–50%.
How We Build a Failure Prediction System
Degradation Model and RUL Estimator
We model the deterioration process through regression on days_to_failure or survival analysis. The key technique is to train the model only on a 90-day window before failure, excluding long periods of normal operation.
import pandas as pd
import numpy as np
from sklearn.model_selection import TimeSeriesSplit
from xgboost import XGBRegressor
def train_rul_model(features_df, target_col='days_to_failure'):
train_data = features_df[features_df[target_col] <= 90].dropna(subset=[target_col])
X = train_data.drop(columns=[target_col, 'label', 'timestamp', 'asset_id'])
y = np.log1p(train_data[target_col])
tscv = TimeSeriesSplit(n_splits=5)
model = XGBRegressor(n_estimators=300, learning_rate=0.05, max_depth=6, subsample=0.8)
model.fit(X, y)
return model
For censored data (asset still operating), we use Weibull AFT from the lifelines library—it correctly handles such cases and provides interval predictions.
Multi-Task LSTM with Attention
When enough history is accumulated (10+ cycles per asset), we move to LSTM. A single model simultaneously predicts RUL, failure probability on horizons 7/14/30 days, and degradation stage (normal, onset, progressive, critical). For LSTM failure prediction, we use an architecture with an attention mechanism.
import torch.nn as nn
class FailurePredictionLSTM(nn.Module):
def __init__(self, input_dim, hidden_dim=128, num_layers=2):
super().__init__()
self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers,
batch_first=True, dropout=0.2)
self.attention = nn.MultiheadAttention(hidden_dim, num_heads=4, batch_first=True)
self.rul_head = nn.Sequential(nn.Linear(hidden_dim, 64), nn.ReLU(), nn.Linear(64, 1))
self.failure_head = nn.Sequential(nn.Linear(hidden_dim, 64), nn.ReLU(), nn.Linear(64, 3), nn.Sigmoid())
self.stage_head = nn.Linear(hidden_dim, 4)
def forward(self, x):
lstm_out, _ = self.lstm(x)
attn_out, _ = self.attention(lstm_out, lstm_out, lstm_out)
pooled = attn_out.mean(dim=1)
return {'rul': self.rul_head(pooled),
'failure_prob': self.failure_head(pooled),
'stage': self.stage_head(pooled)}
When comparing XGBoost and LSTM for failure prediction, each has trade-offs. XGBoost with time windows gives Precision@7 = 0.75–0.85, LSTM gives 0.80–0.90, but requires 3–5 times more data. XGBoost is 5 times faster to train than LSTM, making it preferable for the start. We deploy LSTM in the second phase when enough history is accumulated.
The Critical Importance of Probability Calibration
Uncalibrated probabilities lead to an avalanche of false alarms or missed failures. Below is the final calibration via Isotonic Regression:
from sklearn.isotonic import IsotonicRegression
def calibrate_probabilities(raw_probs, true_labels):
calibrator = IsotonicRegression(out_of_bounds='clip')
calibrator.fit(raw_probs, true_labels)
return calibrator
In a real compressor station project, calibration reduced the false alarm rate from 12 to 4 events per asset per month—a 3 times improvement—and coverage (proportion of predicted failures) increased from 60% to 87%. The customer saved $15,000 in the first year by reducing unplanned downtime. On average, across our projects, savings amount to about ₽1.5 million per year per critical asset (equivalent to $20,000).
Choosing the Decision Threshold
We account for error costs: missed failure costs 100 arbitrary units, unnecessary inspection costs 5. The threshold shifts downward, making the model more sensitive. The optimal threshold is found on validation by minimizing total cost. For example, with cost_fn=100 and cost_fp=5, the optimal threshold minimizes total cost, leading to average savings of $25,000 per year per asset.
def find_optimal_threshold(probs, labels, cost_fn=100, cost_fp=5):
thresholds = np.arange(0.05, 0.95, 0.01)
best = 0.5
min_cost = float('inf')
for t in thresholds:
preds = (probs >= t).astype(int)
total = np.sum((preds == 0) & (labels == 1)) * cost_fn + np.sum((preds == 1) & (labels == 0)) * cost_fp
if total < min_cost:
min_cost = total
best = t
return best
Deployment Process
- Data analysis: label failures, build time windows—dataset with labels and features.
- Baseline: XGBoost Failure Classifier + basic RUL—accuracy 70–80%.
- Improvement: LSTM, calibration, threshold optimization—accuracy 85–95%.
- Integration: Webhook to CMMS, alert dashboard—automatic maintenance scheduling.
- Monitoring: Drift detection, retraining—system runs stably.
| Stage | What we do | Result |
|---|---|---|
| 1. Data analysis | Label failure history, build time windows | Dataset with labels and features |
| 2. Baseline | XGBoost Failure Classifier + basic RUL | Accuracy 70–80% |
| 3. Improvement | LSTM, calibration, threshold optimization | Accuracy 85–95% |
| 4. Integration | Webhook to CMMS, alert dashboard | Automatic maintenance scheduling |
| 5. Monitoring | Drift detection, retraining | System runs stably |
Comparison of Prediction Methods
| Parameter | XGBoost | LSTM | Survival Analysis |
|---|---|---|---|
| Precision@7 | 0.75–0.85 | 0.80–0.90 | 0.65–0.75 |
| Data requirements | 3–6 cycles | 10+ cycles | 20+ cycles |
| Training speed | 5–15 min | 1–4 hours | 10–30 min |
| Noise robustness | Medium | High | Low |
Typical Mistakes in Implementation
- Using the entire history 1:1 degrades quality. Need to limit the window before failure.
- Ignoring censoring—use survival analysis instead of regression.
- Setting a single threshold for the entire fleet—tune per asset criticality.
- Forgetting calibration—leads to operator distrust.
Timeline and What You Get
- Failure Classifier + basic RUL + alerts—4–5 weeks.
- LSTM, survival analysis, full integration with maintenance scheduling—3–4 months.
The package includes: trained model, API for integration, web dashboard with alerts and metrics, documentation, team training, and 3 months of post-launch support.
Our team has 5+ years of experience in industrial machine learning, with 20+ predictive maintenance projects delivered. We serve clients in manufacturing, oil & gas, and energy. Our engineers are certified in MLflow and Kubernetes. We guarantee quality—each stage is closed with a checklist.
Contact us for a preliminary analysis of your data—we'll select an architecture and estimate potential savings (up to $30,000 per year on maintenance costs). Order a consultation to see how our approach works on your equipment.