Disk Failure Prediction using SMART Data and Random Forest (Backblaze)

Hard drives rarely fail without leaving traces — SMART telemetry records reallocated sectors, uncorrectable errors and pending sectors long before a drive dies. Yet most users and small teams only look at this data after a failure, because reading dozens of raw attributes per drive every day is tedious and the relationship between any single counter and failure is noisy. Backblaze has published quarterly drive-stats snapshots from its datacenter fleet since 2013, including daily SMART readings and failure labels — the industry's largest public reliability dataset — and it is exactly the kind of real, imbalanced, messy data that separates textbook ML from applied ML. This project turns that data into a working failure-prediction pipeline: SMART CSVs are cleaned and featurized, a Random Forest binary classifier learns the failure signatures, and a dashboard ranks drives by predicted failure probability with configurable alert thresholds. There is no invented accuracy here — the model is evaluated with precision, recall, F1 and ROC-AUC, the metrics that actually matter when only ~1.5% of drives fail.

1. Backblaze-format CSV snapshots (daily SMART readings + a failure label column) are loaded and aligned; failure labels are propagated so each drive-day is a labeled training example.
2. Rows are cleaned: drives with insufficient history are dropped, zero-filled attributes from manufacturers that do not report them are handled, and SMART 5/187/188/197/198, power-on hours and temperature are selected as features.
3. The data is split by drive (not by row) into train and hold-out test sets, so the model is evaluated on drives it has never seen — an 80/20 split by drive identity.
4. Class imbalance (~1.5% failures) is addressed with class-weighted Random Forest training and an appropriate decision threshold, documented in the report.
5. A Random Forest classifier (configurable tree count and depth, documented defaults) is trained on the training set; feature importances are recorded.
6. The hold-out set is scored once: precision, recall, F1 and ROC-AUC are computed, with a confusion matrix showing exactly how many failures were caught vs missed.
7. For inference, the same pipeline reads a fresh SMART snapshot CSV and emits per-drive failure probabilities into the risk dashboard with threshold alerts.

Tech stack:

• Python 3, pandas, NumPy
• scikit-learn (Random Forest, train/test split, metrics)
• Jupyter Notebook (training & evaluation)
• Matplotlib, seaborn (evaluation plots)
• HTML/CSS/JavaScript dashboard (risk scoring UI)
• Backblaze Drive Stats dataset (public quarterly release)

Dataset & model details

• Dataset: Backblaze Drive Stats — daily hard-drive health snapshots from Backblaze's datacenter fleet, published quarterly since 2013, hundreds of thousands of drives (reported at 350,000+ in 2026). Free to download from Backblaze's Drive Stats page. Columns: date, serial number, drive model, failure flag, and raw/normalized SMART attribute readings per drive-day. Failures are rare (~1.5% annualized failure rate), making this an imbalanced binary classification problem.
• Task: Binary classification (failed vs healthy); input = one drive-day feature vector (SMART 5 Reallocated Sectors Count, 187 Reported Uncorrectable Errors, 188 Command Timeout, 197 Current Pending Sector Count, 198 Uncorrectable Sector Count, power-on hours, temperature); output = failure probability.
• Model: Random Forest classifier with class weights to handle imbalance; inputs are per-drive feature vectors, predictions are failure probabilities; decision threshold is configurable and its precision–recall trade-off is analyzed in the report.
• Metrics: ROC-AUC (design target ~0.88), F1-score, precision and recall at the chosen threshold, confusion matrix on the hold-out set. Design targets only — the report documents the actual achieved figures after the training run for the order. No accuracy is claimed as measured until the model is trained.

• [SMART CSV ingestion] Parses Backblaze-format daily drive-stat CSVs, handling the published schema (date, serial, model, failure flag, raw SMART attribute columns) including missing or zero-filled attributes from different manufacturers.
• [Failure-probability classifier] A trained Random Forest binary classifier (failed vs healthy) using SMART 5, 187, 188, 197, 198 plus power-on hours and drive temperature as features.
• [Per-drive risk scoring] Every drive gets a failure probability between 0 and 1 from the trained model, with the risk band (low / medium / high) shown alongside the score.
• [At-risk drive ranking] The fleet dashboard sorts and filters drives by predicted failure probability, SMART counters and drive model, with click-through per-drive detail.
• [Configurable threshold alerts] The alert threshold is adjustable; every drive above it is listed with its SMART counters and probability, illustrating the precision–recall trade-off of threshold choice.
• [Feature-importance view] Mean-decrease-in-impurity importances from the trained forest, showing which SMART attributes drive the predictions.
• [Evaluation report] Precision, recall, F1-score and ROC-AUC on a hold-out test set with a confusion matrix, written up with the class-imbalance analysis a viva expects.

• Complete data-cleaning and training Jupyter notebook
• Trained Random Forest model file with the preprocessing pipeline
• Risk-scoring dashboard web app wired to the trained model
• Evaluation report with precision, recall, F1, ROC-AUC and confusion matrix
• Project report PDF (background, dataset analysis, methodology, results)
• PPT presentation for final review
• Viva Q&A preparation document (class imbalance, SMART attributes, Random Forest internals, threshold trade-offs)