Upload README.md

README.md

@@ -0,0 +1,53 @@
+---
+license: mit
+tags:
+  - cbc-reference-model
+  - mlops-100-day
+  - predictive-maintenance
+  - pytorch
+  - lstm
+---
+
+# CBC Reference Model: Turbofan Remaining Useful Life (C-MAPSS FD001)
+
+> Pre-trained reference model for the **CBC [MLOps 100-Day Track](https://github.com/careerbytecode/cbc-learning-hub/tree/main/100-days/mlops)** (Capstone 4). Published twin of ML Development Capstone 4. **This is the one deep-learning reference model** — it ships as a torch `state_dict` + `model.py`, NOT a single joblib.
+
+## Model details
+- **Type:** single-layer LSTM (hidden 64) over a 30-cycle window of 15 normalized sensors -> scalar RUL (capped at 125).
+- **Framework:** pytorch 2.12.0+cpu · **Serialization:** `manufacturing_lstm.pt` (state_dict) + `manufacturing_meta.joblib` (normalization + arch). Reconstruct with the shipped `model.py`.
+- The LSTM is the rare counterpoint to the classical models: run-to-failure multivariate sensor sequences are the data shape deep learning is for. It beats an XGBoost baseline (RMSE 18.45) overall and decisively near failure.
+
+## Intended use
+Decision-support estimate of operational cycles remaining, to prioritize inspection/maintenance. NOT an automated ground-or-fly authority. Teaching/reference artifact.
+
+## Training data
+NASA C-MAPSS FD001 (100 train + 100 test run-to-failure engines, single operating condition). 15 non-flat sensors used. Simulated, no PII. NASA Open Data (public domain).
+
+## Metrics (test = last cycle of each test engine vs RUL_FD001, scored once)
+| Model | Test RMSE | Near-failure RUL[0,50) |
+|---|---|---|
+| XGBoost baseline | 18.45 | — |
+| **LSTM (deployed)** | **14.88** | **4.78** |
+
+The LSTM wins overall and is decisively better in the operationally critical near-failure band.
+
+## How to load and predict
+```python
+from huggingface_hub import snapshot_download
+import sys, json
+d = snapshot_download("careerbytecode/mlops-ref-manufacturing-rul")
+sys.path.insert(0, d + "/model"); sys.path.insert(0, d)
+from model import load_model, predict_rul       # needs torch installed
+model, meta = load_model(d + "/model")
+sample = json.load(open(d + "/sample_input.json"))
+print(predict_rul(model, meta, sample["window"]))  # predicted RUL (cycles)
+```
+**Serving requires `torch`** and the shipped `model.py` (the class definition) — a joblib load alone will not work.
+
+## Limitations
+- Trained on FD001 (one operating condition); FD002/FD004 (six conditions) need condition-aware normalization.
+- RUL capped at 125: cannot distinguish a very-healthy from a merely-healthy engine, by design.
+- Needs the full 30-cycle window + the training normalization stats to serve; a single reading is not enough. Simulated data — expect drift on real telemetry. Reference/teaching artifact only.
+
+---
+© 2015-2026 CareerByteCode. All rights reserved. | CC BY-NC-SA 4.0 (docs), MIT (code) | Authored by Raghavendra R, Platform Owner CareerByteCode, Solution Architect