Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,63 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+dist/
+build/
+
+# Virtual Environment
+.venv/
+venv/
+ENV/
+env/
+
+# Environment variables and secrets
+.env
+.env.local
+.env.*.local
+*.env
+secrets/
+*.key
+*.pem
+
+# MLflow
+mlruns/
+.mlflow/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+*.out
+
+# Jupyter Notebook checkpoints
+.ipynb_checkpoints/
+
+# Model files (optional - uncomment if you don't want to track large model files)
+# models/*.joblib
+# models/*.pkl
+
+# Data files (optional - uncomment if data is too large)
+# data/*.csv
+# data/processed/*.csv
+
+# Temporary files
+*.tmp
+*.bak
+*.cache
+
+# Hugging Face tokens (never commit these!)
+**/token*
+**/*token*

APP_INTERFACE_GUIDE.md

@@ -0,0 +1,182 @@
+# Streamlit App Interface Guide
+
+## 🚀 Accessing the App
+
+The Streamlit app should now be running. Open your web browser and navigate to:
+
+**http://localhost:8501**
+
+If port 8501 is busy, Streamlit will automatically use the next available port (8502, 8503, etc.). Check the terminal output for the exact URL.
+
+---
+
+## 📱 Interface Overview
+
+### **Main Page Layout**
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  🛠️ Engine Predictive Maintenance – Failure Prediction  │
+├─────────────────────────────────────────────────────────┤
+│                                                           │
+│  This app predicts whether an engine is operating        │
+│  normally (0) or requires maintenance / at risk of      │
+│  failure (1) based on real-time sensor readings.        │
+│                                                           │
+│  Adjust the sensor values below and click Predict to    │
+│  see the model's classification and the probability of   │
+│  a potential fault.                                       │
+│                                                           │
+├─────────────────────────────────────────────────────────┤
+│  Input Sensor Readings                                   │
+├─────────────────────────────────────────────────────────┤
+│                                                           │
+│  ┌─────────────────────┐  ┌─────────────────────┐     │
+│  │ Engine RPM           │  │ Coolant Pressure    │     │
+│  │ [800.0]              │  │ [2.0]               │     │
+│  │                      │  │                     │     │
+│  │ Lub Oil Pressure     │  │ Lub Oil Temperature │     │
+│  │ [3.0]                │  │ [80.0]              │     │
+│  │                      │  │                     │     │
+│  │ Fuel Pressure        │  │ Coolant Temperature │     │
+│  │ [10.0]               │  │ [80.0]              │     │
+│  └─────────────────────┘  └─────────────────────┘     │
+│                                                           │
+│              [Predict Button]                            │
+│                                                           │
+└─────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────┐
+│  Sidebar: Model Source                                   │
+├─────────────────────────────────────────────────────────┤
+│  Load model from:                                        │
+│  ○ Hugging Face Hub                                      │
+│  ● Local file                                            │
+│                                                           │
+│  Note: On Hugging Face Spaces, the model is typically   │
+│  loaded from the model hub. Locally, you can choose     │
+│  either source as long as you have run the training      │
+│  pipeline or configured your HF token.                   │
+└─────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🎯 How to Use the Interface
+
+### **Step 1: Select Model Source (Sidebar)**
+- Choose **"Local file"** if you've run `python src/train.py` locally
+- Choose **"Hugging Face Hub"** if you've uploaded the model to HF and set `HF_TOKEN`
+
+### **Step 2: Enter Sensor Values**
+
+Adjust the 6 sensor inputs:
+
+1. **Engine RPM** (0-4000)
+   - Default: 800.0
+   - Typical range: 500-2000 RPM
+
+2. **Lub Oil Pressure** (0-10 bar/kPa)
+   - Default: 3.0
+   - Typical range: 2-5 bar
+
+3. **Fuel Pressure** (0-30 bar/kPa)
+   - Default: 10.0
+   - Typical range: 5-20 bar
+
+4. **Coolant Pressure** (0-10 bar/kPa)
+   - Default: 2.0
+   - Typical range: 1-4 bar
+
+5. **Lub Oil Temperature** (0-150°C)
+   - Default: 80.0
+   - Typical range: 70-90°C
+
+6. **Coolant Temperature** (0-150°C)
+   - Default: 80.0
+   - Typical range: 70-90°C
+
+### **Step 3: Click "Predict"**
+
+After clicking the **Predict** button, you'll see one of two results:
+
+#### ✅ **Normal Operation**
+```
+✅ The engine is LIKELY OPERATING NORMALLY (probability of fault X.XX%).
+```
+
+#### 🚨 **Faulty / Requires Maintenance**
+```
+🚨 The engine is LIKELY FAULTY / REQUIRES MAINTENANCE (probability XX.XX%).
+```
+
+---
+
+## 📊 Example Predictions
+
+### **Example 1: Normal Engine**
+- Engine RPM: 1200
+- Lub Oil Pressure: 3.5
+- Fuel Pressure: 12.0
+- Coolant Pressure: 2.5
+- Lub Oil Temperature: 82.0
+- Coolant Temperature: 85.0
+- **Result**: ✅ Normal operation (low fault probability)
+
+### **Example 2: Faulty Engine**
+- Engine RPM: 400
+- Lub Oil Pressure: 1.5
+- Fuel Pressure: 5.0
+- Coolant Pressure: 1.0
+- Lub Oil Temperature: 95.0
+- Coolant Temperature: 100.0
+- **Result**: 🚨 Requires maintenance (high fault probability)
+
+---
+
+## 🔧 Troubleshooting
+
+### **App Not Loading?**
+1. Check terminal for errors
+2. Verify port 8501 is available: `lsof -ti:8501`
+3. Try a different port: `streamlit run src/app.py --server.port 8502`
+
+### **Model Not Found Error?**
+1. **For Local**: Run `python src/train.py` first to create `models/best_model.joblib`
+2. **For HF**: Set `HF_TOKEN` and `HF_MODEL_REPO` environment variables
+
+### **Import Errors?**
+1. Activate virtual environment: `source .venv/bin/activate`
+2. Install dependencies: `pip install -r requirements.txt`
+
+---
+
+## 🎨 Interface Features
+
+- **Clean, centered layout** for easy input
+- **Two-column form** for organized sensor inputs
+- **Real-time prediction** with probability scores
+- **Color-coded results**: Green for normal, Red for faulty
+- **Sidebar model selection** for flexibility
+- **Responsive design** that works on different screen sizes
+
+---
+
+## 📸 Screenshots for Your Report
+
+When documenting this in your final report, you can:
+1. Take a screenshot of the input form
+2. Take a screenshot showing a "Normal" prediction
+3. Take a screenshot showing a "Faulty" prediction
+4. Include the URL: `http://localhost:8501` (or your deployed HF Space URL)
+
+---
+
+## 🚀 Next Steps
+
+1. **Test the app locally** with different sensor values
+2. **Deploy to Hugging Face Space** using `python src/deploy_to_hf.py`
+3. **Include screenshots** in your final report/notebook
+4. **Document the interface** in your submission
+
+The app is ready to use! 🎉

CONFIGURATION_GUIDE.md

@@ -0,0 +1,153 @@
+# Configuration Guide: Hugging Face & GitHub Setup
+
+This guide shows you exactly where to configure your Hugging Face Space details and GitHub repository information.
+
+---
+
+## 1. Hugging Face Configuration
+
+### Option A: Update `src/config.py` (Recommended for Local Testing)
+
+Edit `/Users/ananttripathi/Desktop/mlops/src/config.py` and replace the placeholder values:
+
+```python
+# Lines 58-62 in src/config.py
+HF_DATASET_REPO = os.getenv(
+    "HF_DATASET_REPO", "your-username/engine-maintenance-dataset"  # <-- Replace "your-username"
+)
+HF_MODEL_REPO = os.getenv("HF_MODEL_REPO", "your-username/engine-maintenance-model")  # <-- Replace
+HF_SPACE_REPO = os.getenv("HF_SPACE_REPO", "your-username/engine-maintenance-space")  # <-- Replace
+```
+
+**Example** (HF username: `ananttripathiak`, GitHub username: `ananttripathi`):
+```python
+HF_DATASET_REPO = os.getenv(
+    "HF_DATASET_REPO", "ananttripathiak/engine-maintenance-dataset"
+)
+HF_MODEL_REPO = os.getenv("HF_MODEL_REPO", "ananttripathiak/engine-maintenance-model")
+HF_SPACE_REPO = os.getenv("HF_SPACE_REPO", "ananttripathiak/engine-maintenance-space")
+```
+
+### Option B: Set Environment Variables (For Local Testing)
+
+Instead of editing `config.py`, you can export these in your terminal:
+
+```bash
+export HF_TOKEN="hf_your_token_here"
+export HF_DATASET_REPO="your-username/engine-maintenance-dataset"
+export HF_MODEL_REPO="your-username/engine-maintenance-model"
+export HF_SPACE_REPO="your-username/engine-maintenance-space"
+```
+
+---
+
+## 2. GitHub Repository Configuration
+
+### A. GitHub Secrets (Required for GitHub Actions)
+
+Go to your GitHub repository → **Settings** → **Secrets and variables** → **Actions** → **New repository secret**
+
+Add these 4 secrets:
+
+1. **`HF_TOKEN`**
+   - Value: Your Hugging Face access token (get it from https://huggingface.co/settings/tokens)
+   - Example: `hf_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`
+
+2. **`HF_DATASET_REPO`**
+   - Value: Your Hugging Face dataset repo ID
+   - Example: `ananttripathiak/engine-maintenance-dataset`
+
+3. **`HF_MODEL_REPO`**
+   - Value: Your Hugging Face model repo ID
+   - Example: `ananttripathiak/engine-maintenance-model`
+
+4. **`HF_SPACE_REPO`**
+   - Value: Your Hugging Face Space repo ID
+   - Example: `ananttripathiak/engine-maintenance-space`
+
+**Note:** The GitHub Actions workflow (`.github/workflows/pipeline.yml`) automatically reads these secrets. No code changes needed!
+
+### B. Update README.md with Your GitHub Repo URL
+
+Edit `/Users/ananttripathi/Desktop/mlops/README.md` and add your GitHub repository link:
+
+```markdown
+## GitHub Repository
+
+- **Repository URL**: https://github.com/your-username/engine-predictive-maintenance
+- **GitHub Actions**: https://github.com/your-username/engine-predictive-maintenance/actions
+```
+
+---
+
+## 3. Quick Setup Checklist
+
+- [ ] **Hugging Face Account**: Create account at https://huggingface.co
+- [ ] **HF Access Token**: Generate at https://huggingface.co/settings/tokens (needs `write` permission)
+- [ ] **Update `src/config.py`**: Replace `"username"` with your actual HF username
+- [ ] **Create HF Repos** (optional - scripts will create them automatically):
+  - Dataset repo: `your-username/engine-maintenance-dataset`
+  - Model repo: `your-username/engine-maintenance-model`
+  - Space repo: `your-username/engine-maintenance-space`
+- [ ] **GitHub Repository**: Create a new repo and push this `mlops` folder
+- [ ] **GitHub Secrets**: Add the 4 secrets listed above in your GitHub repo settings
+- [ ] **Test Locally**: Run `python src/data_register.py` to verify HF connection
+
+---
+
+## 4. Testing Your Configuration
+
+### Test Local Configuration
+
+```bash
+cd /Users/ananttripathi/Desktop/mlops
+source .venv/bin/activate
+
+# Set your HF token (if not in config.py)
+export HF_TOKEN="hf_your_token_here"
+
+# Test data registration
+python src/data_register.py
+
+# Test data preparation
+python src/data_prep.py
+
+# Test model training
+python src/train.py
+
+# Test deployment
+python src/deploy_to_hf.py
+```
+
+### Test GitHub Actions
+
+1. Push your code to GitHub:
+   ```bash
+   git add .
+   git commit -m "Initial commit: Predictive maintenance MLOps pipeline"
+   git push origin main
+   ```
+
+2. Go to your GitHub repo → **Actions** tab
+3. You should see the "Predictive Maintenance Pipeline" workflow running
+4. All 4 jobs should complete successfully (green checkmarks)
+
+---
+
+## 5. Where Each Configuration is Used
+
+| Configuration | Used In | Purpose |
+|--------------|---------|---------|
+| `HF_DATASET_REPO` | `src/data_register.py`, `src/data_prep.py`, `src/train.py` | Dataset storage and retrieval |
+| `HF_MODEL_REPO` | `src/train.py`, `src/inference.py`, `src/app.py` | Model storage and loading |
+| `HF_SPACE_REPO` | `src/deploy_to_hf.py` | Streamlit app deployment |
+| `HF_TOKEN` | All HF-related scripts | Authentication |
+| GitHub Secrets | `.github/workflows/pipeline.yml` | CI/CD automation |
+
+---
+
+## Need Help?
+
+- **Hugging Face Docs**: https://huggingface.co/docs/hub
+- **GitHub Actions Docs**: https://docs.github.com/en/actions
+- **GitHub Secrets**: https://docs.github.com/en/actions/security-guides/encrypted-secrets

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+ENV PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
+
+# Install system dependencies (if needed for some Python packages)
+RUN apt-get update && apt-get install -y --no-install-recommends \ 
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["streamlit", "run", "src/app.py", "--server.port", "7860", "--server.address", "0.0.0.0"]
+

GITHUB_REPO_INFO.md

@@ -0,0 +1,71 @@
+# GitHub Repository Information
+
+## Repository Details
+
+- **GitHub Username**: `ananttripathi`
+- **Repository Name**: `engine-predictive-maintenance` (or your chosen name)
+- **Full Repository URL**: `https://github.com/ananttripathi/engine-predictive-maintenance`
+
+## Where to Add This Information
+
+### 1. In Your Final Notebook/Report
+
+Add a section like this:
+
+```markdown
+## GitHub Repository
+
+- **Repository URL**: https://github.com/ananttripathi/engine-predictive-maintenance
+- **GitHub Actions Workflow**: https://github.com/ananttripathi/engine-predictive-maintenance/actions
+- **Repository Structure**: [Screenshot of folder structure]
+- **Workflow Execution**: [Screenshot of successful pipeline runs]
+```
+
+### 2. In README.md
+
+The README already includes a placeholder. After you create the repo, update it with your actual repo name.
+
+### 3. GitHub Actions Workflow
+
+**No changes needed!** The `.github/workflows/pipeline.yml` file automatically runs in the context of whatever repository it's pushed to. It doesn't need the repo URL hardcoded.
+
+## Steps to Set Up GitHub Repository
+
+1. **Create the repository on GitHub:**
+   - Go to https://github.com/new
+   - Repository name: `engine-predictive-maintenance` (or your choice)
+   - Description: "Predictive Maintenance MLOps Pipeline for Engine Failure Classification"
+   - Choose Public or Private
+   - **Don't** initialize with README, .gitignore, or license (we already have files)
+
+2. **Push your code:**
+   ```bash
+   cd /Users/ananttripathi/Desktop/mlops
+   git init
+   git add .
+   git commit -m "Initial commit: Predictive maintenance MLOps pipeline"
+   git branch -M main
+   git remote add origin https://github.com/ananttripathi/engine-predictive-maintenance.git
+   git push -u origin main
+   ```
+
+3. **Add GitHub Secrets:**
+   - Go to: https://github.com/ananttripathi/engine-predictive-maintenance/settings/secrets/actions
+   - Click "New repository secret"
+   - Add these 4 secrets:
+     - `HF_TOKEN` → Your Hugging Face token
+     - `HF_DATASET_REPO` → `ananttripathiak/engine-maintenance-dataset`
+     - `HF_MODEL_REPO` → `ananttripathiak/engine-maintenance-model`
+     - `HF_SPACE_REPO` → `ananttripathiak/engine-maintenance-space`
+
+4. **Verify GitHub Actions:**
+   - After pushing, go to: https://github.com/ananttripathi/engine-predictive-maintenance/actions
+   - You should see the "Predictive Maintenance Pipeline" workflow running
+   - All 4 jobs should complete successfully
+
+## Important Notes
+
+- **GitHub username** (`ananttripathi`) is used for the repository URL
+- **Hugging Face username** might be different - check your HF account and update `src/config.py` if needed
+- The GitHub Actions workflow reads secrets automatically - no code changes needed
+- Repository name can be anything you want (e.g., `engine-predictive-maintenance`, `mlops-project`, etc.)

MANUAL_VS_AUTOMATIC.md

@@ -0,0 +1,235 @@
+# Manual vs Automatic Uploads - Quick Guide
+
+## 🚀 AUTOMATIC Uploads (Via Scripts)
+
+These happen automatically when you run the scripts. **You don't need to manually upload anything to Hugging Face.**
+
+### ✅ Automatic: Hugging Face Dataset Repo
+**Script**: `python src/data_register.py` and `python src/data_prep.py`
+
+**What gets uploaded automatically:**
+- ✅ `data/engine_data.csv` → HF Dataset Repo
+- ✅ `data/processed/train.csv` → HF Dataset Repo  
+- ✅ `data/processed/test.csv` → HF Dataset Repo
+
+**You just run:**
+```bash
+python src/data_register.py    # Auto-uploads raw data
+python src/data_prep.py        # Auto-uploads train/test
+```
+
+**That's it!** The scripts handle everything - creating the repo, uploading files, etc.
+
+---
+
+### ✅ Automatic: Hugging Face Model Repo
+**Script**: `python src/train.py`
+
+**What gets uploaded automatically:**
+- ✅ `models/best_model.joblib` → HF Model Repo (as `model.joblib`)
+
+**You just run:**
+```bash
+python src/train.py
+```
+
+**That's it!** The script:
+1. Trains the model
+2. Saves it locally
+3. Automatically uploads to HF Model Repo
+
+---
+
+### ✅ Automatic: Hugging Face Space (Streamlit App)
+**Script**: `python src/deploy_to_hf.py`
+
+**What gets uploaded automatically:**
+- ✅ `src/app.py` (Streamlit app)
+- ✅ `src/inference.py`
+- ✅ `src/config.py`
+- ✅ `Dockerfile`
+- ✅ `requirements.txt`
+- ✅ Other `src/*.py` files needed
+
+**You just run:**
+```bash
+python src/deploy_to_hf.py
+```
+
+**That's it!** The script:
+1. Creates/updates the HF Space
+2. Uploads all deployment files
+3. Configures it as a Streamlit app
+
+---
+
+## 📤 MANUAL Uploads (You Do This)
+
+Only **ONE** thing needs to be done manually:
+
+### ⚠️ Manual: GitHub Repository
+
+**What you need to do manually:**
+- Push your entire `mlops/` folder to GitHub
+
+**Steps:**
+```bash
+cd /Users/ananttripathi/Desktop/mlops
+
+# 1. Initialize git (if not done)
+git init
+
+# 2. Create .gitignore (to exclude large files)
+cat > .gitignore << EOF
+.venv/
+__pycache__/
+*.pyc
+mlruns/
+*.log
+.DS_Store
+EOF
+
+# 3. Add all files
+git add .
+
+# 4. Commit
+git commit -m "Initial commit: Predictive Maintenance MLOps Pipeline"
+
+# 5. Add your GitHub repo as remote
+git remote add origin https://github.com/ananttripathi/engine-predictive-maintenance.git
+
+# 6. Push to GitHub
+git push -u origin main
+```
+
+**That's the ONLY manual upload!**
+
+---
+
+## 📊 Summary Table
+
+| Destination | Upload Method | What You Do |
+|------------|---------------|-------------|
+| **GitHub** | ⚠️ **MANUAL** | Run `git push` commands |
+| **HF Dataset** | ✅ **AUTOMATIC** | Run `python src/data_register.py` and `python src/data_prep.py` |
+| **HF Model** | ✅ **AUTOMATIC** | Run `python src/train.py` |
+| **HF Space** | ✅ **AUTOMATIC** | Run `python src/deploy_to_hf.py` |
+
+---
+
+## 🎯 Complete Workflow
+
+### Step 1: Manual - GitHub (Do This First)
+```bash
+# Push everything to GitHub
+git init
+git add .
+git commit -m "Initial commit"
+git remote add origin https://github.com/ananttripathi/engine-predictive-maintenance.git
+git push -u origin main
+```
+⏱️ **Time**: 2-3 minutes
+
+---
+
+### Step 2: Automatic - HF Dataset
+```bash
+export HF_TOKEN="your_hf_token"
+python src/data_register.py
+python src/data_prep.py
+```
+⏱️ **Time**: 1-2 minutes (scripts do everything)
+
+---
+
+### Step 3: Automatic - HF Model
+```bash
+python src/train.py
+```
+⏱️ **Time**: 5-10 minutes (trains model + auto-uploads)
+
+---
+
+### Step 4: Automatic - HF Space
+```bash
+python src/deploy_to_hf.py
+```
+⏱️ **Time**: 1-2 minutes (scripts do everything)
+
+---
+
+## ✅ What You Need to Prepare
+
+### Before Running Scripts:
+
+1. **Set Environment Variable:**
+   ```bash
+   export HF_TOKEN="hf_your_token_here"
+   ```
+
+2. **Update `src/config.py`** (already done):
+   - HF repos are set to `ananttripathiak/...`
+
+3. **That's it!** Scripts handle the rest automatically.
+
+---
+
+## 🔍 Verification
+
+After running scripts, verify automatic uploads:
+
+1. **HF Dataset**: https://huggingface.co/datasets/ananttripathiak/engine-maintenance-dataset
+   - Should see: `data/engine_data.csv`, `data/train.csv`, `data/test.csv`
+
+2. **HF Model**: https://huggingface.co/ananttripathiak/engine-maintenance-model
+   - Should see: `model.joblib`
+
+3. **HF Space**: https://huggingface.co/spaces/ananttripathiak/engine-maintenance-space
+   - Should see: `src/app.py`, `Dockerfile`, `requirements.txt`
+   - App should be running!
+
+---
+
+## 💡 Key Points
+
+✅ **Automatic (3 out of 4):**
+- HF Dataset upload
+- HF Model upload  
+- HF Space deployment
+
+⚠️ **Manual (1 out of 4):**
+- GitHub push (only this one!)
+
+🎯 **Bottom Line:**
+- **75% automatic** - Just run the scripts!
+- **25% manual** - Just push to GitHub once!
+
+---
+
+## 🚨 Common Questions
+
+**Q: Do I need to manually create HF repos?**
+A: **No!** Scripts create them automatically if they don't exist.
+
+**Q: Do I need to manually upload files to HF?**
+A: **No!** Scripts upload everything automatically.
+
+**Q: What if a script fails?**
+A: Check `HF_TOKEN` is set, then re-run the script. It will continue from where it left off.
+
+**Q: Can I skip GitHub and just use HF?**
+A: For the project rubric, you need GitHub for the CI/CD workflow. But for HF-only, yes, scripts handle everything.
+
+---
+
+## 📝 Quick Checklist
+
+- [ ] **Manual**: Push to GitHub (`git push`)
+- [ ] **Automatic**: Run `python src/data_register.py`
+- [ ] **Automatic**: Run `python src/data_prep.py`
+- [ ] **Automatic**: Run `python src/train.py`
+- [ ] **Automatic**: Run `python src/deploy_to_hf.py`
+- [ ] Verify all uploads completed successfully
+
+**Total Manual Work: ~5 minutes (just GitHub)**
+**Total Automatic Work: ~10-15 minutes (scripts do everything)**

Notebook_AML_and_MLOps_Project (2).ipynb

@@ -0,0 +1,1808 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "klg2JF-oBblG"
+   },
+   "source": [
+    "# Problem Statement"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "m0CcOjZ-BblL"
+   },
+   "source": [
+    "## **Business Context**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uyT6Koe7BblM"
+   },
+   "source": [
+    "\"Visit with Us,\" a leading travel company, is revolutionizing the tourism industry by leveraging data-driven strategies to optimize operations and customer engagement. While introducing a new package offering, such as the Wellness Tourism Package, the company faces challenges in targeting the right customers efficiently. The manual approach to identifying potential customers is inconsistent, time-consuming, and prone to errors, leading to missed opportunities and suboptimal campaign performance.\n",
+    "\n",
+    "To address these issues, the company aims to implement a scalable and automated system that integrates customer data, predicts potential buyers, and enhances decision-making for marketing strategies. By utilizing an MLOps pipeline, the company seeks to achieve seamless integration of data preprocessing, model development, deployment, and CI/CD practices for continuous improvement. This system will ensure efficient targeting of customers, timely updates to the predictive model, and adaptation to evolving customer behaviors, ultimately driving growth and customer satisfaction.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "zm6bNQOJBblO"
+   },
+   "source": [
+    "## **Objective**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7PYtjk_YBblO"
+   },
+   "source": [
+    "As an MLOps Engineer at \"Visit with Us,\" your responsibility is to design and deploy an MLOps pipeline on GitHub to automate the end-to-end workflow for predicting customer purchases. The primary objective is to build a model that predicts whether a customer will purchase the newly introduced Wellness Tourism Package before contacting them. The pipeline will include data cleaning, preprocessing, transformation, model building, training, evaluation, and deployment, ensuring consistent performance and scalability. By leveraging GitHub Actions for CI/CD integration, the system will enable automated updates, streamline model deployment, and improve operational efficiency. This robust predictive solution will empower policymakers to make data-driven decisions, enhance marketing strategies, and effectively target potential customers, thereby driving customer acquisition and business growth."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "z8C11AzTBblP"
+   },
+   "source": [
+    "## **Data Description**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9DQx3pkaBblP"
+   },
+   "source": [
+    "The dataset contains customer and interaction data that serve as key attributes for predicting the likelihood of purchasing the Wellness Tourism Package. The detailed attributes are:\n",
+    "\n",
+    "**Customer Details**\n",
+    "- **CustomerID:** Unique identifier for each customer.\n",
+    "- **ProdTaken:** Target variable indicating whether the customer has purchased a package (0: No, 1: Yes).\n",
+    "- **Age:** Age of the customer.\n",
+    "- **TypeofContact:** The method by which the customer was contacted (Company Invited or Self Inquiry).\n",
+    "- **CityTier:** The city category based on development, population, and living standards (Tier 1 > Tier 2 > Tier 3).\n",
+    "- **Occupation:** Customer's occupation (e.g., Salaried, Freelancer).\n",
+    "- **Gender:** Gender of the customer (Male, Female).\n",
+    "- **NumberOfPersonVisiting:** Total number of people accompanying the customer on the trip.\n",
+    "- **PreferredPropertyStar:** Preferred hotel rating by the customer.\n",
+    "- **MaritalStatus:** Marital status of the customer (Single, Married, Divorced).\n",
+    "- **NumberOfTrips:** Average number of trips the customer takes annually.\n",
+    "- **Passport:** Whether the customer holds a valid passport (0: No, 1: Yes).\n",
+    "- **OwnCar:** Whether the customer owns a car (0: No, 1: Yes).\n",
+    "- **NumberOfChildrenVisiting:** Number of children below age 5 accompanying the customer.\n",
+    "- **Designation:** Customer's designation in their current organization.\n",
+    "- **MonthlyIncome:** Gross monthly income of the customer.\n",
+    "\n",
+    "**Customer Interaction Data**\n",
+    "- **PitchSatisfactionScore:** Score indicating the customer's satisfaction with the sales pitch.\n",
+    "- **ProductPitched:** The type of product pitched to the customer.\n",
+    "- **NumberOfFollowups:** Total number of follow-ups by the salesperson after the sales pitch.-\n",
+    "- **DurationOfPitch:** Duration of the sales pitch delivered to the customer.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "0LbSu_p2jYfe"
+   },
+   "source": [
+    "# Model Building"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 15,
+     "status": "ok",
+     "timestamp": 1765705284123,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "giodc4KknHID",
+    "outputId": "2caa2d21-8ef6-4259-8d79-5573ee1372d1"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/content\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create a master folder to keep all files created when executing the below code cells\n",
+    "import os\n",
+    "print(os.getcwd())\n",
+    "os.makedirs(\"tourism_project\", exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 1,
+     "status": "ok",
+     "timestamp": 1765705284135,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "SUKPoy0EA4jj"
+   },
+   "outputs": [],
+   "source": [
+    "# Create a folder for storing the model building files\n",
+    "os.makedirs(\"tourism_project/model_building\", exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9DtS3gNDjBbR"
+   },
+   "source": [
+    "## Data Registration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 10,
+     "status": "ok",
+     "timestamp": 1765705284146,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "ZagOeVxJOtJ9"
+   },
+   "outputs": [],
+   "source": [
+    "os.makedirs(\"tourism_project/data\", exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "WxXiD9ZXxodF"
+   },
+   "source": [
+    "Once the **data** folder created after executing the above cell, please upload the **tourism.csv** in to the folder"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hh2TjRG5WJ4Z"
+   },
+   "source": [
+    "## Data Preparation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 9,
+     "status": "ok",
+     "timestamp": 1765705284156,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "EHVRGAeoOtJ-",
+    "outputId": "016d1a7d-e728-4d1e-a208-c4a08c9213a4"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing tourism_project/model_building/data_register.py\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%writefile tourism_project/model_building/data_register.py\n",
+    "from huggingface_hub.utils import RepositoryNotFoundError, HfHubHTTPError\n",
+    "from huggingface_hub import HfApi, create_repo\n",
+    "import os\n",
+    "\n",
+    "\n",
+    "repo_id = \"ananttripathiak/tourism-dataset\"\n",
+    "repo_type = \"dataset\"\n",
+    "\n",
+    "# Initialize API client\n",
+    "api = HfApi(token=os.getenv(\"HF_TOKEN\"))\n",
+    "\n",
+    "# Step 1: Check if the space exists\n",
+    "try:\n",
+    "    api.repo_info(repo_id=repo_id, repo_type=repo_type)\n",
+    "    print(f\"Space '{repo_id}' already exists. Using it.\")\n",
+    "except RepositoryNotFoundError:\n",
+    "    print(f\"Space '{repo_id}' not found. Creating new space...\")\n",
+    "    create_repo(repo_id=repo_id, repo_type=repo_type, private=False)\n",
+    "    print(f\"Space '{repo_id}' created.\")\n",
+    "\n",
+    "api.upload_folder(\n",
+    "    folder_path=\"tourism_project/data\",\n",
+    "    repo_id=repo_id,\n",
+    "    repo_type=repo_type,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "eZZKnLkLjeM4"
+   },
+   "source": [
+    "## Model Training and Registration with Experimentation Tracking"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 2,
+     "status": "ok",
+     "timestamp": 1765705284159,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "LFmrcXT_OtJ-"
+   },
+   "outputs": [],
+   "source": [
+    "# !pip install mlflow scikit-learn huggingface_hub\n",
+    "# import sys\n",
+    "# !{sys.executable} -m pip install mlflow"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 26,
+     "status": "ok",
+     "timestamp": 1765705284186,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "DatpH_YdOtJ-",
+    "outputId": "3f7f7b88-26e9-4e36-df88-b83e5f28fd09"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing tourism_project/model_building/train.py\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%writefile tourism_project/model_building/train.py\n",
+    "\n",
+    "# for data manipulation\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "# for data preprocessing and pipeline creation\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.compose import make_column_transformer\n",
+    "from sklearn.pipeline import make_pipeline\n",
+    "# for model training, tuning, and evaluation\n",
+    "import xgboost as xgb\n",
+    "from sklearn.model_selection import GridSearchCV\n",
+    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, classification_report, confusion_matrix\n",
+    "# for model serialization\n",
+    "import joblib\n",
+    "# for creating a folder\n",
+    "import os\n",
+    "# for hugging face space authentication to upload files\n",
+    "from huggingface_hub import login, HfApi, create_repo\n",
+    "from huggingface_hub.utils import RepositoryNotFoundError, HfHubHTTPError\n",
+    "import mlflow\n",
+    "\n",
+    "# Set up MLflow tracking\n",
+    "mlflow.set_tracking_uri(\"http://localhost:5000\")\n",
+    "mlflow.set_experiment(\"tourism-package-prediction\")\n",
+    "\n",
+    "api = HfApi()\n",
+    "\n",
+    "# Load the preprocessed data from Hugging Face\n",
+    "Xtrain_path = \"hf://datasets/ananttripathiak/tourism-dataset/Xtrain.csv\"\n",
+    "Xtest_path = \"hf://datasets/ananttripathiak/tourism-dataset/Xtest.csv\"\n",
+    "ytrain_path = \"hf://datasets/ananttripathiak/tourism-dataset/ytrain.csv\"\n",
+    "ytest_path = \"hf://datasets/ananttripathiak/tourism-dataset/ytest.csv\"\n",
+    "\n",
+    "print(\"Loading preprocessed data...\")\n",
+    "Xtrain = pd.read_csv(Xtrain_path)\n",
+    "Xtest = pd.read_csv(Xtest_path)\n",
+    "ytrain = pd.read_csv(ytrain_path).values.ravel()\n",
+    "ytest = pd.read_csv(ytest_path).values.ravel()\n",
+    "\n",
+    "print(f\"Training set shape: {Xtrain.shape}\")\n",
+    "print(f\"Test set shape: {Xtest.shape}\")\n",
+    "\n",
+    "# Identify numeric features (all features after encoding)\n",
+    "numeric_features = Xtrain.columns.tolist()\n",
+    "\n",
+    "# Preprocessor - StandardScaler for all numeric features\n",
+    "preprocessor = make_column_transformer(\n",
+    "    (StandardScaler(), numeric_features)\n",
+    ")\n",
+    "\n",
+    "# Define base XGBoost Classifier\n",
+    "xgb_model = xgb.XGBClassifier(\n",
+    "    random_state=42,\n",
+    "    n_jobs=-1,\n",
+    "    eval_metric='logloss',\n",
+    "    use_label_encoder=False\n",
+    ")\n",
+    "\n",
+    "# Hyperparameter grid for classification\n",
+    "param_grid = {\n",
+    "    'xgbclassifier__n_estimators': [100, 200, 300],\n",
+    "    'xgbclassifier__max_depth': [3, 5, 7],\n",
+    "    'xgbclassifier__learning_rate': [0.01, 0.05, 0.1],\n",
+    "    'xgbclassifier__subsample': [0.7, 0.8, 1.0],\n",
+    "    'xgbclassifier__colsample_bytree': [0.7, 0.8, 1.0],\n",
+    "    'xgbclassifier__scale_pos_weight': [1, 2, 3]  # Handle class imbalance\n",
+    "}\n",
+    "\n",
+    "# Pipeline\n",
+    "model_pipeline = make_pipeline(preprocessor, xgb_model)\n",
+    "\n",
+    "print(\"\\nStarting MLflow experiment...\")\n",
+    "with mlflow.start_run():\n",
+    "    print(\"Performing Grid Search with Cross-Validation...\")\n",
+    "    # Grid Search\n",
+    "    grid_search = GridSearchCV(\n",
+    "        model_pipeline,\n",
+    "        param_grid,\n",
+    "        cv=3,\n",
+    "        n_jobs=-1,\n",
+    "        scoring='roc_auc',\n",
+    "        verbose=1\n",
+    "    )\n",
+    "    grid_search.fit(Xtrain, ytrain)\n",
+    "\n",
+    "    # Log parameter sets\n",
+    "    results = grid_search.cv_results_\n",
+    "    print(f\"\\nEvaluated {len(results['params'])} parameter combinations\")\n",
+    "\n",
+    "    for i in range(len(results['params'])):\n",
+    "        param_set = results['params'][i]\n",
+    "        mean_score = results['mean_test_score'][i]\n",
+    "\n",
+    "        with mlflow.start_run(nested=True):\n",
+    "            mlflow.log_params(param_set)\n",
+    "            mlflow.log_metric(\"mean_roc_auc\", mean_score)\n",
+    "\n",
+    "    # Best model\n",
+    "    print(f\"\\nBest parameters: {grid_search.best_params_}\")\n",
+    "    mlflow.log_params(grid_search.best_params_)\n",
+    "    best_model = grid_search.best_estimator_\n",
+    "\n",
+    "    # Predictions\n",
+    "    print(\"\\nMaking predictions...\")\n",
+    "    y_pred_train = best_model.predict(Xtrain)\n",
+    "    y_pred_test = best_model.predict(Xtest)\n",
+    "\n",
+    "    # Probability predictions for ROC-AUC\n",
+    "    y_pred_train_proba = best_model.predict_proba(Xtrain)[:, 1]\n",
+    "    y_pred_test_proba = best_model.predict_proba(Xtest)[:, 1]\n",
+    "\n",
+    "    # Calculate metrics\n",
+    "    print(\"\\nCalculating metrics...\")\n",
+    "    train_accuracy = accuracy_score(ytrain, y_pred_train)\n",
+    "    test_accuracy = accuracy_score(ytest, y_pred_test)\n",
+    "\n",
+    "    train_precision = precision_score(ytrain, y_pred_train, zero_division=0)\n",
+    "    test_precision = precision_score(ytest, y_pred_test, zero_division=0)\n",
+    "\n",
+    "    train_recall = recall_score(ytrain, y_pred_train, zero_division=0)\n",
+    "    test_recall = recall_score(ytest, y_pred_test, zero_division=0)\n",
+    "\n",
+    "    train_f1 = f1_score(ytrain, y_pred_train, zero_division=0)\n",
+    "    test_f1 = f1_score(ytest, y_pred_test, zero_division=0)\n",
+    "\n",
+    "    train_roc_auc = roc_auc_score(ytrain, y_pred_train_proba)\n",
+    "    test_roc_auc = roc_auc_score(ytest, y_pred_test_proba)\n",
+    "\n",
+    "    # Log metrics\n",
+    "    mlflow.log_metrics({\n",
+    "        \"train_accuracy\": train_accuracy,\n",
+    "        \"test_accuracy\": test_accuracy,\n",
+    "        \"train_precision\": train_precision,\n",
+    "        \"test_precision\": test_precision,\n",
+    "        \"train_recall\": train_recall,\n",
+    "        \"test_recall\": test_recall,\n",
+    "        \"train_f1_score\": train_f1,\n",
+    "        \"test_f1_score\": test_f1,\n",
+    "        \"train_roc_auc\": train_roc_auc,\n",
+    "        \"test_roc_auc\": test_roc_auc\n",
+    "    })\n",
+    "\n",
+    "    # Print results\n",
+    "    print(\"\\n\" + \"=\"*50)\n",
+    "    print(\"MODEL PERFORMANCE METRICS\")\n",
+    "    print(\"=\"*50)\n",
+    "    print(f\"Train Accuracy: {train_accuracy:.4f} | Test Accuracy: {test_accuracy:.4f}\")\n",
+    "    print(f\"Train Precision: {train_precision:.4f} | Test Precision: {test_precision:.4f}\")\n",
+    "    print(f\"Train Recall: {train_recall:.4f} | Test Recall: {test_recall:.4f}\")\n",
+    "    print(f\"Train F1-Score: {train_f1:.4f} | Test F1-Score: {test_f1:.4f}\")\n",
+    "    print(f\"Train ROC-AUC: {train_roc_auc:.4f} | Test ROC-AUC: {test_roc_auc:.4f}\")\n",
+    "    print(\"=\"*50)\n",
+    "\n",
+    "    print(\"\\nTest Set Classification Report:\")\n",
+    "    print(classification_report(ytest, y_pred_test, target_names=['No Purchase', 'Purchase']))\n",
+    "\n",
+    "    print(\"\\nTest Set Confusion Matrix:\")\n",
+    "    print(confusion_matrix(ytest, y_pred_test))\n",
+    "\n",
+    "    # Save the model locally\n",
+    "    model_path = \"best_tourism_model_v1.joblib\"\n",
+    "    joblib.dump(best_model, model_path)\n",
+    "    print(f\"\\nModel saved locally as: {model_path}\")\n",
+    "\n",
+    "    # Log the model artifact\n",
+    "    mlflow.log_artifact(model_path, artifact_path=\"model\")\n",
+    "    print(f\"Model logged to MLflow\")\n",
+    "\n",
+    "    # Upload to Hugging Face\n",
+    "    repo_id = \"ananttripathiak/tourism-prediction-model\"\n",
+    "    repo_type = \"model\"\n",
+    "\n",
+    "    # Step 1: Check if the repository exists\n",
+    "    try:\n",
+    "        api.repo_info(repo_id=repo_id, repo_type=repo_type)\n",
+    "        print(f\"\\nRepository '{repo_id}' already exists. Using it.\")\n",
+    "    except RepositoryNotFoundError:\n",
+    "        print(f\"\\nRepository '{repo_id}' not found. Creating new repository...\")\n",
+    "        create_repo(repo_id=repo_id, repo_type=repo_type, private=False)\n",
+    "        print(f\"Repository '{repo_id}' created.\")\n",
+    "\n",
+    "    # Upload model to Hugging Face\n",
+    "    api.upload_file(\n",
+    "        path_or_fileobj=\"best_tourism_model_v1.joblib\",\n",
+    "        path_in_repo=\"best_tourism_model_v1.joblib\",\n",
+    "        repo_id=repo_id,\n",
+    "        repo_type=repo_type,\n",
+    "    )\n",
+    "    print(f\"Model uploaded to Hugging Face: {repo_id}\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*50)\n",
+    "print(\"MODEL TRAINING COMPLETED SUCCESSFULLY!\")\n",
+    "print(\"=\"*50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 203,
+     "status": "ok",
+     "timestamp": 1765705284390,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "Vtjn_63uOtJ-",
+    "outputId": "259877f9-6be4-4ef1-cda4-c06d26720447"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing tourism_project/model_building/prep.py\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%writefile tourism_project/model_building/prep.py\n",
+    "# for data manipulation\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "# for data preprocessing and pipeline creation\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "# for converting text data in to numerical representation\n",
+    "from sklearn.preprocessing import LabelEncoder\n",
+    "# for hugging face space authentication to upload files\n",
+    "from huggingface_hub import login, HfApi\n",
+    "import os\n",
+    "\n",
+    "# Define constants for the dataset and output paths\n",
+    "api = HfApi(token=os.getenv(\"HF_TOKEN\"))\n",
+    "DATASET_PATH = \"hf://datasets/ananttripathiak/tourism-dataset/tourism.csv\"\n",
+    "df = pd.read_csv(DATASET_PATH)\n",
+    "print(\"Dataset loaded successfully.\")\n",
+    "print(f\"Dataset shape: {df.shape}\")\n",
+    "\n",
+    "# Drop the unnamed index column if it exists\n",
+    "if 'Unnamed: 0' in df.columns or df.columns[0] == '':\n",
+    "    df = df.iloc[:, 1:]\n",
+    "\n",
+    "# Drop CustomerID as it's a unique identifier (not useful for modeling)\n",
+    "if 'CustomerID' in df.columns:\n",
+    "    df.drop(columns=['CustomerID'], inplace=True)\n",
+    "\n",
+    "# Handle missing values\n",
+    "print(\"\\nHandling missing values...\")\n",
+    "# For numerical columns, fill with median\n",
+    "numerical_cols = df.select_dtypes(include=[np.number]).columns\n",
+    "for col in numerical_cols:\n",
+    "    if df[col].isnull().sum() > 0:\n",
+    "        df[col].fillna(df[col].median(), inplace=True)\n",
+    "\n",
+    "# For categorical columns, fill with mode\n",
+    "categorical_cols = df.select_dtypes(include=['object']).columns\n",
+    "for col in categorical_cols:\n",
+    "    if df[col].isnull().sum() > 0:\n",
+    "        df[col].fillna(df[col].mode()[0], inplace=True)\n",
+    "\n",
+    "# Handle specific data quality issues (e.g., \"Fe Male\" should be \"Female\")\n",
+    "if 'Gender' in df.columns:\n",
+    "    df['Gender'] = df['Gender'].str.strip().replace({'Fe Male': 'Female', 'Fe male': 'Female'})\n",
+    "\n",
+    "# Encode categorical columns\n",
+    "print(\"\\nEncoding categorical variables...\")\n",
+    "label_encoder = LabelEncoder()\n",
+    "\n",
+    "# List of categorical columns to encode\n",
+    "categorical_features = ['TypeofContact', 'Occupation', 'Gender', 'ProductPitched',\n",
+    "                        'MaritalStatus', 'Designation']\n",
+    "\n",
+    "for col in categorical_features:\n",
+    "    if col in df.columns:\n",
+    "        df[col] = label_encoder.fit_transform(df[col].astype(str))\n",
+    "\n",
+    "# Define target variable\n",
+    "target_col = 'ProdTaken'\n",
+    "\n",
+    "# Split into X (features) and y (target)\n",
+    "X = df.drop(columns=[target_col])\n",
+    "y = df[target_col]\n",
+    "\n",
+    "print(f\"\\nFeatures shape: {X.shape}\")\n",
+    "print(f\"Target shape: {y.shape}\")\n",
+    "print(f\"Target distribution:\\n{y.value_counts()}\")\n",
+    "\n",
+    "# Perform train-test split\n",
+    "Xtrain, Xtest, ytrain, ytest = train_test_split(\n",
+    "    X, y, test_size=0.2, random_state=42, stratify=y\n",
+    ")\n",
+    "\n",
+    "print(f\"\\nTrain set size: {Xtrain.shape[0]}\")\n",
+    "print(f\"Test set size: {Xtest.shape[0]}\")\n",
+    "\n",
+    "# Save the datasets\n",
+    "Xtrain.to_csv(\"Xtrain.csv\", index=False)\n",
+    "Xtest.to_csv(\"Xtest.csv\", index=False)\n",
+    "ytrain.to_csv(\"ytrain.csv\", index=False)\n",
+    "ytest.to_csv(\"ytest.csv\", index=False)\n",
+    "\n",
+    "print(\"\\nDatasets saved locally.\")\n",
+    "\n",
+    "# Upload to Hugging Face\n",
+    "files = [\"Xtrain.csv\", \"Xtest.csv\", \"ytrain.csv\", \"ytest.csv\"]\n",
+    "\n",
+    "for file_path in files:\n",
+    "    api.upload_file(\n",
+    "        path_or_fileobj=file_path,\n",
+    "        path_in_repo=file_path.split(\"/\")[-1],\n",
+    "        repo_id=\"ananttripathiak/tourism-dataset\",\n",
+    "        repo_type=\"dataset\",\n",
+    "    )\n",
+    "    print(f\"Uploaded {file_path} to Hugging Face\")\n",
+    "\n",
+    "print(\"\\nData preparation completed successfully!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "0McYCZzkji5I"
+   },
+   "source": [
+    "# Deployment"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9QrY2v77vbEZ"
+   },
+   "source": [
+    "## Dockerfile"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 2,
+     "status": "ok",
+     "timestamp": 1765705284393,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "0-AMAI72CR-T"
+   },
+   "outputs": [],
+   "source": [
+    "os.makedirs(\"tourism_project/deployment\", exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 10,
+     "status": "ok",
+     "timestamp": 1765705284404,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "ZTicTDnPCVZr",
+    "outputId": "1707e165-9dee-4adb-c9c4-e2e0b50ce8fb"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing tourism_project/deployment/Dockerfile\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%writefile tourism_project/deployment/Dockerfile\n",
+    "# Use a minimal base image with Python 3.9 installed\n",
+    "FROM python:3.9\n",
+    "\n",
+    "# Set the working directory inside the container to /app\n",
+    "WORKDIR /app\n",
+    "\n",
+    "# Copy all files from the current directory on the host to the container's /app directory\n",
+    "COPY . .\n",
+    "\n",
+    "# Install Python dependencies listed in requirements.txt\n",
+    "RUN pip3 install -r requirements.txt\n",
+    "\n",
+    "RUN useradd -m -u 1000 user\n",
+    "USER user\n",
+    "ENV HOME=/home/user \\\n",
+    "\tPATH=/home/user/.local/bin:$PATH\n",
+    "\n",
+    "WORKDIR $HOME/app\n",
+    "\n",
+    "COPY --chown=user . $HOME/app\n",
+    "\n",
+    "# Define the command to run the Streamlit app on port \"8501\" and make it accessible externally\n",
+    "CMD [\"streamlit\", \"run\", \"app.py\", \"--server.port=8501\", \"--server.address=0.0.0.0\", \"--server.enableXsrfProtection=false\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "LCvrklrBwNvJ"
+   },
+   "source": [
+    "## Streamlit App"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fXWe6ObRjP6-"
+   },
+   "source": [
+    "Please ensure that the web app script is named `app.py`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 56,
+     "status": "ok",
+     "timestamp": 1765705284459,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "WBG-jxM89jdp",
+    "outputId": "885441f8-7cf2-4646-fc4e-705ebddf4640"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing tourism_project/deployment/app.py\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%writefile tourism_project/deployment/app.py\n",
+    "import streamlit as st\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from huggingface_hub import hf_hub_download\n",
+    "import joblib\n",
+    "\n",
+    "# Page configuration\n",
+    "st.set_page_config(\n",
+    "    page_title=\"Tourism Package Prediction\",\n",
+    "    page_icon=\"✈️\",\n",
+    "    layout=\"wide\"\n",
+    ")\n",
+    "\n",
+    "# Download and load the trained model\n",
+    "@st.cache_resource\n",
+    "def load_model():\n",
+    "    try:\n",
+    "        model_path = hf_hub_download(\n",
+    "            repo_id=\"ananttripathiak/tourism-prediction-model\",\n",
+    "            filename=\"best_tourism_model_v1.joblib\"\n",
+    "        )\n",
+    "        model = joblib.load(model_path)\n",
+    "        return model\n",
+    "    except Exception as e:\n",
+    "        st.error(f\"Error loading model: {e}\")\n",
+    "        return None\n",
+    "\n",
+    "model = load_model()\n",
+    "\n",
+    "# Title and Description\n",
+    "st.title(\"✈️ Wellness Tourism Package Prediction\")\n",
+    "st.markdown(\"\"\"\n",
+    "<style>\n",
+    "    .main-header {\n",
+    "        font-size: 20px;\n",
+    "        color: #1f77b4;\n",
+    "        margin-bottom: 20px;\n",
+    "    }\n",
+    "    .prediction-box {\n",
+    "        padding: 20px;\n",
+    "        border-radius: 10px;\n",
+    "        margin: 20px 0;\n",
+    "    }\n",
+    "    .success-box {\n",
+    "        background-color: #d4edda;\n",
+    "        border: 1px solid #c3e6cb;\n",
+    "    }\n",
+    "    .warning-box {\n",
+    "        background-color: #fff3cd;\n",
+    "        border: 1px solid #ffeeba;\n",
+    "    }\n",
+    "</style>\n",
+    "\"\"\", unsafe_allow_html=True)\n",
+    "\n",
+    "st.markdown(\"\"\"\n",
+    "This application predicts the likelihood of a customer purchasing the **Wellness Tourism Package**\n",
+    "based on their profile and interaction data. Enter customer details below to get a prediction.\n",
+    "\"\"\")\n",
+    "\n",
+    "# Create two columns for input\n",
+    "col1, col2 = st.columns(2)\n",
+    "\n",
+    "with col1:\n",
+    "    st.subheader(\"📋 Customer Demographics\")\n",
+    "\n",
+    "    age = st.number_input(\"Age\", min_value=18, max_value=100, value=35, step=1)\n",
+    "\n",
+    "    type_of_contact = st.selectbox(\n",
+    "        \"Type of Contact\",\n",
+    "        options=[\"Self Enquiry\", \"Company Invited\"]\n",
+    "    )\n",
+    "\n",
+    "    city_tier = st.selectbox(\n",
+    "        \"City Tier\",\n",
+    "        options=[1, 2, 3],\n",
+    "        help=\"Tier 1: Metro cities, Tier 2: Mid-sized cities, Tier 3: Smaller cities\"\n",
+    "    )\n",
+    "\n",
+    "    occupation = st.selectbox(\n",
+    "        \"Occupation\",\n",
+    "        options=[\"Salaried\", \"Small Business\", \"Free Lancer\", \"Large Business\"]\n",
+    "    )\n",
+    "\n",
+    "    gender = st.selectbox(\"Gender\", options=[\"Male\", \"Female\"])\n",
+    "\n",
+    "    marital_status = st.selectbox(\n",
+    "        \"Marital Status\",\n",
+    "        options=[\"Single\", \"Married\", \"Divorced\", \"Unmarried\"]\n",
+    "    )\n",
+    "\n",
+    "    designation = st.selectbox(\n",
+    "        \"Designation\",\n",
+    "        options=[\"Executive\", \"Manager\", \"Senior Manager\", \"AVP\", \"VP\"]\n",
+    "    )\n",
+    "\n",
+    "    monthly_income = st.number_input(\n",
+    "        \"Monthly Income (₹)\",\n",
+    "        min_value=0.0,\n",
+    "        max_value=200000.0,\n",
+    "        value=25000.0,\n",
+    "        step=1000.0\n",
+    "    )\n",
+    "\n",
+    "with col2:\n",
+    "    st.subheader(\"🎯 Customer Interaction & Preferences\")\n",
+    "\n",
+    "    duration_of_pitch = st.number_input(\n",
+    "        \"Duration of Pitch (minutes)\",\n",
+    "        min_value=0.0,\n",
+    "        max_value=60.0,\n",
+    "        value=15.0,\n",
+    "        step=0.5\n",
+    "    )\n",
+    "\n",
+    "    number_of_persons_visiting = st.number_input(\n",
+    "        \"Number of Persons Visiting\",\n",
+    "        min_value=1,\n",
+    "        max_value=10,\n",
+    "        value=2,\n",
+    "        step=1\n",
+    "    )\n",
+    "\n",
+    "    number_of_followups = st.number_input(\n",
+    "        \"Number of Follow-ups\",\n",
+    "        min_value=0.0,\n",
+    "        max_value=10.0,\n",
+    "        value=3.0,\n",
+    "        step=1.0\n",
+    "    )\n",
+    "\n",
+    "    product_pitched = st.selectbox(\n",
+    "        \"Product Pitched\",\n",
+    "        options=[\"Basic\", \"Standard\", \"Deluxe\", \"Super Deluxe\", \"King\"]\n",
+    "    )\n",
+    "\n",
+    "    preferred_property_star = st.selectbox(\n",
+    "        \"Preferred Property Star Rating\",\n",
+    "        options=[3.0, 4.0, 5.0]\n",
+    "    )\n",
+    "\n",
+    "    number_of_trips = st.number_input(\n",
+    "        \"Number of Trips (per year)\",\n",
+    "        min_value=0.0,\n",
+    "        max_value=20.0,\n",
+    "        value=3.0,\n",
+    "        step=1.0\n",
+    "    )\n",
+    "\n",
+    "    passport = st.selectbox(\"Has Passport?\", options=[\"Yes\", \"No\"])\n",
+    "\n",
+    "    pitch_satisfaction_score = st.slider(\n",
+    "        \"Pitch Satisfaction Score\",\n",
+    "        min_value=1,\n",
+    "        max_value=5,\n",
+    "        value=3,\n",
+    "        step=1\n",
+    "    )\n",
+    "\n",
+    "    own_car = st.selectbox(\"Owns Car?\", options=[\"Yes\", \"No\"])\n",
+    "\n",
+    "    number_of_children_visiting = st.number_input(\n",
+    "        \"Number of Children Visiting\",\n",
+    "        min_value=0.0,\n",
+    "        max_value=5.0,\n",
+    "        value=0.0,\n",
+    "        step=1.0\n",
+    "    )\n",
+    "\n",
+    "# Encoding mapping (based on LabelEncoder used during training)\n",
+    "# Note: These mappings should match the exact encoding used during training\n",
+    "type_of_contact_map = {\"Company Invited\": 0, \"Self Enquiry\": 1}\n",
+    "occupation_map = {\"Free Lancer\": 0, \"Large Business\": 1, \"Salaried\": 2, \"Small Business\": 3}\n",
+    "gender_map = {\"Female\": 0, \"Male\": 1}\n",
+    "product_pitched_map = {\"Basic\": 0, \"Deluxe\": 1, \"King\": 2, \"Standard\": 3, \"Super Deluxe\": 4}\n",
+    "marital_status_map = {\"Divorced\": 0, \"Married\": 1, \"Single\": 2, \"Unmarried\": 3}\n",
+    "designation_map = {\"AVP\": 0, \"Executive\": 1, \"Manager\": 2, \"Senior Manager\": 3, \"VP\": 4}\n",
+    "\n",
+    "# Convert Yes/No to 0/1\n",
+    "passport_val = 1 if passport == \"Yes\" else 0\n",
+    "own_car_val = 1 if own_car == \"Yes\" else 0\n",
+    "\n",
+    "# Prepare input data\n",
+    "input_data = pd.DataFrame([{\n",
+    "    'Age': age,\n",
+    "    'TypeofContact': type_of_contact_map[type_of_contact],\n",
+    "    'CityTier': city_tier,\n",
+    "    'DurationOfPitch': duration_of_pitch,\n",
+    "    'Occupation': occupation_map[occupation],\n",
+    "    'Gender': gender_map[gender],\n",
+    "    'NumberOfPersonVisiting': number_of_persons_visiting,\n",
+    "    'NumberOfFollowups': number_of_followups,\n",
+    "    'ProductPitched': product_pitched_map[product_pitched],\n",
+    "    'PreferredPropertyStar': preferred_property_star,\n",
+    "    'MaritalStatus': marital_status_map[marital_status],\n",
+    "    'NumberOfTrips': number_of_trips,\n",
+    "    'Passport': passport_val,\n",
+    "    'PitchSatisfactionScore': pitch_satisfaction_score,\n",
+    "    'OwnCar': own_car_val,\n",
+    "    'NumberOfChildrenVisiting': number_of_children_visiting,\n",
+    "    'Designation': designation_map[designation],\n",
+    "    'MonthlyIncome': monthly_income\n",
+    "}])\n",
+    "\n",
+    "# Predict button\n",
+    "st.markdown(\"---\")\n",
+    "if st.button(\"🔮 Predict Purchase Likelihood\", use_container_width=True):\n",
+    "    if model is not None:\n",
+    "        try:\n",
+    "            # Make prediction\n",
+    "            prediction = model.predict(input_data)[0]\n",
+    "            prediction_proba = model.predict_proba(input_data)[0]\n",
+    "\n",
+    "            # Display results\n",
+    "            st.markdown(\"### 📊 Prediction Results\")\n",
+    "\n",
+    "            if prediction == 1:\n",
+    "                st.markdown(\n",
+    "                    f'<div class=\"prediction-box success-box\">'\n",
+    "                    f'<h2 style=\"color: #155724;\">✅ High Likelihood of Purchase!</h2>'\n",
+    "                    f'<p style=\"font-size: 18px;\">This customer is <b>likely to purchase</b> the Wellness Tourism Package.</p>'\n",
+    "                    f'<p style=\"font-size: 16px;\">Confidence: <b>{prediction_proba[1]*100:.2f}%</b></p>'\n",
+    "                    f'</div>',\n",
+    "                    unsafe_allow_html=True\n",
+    "                )\n",
+    "                st.success(\"💡 **Recommendation:** Prioritize follow-up with this customer!\")\n",
+    "            else:\n",
+    "                st.markdown(\n",
+    "                    f'<div class=\"prediction-box warning-box\">'\n",
+    "                    f'<h2 style=\"color: #856404;\">⚠️ Low Likelihood of Purchase</h2>'\n",
+    "                    f'<p style=\"font-size: 18px;\">This customer is <b>unlikely to purchase</b> the Wellness Tourism Package.</p>'\n",
+    "                    f'<p style=\"font-size: 16px;\">Confidence: <b>{prediction_proba[0]*100:.2f}%</b></p>'\n",
+    "                    f'</div>',\n",
+    "                    unsafe_allow_html=True\n",
+    "                )\n",
+    "                st.info(\"💡 **Recommendation:** Consider alternative packages or additional engagement strategies.\")\n",
+    "\n",
+    "            # Show probability breakdown\n",
+    "            col_prob1, col_prob2 = st.columns(2)\n",
+    "            with col_prob1:\n",
+    "                st.metric(\"Probability of No Purchase\", f\"{prediction_proba[0]*100:.2f}%\")\n",
+    "            with col_prob2:\n",
+    "                st.metric(\"Probability of Purchase\", f\"{prediction_proba[1]*100:.2f}%\")\n",
+    "\n",
+    "        except Exception as e:\n",
+    "            st.error(f\"Error making prediction: {e}\")\n",
+    "    else:\n",
+    "        st.error(\"Model not loaded. Please check the model repository.\")\n",
+    "\n",
+    "# Footer\n",
+    "st.markdown(\"---\")\n",
+    "st.markdown(\"\"\"\n",
+    "<div style='text-align: center; color: #666; padding: 20px;'>\n",
+    "    <p>🏢 Visit with Us - Wellness Tourism Package Prediction System</p>\n",
+    "    <p>Built with ❤️ using Streamlit and XGBoost</p>\n",
+    "</div>\n",
+    "\"\"\", unsafe_allow_html=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "07cYzWcIwTL-"
+   },
+   "source": [
+    "## Dependency Handling"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "JEgfHL64jU7o"
+   },
+   "source": [
+    "Please ensure that the dependency handling file is named `requirements.txt`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 4,
+     "status": "ok",
+     "timestamp": 1765705284460,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "nvdmy7Wd9lda",
+    "outputId": "16b57c41-8e07-49cc-d6c5-1f15240b59fe"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing tourism_project/deployment/requirements.txt\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%writefile tourism_project/deployment/requirements.txt\n",
+    "pandas==2.2.2\n",
+    "numpy==1.26.4\n",
+    "huggingface_hub==0.32.6\n",
+    "streamlit==1.43.2\n",
+    "joblib==1.5.1\n",
+    "scikit-learn==1.6.0\n",
+    "xgboost==2.1.4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "V4ynzpKNwWS_"
+   },
+   "source": [
+    "# Hosting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 1,
+     "status": "ok",
+     "timestamp": 1765705284460,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "7p5sBvTg9nCW"
+   },
+   "outputs": [],
+   "source": [
+    "os.makedirs(\"tourism_project/hosting\", exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 2,
+     "status": "ok",
+     "timestamp": 1765705284463,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "QlpgAQoXOtKA",
+    "outputId": "2611020e-c3cf-4dea-af77-ccb122c85e65"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing tourism_project/hosting/hosting.py\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%writefile tourism_project/hosting/hosting.py\n",
+    "from huggingface_hub import HfApi\n",
+    "import os\n",
+    "\n",
+    "api = HfApi(token=os.getenv(\"HF_TOKEN\"))\n",
+    "api.upload_folder(\n",
+    "    folder_path=\"tourism_project/deployment\",\n",
+    "    repo_id=\"ananttripathiak/wellness-tourism-prediction\",\n",
+    "    repo_type=\"space\",\n",
+    "    path_in_repo=\"\",\n",
+    ")\n",
+    "\n",
+    "print(\"Deployment files successfully uploaded to Hugging Face Space!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "PuCgAW2hktli"
+   },
+   "source": [
+    "# MLOps Pipeline with Github Actions Workflow"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "L5BZr5i8PKVN"
+   },
+   "source": [
+    "**Note:**\n",
+    "\n",
+    "1. Before running the file below, make sure to add the HF_TOKEN to your GitHub secrets to enable authentication between GitHub and Hugging Face.\n",
+    "2. The below code is for a sample YAML file that can be updated as required to meet the requirements of this project."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 10,
+     "status": "ok",
+     "timestamp": 1765705284474,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "H2kXyghROtKA"
+   },
+   "outputs": [],
+   "source": [
+    "os.makedirs(\"tourism_project/.github/workflows\", exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 5,
+     "status": "ok",
+     "timestamp": 1765705284479,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "M5J4Kq2ROtKA",
+    "outputId": "a9c5ad71-d5b5-41a0-823e-8739942162fb"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing tourism_project/.github/workflows/pipeline.yml\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%writefile tourism_project/.github/workflows/pipeline.yml\n",
+    "name: Tourism Package Prediction Pipeline\n",
+    "\n",
+    "on:\n",
+    "  push:\n",
+    "    branches:\n",
+    "      - main\n",
+    "\n",
+    "jobs:\n",
+    "\n",
+    "  register-dataset:\n",
+    "    runs-on: ubuntu-latest\n",
+    "    steps:\n",
+    "      - uses: actions/checkout@v3\n",
+    "      - name: Install Dependencies\n",
+    "        run: pip install -r tourism_project/requirements.txt\n",
+    "      - name: Upload Dataset to Hugging Face Hub\n",
+    "        env:\n",
+    "          HF_TOKEN: ${{ secrets.HF_TOKEN }}\n",
+    "        run: python tourism_project/model_building/data_register.py\n",
+    "\n",
+    "  data-prep:\n",
+    "    needs: register-dataset\n",
+    "    runs-on: ubuntu-latest\n",
+    "    steps:\n",
+    "      - uses: actions/checkout@v3\n",
+    "      - name: Install Dependencies\n",
+    "        run: pip install -r tourism_project/requirements.txt\n",
+    "      - name: Run Data Preparation\n",
+    "        env:\n",
+    "          HF_TOKEN: ${{ secrets.HF_TOKEN }}\n",
+    "        run: python tourism_project/model_building/prep.py\n",
+    "\n",
+    "  model-traning:\n",
+    "    needs: data-prep\n",
+    "    runs-on: ubuntu-latest\n",
+    "    steps:\n",
+    "      - uses: actions/checkout@v3\n",
+    "      - name: Install Dependencies\n",
+    "        run: pip install -r tourism_project/requirements.txt\n",
+    "      - name: Start MLflow Server\n",
+    "        run: |\n",
+    "          nohup mlflow ui --host 0.0.0.0 --port 5000 &\n",
+    "          sleep 5\n",
+    "      - name: Model Building\n",
+    "        env:\n",
+    "          HF_TOKEN: ${{ secrets.HF_TOKEN }}\n",
+    "        run: python tourism_project/model_building/train.py\n",
+    "\n",
+    "  deploy-hosting:\n",
+    "    runs-on: ubuntu-latest\n",
+    "    needs: [model-traning,data-prep,register-dataset]\n",
+    "    steps:\n",
+    "      - uses: actions/checkout@v3\n",
+    "      - name: Install Dependencies\n",
+    "        run: pip install -r tourism_project/requirements.txt\n",
+    "      - name: Push files to Frontend Hugging Face Space\n",
+    "        env:\n",
+    "          HF_TOKEN: ${{ secrets.HF_TOKEN }}\n",
+    "        run: python tourism_project/hosting/hosting.py\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "J029tYPq4Rmq"
+   },
+   "source": [
+    "```\n",
+    "name: Tourism Project Pipeline\n",
+    "\n",
+    "on:\n",
+    "  push:\n",
+    "    branches:\n",
+    "      - main  # Automatically triggers on push to the main branch\n",
+    "\n",
+    "jobs:\n",
+    "\n",
+    "  register-dataset:\n",
+    "    runs-on: ubuntu-latest\n",
+    "    steps:\n",
+    "      - uses: actions/checkout@v3\n",
+    "      - name: Install Dependencies\n",
+    "        run: <add_code_here>\n",
+    "      - name: Upload Dataset to Hugging Face Hub\n",
+    "        env:\n",
+    "          HF_TOKEN: ${{ secrets.HF_TOKEN }}\n",
+    "        run: <add_code_here>\n",
+    "\n",
+    "  data-prep:\n",
+    "    needs: register-dataset\n",
+    "    runs-on: ubuntu-latest\n",
+    "    steps:\n",
+    "      - uses: actions/checkout@v3\n",
+    "      - name: Install Dependencies\n",
+    "        run: <add_code_here>\n",
+    "      - name: Run Data Preparation\n",
+    "        env:\n",
+    "          HF_TOKEN: ${{ secrets.HF_TOKEN }}\n",
+    "        run: <add_code_here>\n",
+    "\n",
+    "\n",
+    "  model-traning:\n",
+    "    needs: data-prep\n",
+    "    runs-on: ubuntu-latest\n",
+    "    steps:\n",
+    "      - uses: actions/checkout@v3\n",
+    "      - name: Install Dependencies\n",
+    "        run: <add_code_here>\n",
+    "      - name: Start MLflow Server\n",
+    "        run: |\n",
+    "          nohup mlflow ui --host 0.0.0.0 --port 5000 &  # Run MLflow UI in the background\n",
+    "          sleep 5  # Wait for a moment to let the server starts\n",
+    "      - name: Model Building\n",
+    "        env:\n",
+    "          HF_TOKEN: ${{ secrets.HF_TOKEN }}\n",
+    "        run: <add_code_here>\n",
+    "\n",
+    "\n",
+    "  deploy-hosting:\n",
+    "    runs-on: ubuntu-latest\n",
+    "    needs: [model-traning,data-prep,register-dataset]\n",
+    "    steps:\n",
+    "      - uses: actions/checkout@v3\n",
+    "      - name: Install Dependencies\n",
+    "        run: <add_code_here>\n",
+    "      - name: Push files to Frontend Hugging Face Space\n",
+    "        env:\n",
+    "          HF_TOKEN: ${{ secrets.HF_TOKEN }}\n",
+    "        run: <add_code_here>\n",
+    "\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "T9fgZ_Mq3zzp"
+   },
+   "source": [
+    "**Note:** To use this YAML file for our use case, we need to\n",
+    "\n",
+    "1. Go to the GitHub repository for the project\n",
+    "2. Create a folder named ***.github/workflows/***\n",
+    "3. In the above folder, create a file named ***pipeline.yml***\n",
+    "4. Copy and paste the above content for the YAML file into the ***pipeline.yml*** file"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "PvEUJ-t5kdxH"
+   },
+   "source": [
+    "## Requirements file for the Github Actions Workflow"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 2,
+     "status": "ok",
+     "timestamp": 1765705284481,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "nfqWcLRm-dga",
+    "outputId": "ca9d9001-8154-47f1-809a-c2d62e51b4c2"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing tourism_project/requirements.txt\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%writefile tourism_project/requirements.txt\n",
+    "huggingface_hub==0.32.6\n",
+    "datasets==3.6.0\n",
+    "pandas==2.2.2\n",
+    "numpy==1.26.4\n",
+    "scikit-learn==1.6.0\n",
+    "xgboost==2.1.4\n",
+    "mlflow==3.0.1\n",
+    "joblib==1.5.1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "BA6mP-Ebkm3O"
+   },
+   "source": [
+    "## Github Authentication and Push Files"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "T84Ei-g9Z2uw"
+   },
+   "source": [
+    "* Before moving forward, we need to generate a secret token to push files directly from Colab to the GitHub repository.\n",
+    "* Please follow the below instructions to create the GitHub token:\n",
+    "    - Open your GitHub profile.\n",
+    "    - Click on ***Settings***.\n",
+    "    - Go to ***Developer Settings***.\n",
+    "    - Expand the ***Personal access tokens*** section and select ***Tokens (classic)***.\n",
+    "    - Click ***Generate new token***, then choose ***Generate new token (classic)***.\n",
+    "    - Add a note and select all required scopes.\n",
+    "    - Click ***Generate token***.\n",
+    "    - Copy the generated token and store it safely in a notepad."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 6682,
+     "status": "ok",
+     "timestamp": 1765705291163,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "KPDx4gqGh7cO",
+    "outputId": "47eb6218-6a20-4eae-ee1d-04c771d14101"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading package lists... Done\n",
+      "Building dependency tree... Done\n",
+      "Reading state information... Done\n",
+      "git is already the newest version (1:2.34.1-1ubuntu1.15).\n",
+      "0 upgraded, 0 newly installed, 0 to remove and 1 not upgraded.\n",
+      "Cloning into 'Tourism_Project'...\n",
+      "remote: Enumerating objects: 99, done.\u001b[K\n",
+      "remote: Counting objects: 100% (99/99), done.\u001b[K\n",
+      "remote: Compressing objects: 100% (89/89), done.\u001b[K\n",
+      "remote: Total 99 (delta 31), reused 0 (delta 0), pack-reused 0 (from 0)\u001b[K\n",
+      "Receiving objects: 100% (99/99), 111.21 KiB | 4.28 MiB/s, done.\n",
+      "Resolving deltas: 100% (31/31), done.\n",
+      "mv: cannot move '/content/tourism_project/' to '/content/Tourism_Project/tourism_project': Directory not empty\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Install Git\n",
+    "!apt-get install git\n",
+    "\n",
+    "# Set your Git identity (replace with your details)\n",
+    "!git config --global user.email \"ananttripathi1996@gmail.com\"\n",
+    "!git config --global user.name \"ananttripathi\"\n",
+    "\n",
+    "# Clone your GitHub repository\n",
+    "!git clone https://github.com/ananttripathi/Tourism_Project.git\n",
+    "\n",
+    "# Move your folder to the repository directory\n",
+    "!mv /content/tourism_project/ /content/Tourism_Project"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 435,
+     "status": "ok",
+     "timestamp": 1765705291611,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "IuUahCwVigon",
+    "outputId": "4ca2922a-9c3b-4bbe-ce2f-ef55236d9ba5"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/content/Tourism_Project\n",
+      "On branch main\n",
+      "Your branch is up to date with 'origin/main'.\n",
+      "\n",
+      "nothing to commit, working tree clean\n",
+      "Everything up-to-date\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Change directory to the cloned repository\n",
+    "%cd Tourism_Project/\n",
+    "\n",
+    "# Add the new folder to Git\n",
+    "!git add .\n",
+    "\n",
+    "# Commit the changes\n",
+    "!git commit -m \"first commit\"\n",
+    "\n",
+    "# Push to GitHub (you'll need your GitHub credentials; use a personal access token if 2FA enabled)\n",
+    "!git push https://ananttripathi:github_pat_11SPxp30Fxq@github.com/ananttripathi/Tourism_Project.git"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "v-i8Jdyz-_L1"
+   },
+   "source": [
+    "# Output Evaluation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FTK8Bpda_UHg"
+   },
+   "source": [
+    "- GitHub (link to repository, screenshot of folder structure and executed workflow)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 57,
+     "status": "ok",
+     "timestamp": 1765705291669,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "6qzzesaG_Xw8"
+   },
+   "outputs": [],
+   "source": [
+    "# TODO: Add Screenshot After Deployment\n",
+    "#\n",
+    "# After pushing to GitHub and running the workflow, add a screenshot showing:\n",
+    "# 1. GitHub repository structure (showing tourism_project folder and all subfolders)\n",
+    "# 2. GitHub Actions workflow execution (all 4 jobs completed successfully with green checkmarks)\n",
+    "#\n",
+    "# Screenshot should show:\n",
+    "# ✅ register-dataset job completed\n",
+    "# ✅ data-prep job completed\n",
+    "# ✅ model-training job completed\n",
+    "# ✅ deploy-hosting job completed\n",
+    "#\n",
+    "# You can also provide the GitHub repository URL here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 2,
+     "status": "ok",
+     "timestamp": 1765705291669,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "qXS_wjMdOtKM"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "IidBPl95OtKM"
+   },
+   "source": [
+    "![image.png](attachment:2a952d84-5287-492d-99cd-f5486c138f0e.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "P8QouFeUOtKM"
+   },
+   "source": [
+    "![image.png](attachment:13c64e4a-7f76-49ae-82bc-ce339e99accc.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3KDN31V2_YSr"
+   },
+   "source": [
+    "- Streamlit on Hugging Face (link to HF space, screenshot of Streamlit app)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 1,
+     "status": "ok",
+     "timestamp": 1765705291669,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "NuIUdj3b_ZYV"
+   },
+   "outputs": [],
+   "source": [
+    "# TODO: Add Screenshot After Deployment\n",
+    "#\n",
+    "# After the workflow completes and app is deployed, add a screenshot showing:\n",
+    "# 1. Live Streamlit app running on Hugging Face Spaces\n",
+    "# 2. Making a sample prediction with the interface\n",
+    "# 3. Prediction results displayed with confidence scores\n",
+    "#\n",
+    "# Also provide the Hugging Face Space URL:\n",
+    "# Expected format: https://huggingface.co/spaces/<your-username>/wellness-tourism-prediction\n",
+    "#\n",
+    "# Screenshot should show:\n",
+    "# ✅ App interface with input forms\n",
+    "# ✅ Prediction button\n",
+    "# ✅ Results with confidence scores\n",
+    "# ✅ Recommendations"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "tp06I8AnOtKM"
+   },
+   "source": [
+    "![image.png](attachment:67adea96-d2e2-49a4-b74b-1bcb763ddf53.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 1,
+     "status": "ok",
+     "timestamp": 1765705291669,
+     "user": {
+      "displayName": "Anant Tripathi",
+      "userId": "05588283814303116545"
+     },
+     "user_tz": -330
+    },
+    "id": "mK_xcFxlOtKM"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "zWAag1sAOtKM"
+   },
+   "source": [
+    "![image.png](attachment:2ef2ba58-64cb-4cc8-b9bb-957f4e9e5688.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fN8j9-3nW8G9"
+   },
+   "source": [
+    "<font size=6 color=\"navyblue\">Power Ahead!</font>\n",
+    "___"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernel_info": {
+   "name": "python310-sdkv2"
+  },
+  "kernelspec": {
+   "display_name": "Python [conda env:anaconda3] *",
+   "language": "python",
+   "name": "conda-env-anaconda3-py"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  },
+  "microsoft": {
+   "host": {
+    "AzureML": {
+     "notebookHasBeenCompleted": true
+    }
+   },
+   "ms_spell_check": {
+    "ms_spell_check_language": "en"
+   }
+  },
+  "nteract": {
+   "version": "nteract-front-end@1.0.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

README.md

@@ -1,10 +1,120 @@
----
-title: Engine Maintenance Space
-emoji: 🌖
-colorFrom: indigo
-colorTo: blue
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Predictive Maintenance – Engine Failure Classification (MLOps Project)
+
+> 🎯 **YOLO Achievement PR** - Merging without review to earn the GitHub YOLO badge!
+
+This project builds an end‑to‑end **predictive maintenance system** for small and large engines using sensor data (RPM, pressures, temperatures) to classify whether an engine is **healthy** or **requires maintenance**.
+
+The work is organized to satisfy the provided **interim and final report rubrics**, including:
+
+- **Data registration on Hugging Face**
+- **Exploratory Data Analysis (EDA)**
+- **Data preparation and dataset versioning**
+- **Model building with experimentation tracking**
+- **Model deployment with Docker + Streamlit on Hugging Face Spaces**
+- **Automated GitHub Actions workflow**
+
+### Repository Structure
+
+- `data/` – Raw and processed data (local copies).
+  - `engine_data.csv` – Original engine sensor dataset.
+- `notebooks/`
+  - EDA and experimentation notebooks (you can connect these to your report).
+- `src/`
+  - `config.py` – Central configuration (paths, Hugging Face repo names, MLflow config).
+  - `data_prep.py` – Loads data (from Hugging Face dataset/local), cleans it, and creates train/test splits.
+  - `hf_data_utils.py` – Helper functions for uploading/downloading datasets to/from Hugging Face.
+  - `train.py` – Model training, hyperparameter tuning, MLflow logging, and best‑model saving.
+  - `hf_model_utils.py` – Register and load the best model from the Hugging Face model hub.
+  - `inference.py` – Simple Python API for making predictions from the trained model.
+  - `app.py` – Streamlit app used for deployment on Hugging Face Spaces.
+  - `deploy_to_hf.py` – Script to push deployment files (app, Dockerfile, requirements) to a Hugging Face Space.
+- `.github/workflows/pipeline.yml` – Automated CI/CD workflow for data prep, training, and deployment.
+- `requirements.txt` – Python dependencies (for local use, CI, Docker, and HF Spaces).
+- `Dockerfile` – Container definition for running the Streamlit app.
+
+### High‑Level Pipeline (aligned with template notebook)
+
+1. **Data Registration**
+   - Script: `src/data_register.py`
+   - Behaviour similar to `data_register.py` in the reference notebook:
+     - Creates/uses a **Hugging Face dataset repo** (`HF_DATASET_REPO`),
+     - Uploads `data/engine_data.csv` as the canonical raw dataset.
+2. **EDA**
+   - Script: `src/eda.py` (or use a separate notebook) to perform:
+     - Data overview,
+     - Univariate, bivariate, multivariate analysis,
+     - Business insights about engine health and failure patterns.
+3. **Data Preparation**
+   - Script: `src/data_prep.py`
+   - Loads the raw data from the HF dataset (or local fallback), cleans it, creates train/test splits, and uploads `data/train.csv` and `data/test.csv` back to the dataset repo.
+4. **Model Building + Experiment Tracking**
+   - Script: `src/train.py`
+   - Loads train/test from the HF dataset or local files, trains and tunes a Random Forest classifier, logs all tuned parameters and metrics with **MLflow**, saves the best model locally, and registers it to a **Hugging Face model hub** repo.
+5. **Deployment & Hosting**
+   - Streamlit app: `src/app.py` (used by Docker / HF Space) loads the best model from HF (or local) and serves predictions.
+   - Containerisation: `Dockerfile` and `requirements.txt` define the runtime image and dependencies, matching the “deployment” section of the notebook.
+   - Hosting script: `src/deploy_to_hf.py` plays the role of `hosting.py` in the notebook, pushing the app, Dockerfile, and dependencies to a **Hugging Face Space**.
+6. **GitHub Actions Workflow**
+   - Workflow file: `.github/workflows/pipeline.yml`
+   - Defines four staged jobs mirroring the notebook:
+     - `register-dataset` → runs `src/data_register.py`
+     - `data-prep` → runs `src/data_prep.py`
+     - `model-training` → runs `src/train.py`
+     - `deploy-hosting` → runs `src/deploy_to_hf.py`
+   - All jobs share dependencies via `requirements.txt` and use GitHub secrets for HF credentials and repo IDs.
+
+### What You Need to Configure
+
+#### 1. Hugging Face Configuration
+
+**Update `src/config.py`** (lines 58-62) with your Hugging Face username:
+
+```python
+HF_DATASET_REPO = os.getenv("HF_DATASET_REPO", "your-username/engine-maintenance-dataset")
+HF_MODEL_REPO = os.getenv("HF_MODEL_REPO", "your-username/engine-maintenance-model")
+HF_SPACE_REPO = os.getenv("HF_SPACE_REPO", "your-username/engine-maintenance-space")
+```
+
+Replace `"your-username"` with your actual Hugging Face username (e.g., `"ananttripathi"`).
+
+**Or set environment variables:**
+```bash
+export HF_TOKEN="hf_your_token_here"
+export HF_DATASET_REPO="your-username/engine-maintenance-dataset"
+export HF_MODEL_REPO="your-username/engine-maintenance-model"
+export HF_SPACE_REPO="your-username/engine-maintenance-space"
+```
+
+#### 2. GitHub Repository Configuration
+
+**A. Create GitHub Repository:**
+1. Create a new repository on GitHub (e.g., `engine-predictive-maintenance`)
+2. Push this `mlops` folder to it:
+   ```bash
+   git init
+   git add .
+   git commit -m "Initial commit: Predictive maintenance MLOps pipeline"
+   git remote add origin https://github.com/your-username/engine-predictive-maintenance.git
+   git push -u origin main
+   ```
+
+**B. Add GitHub Secrets:**
+Go to your GitHub repo → **Settings** → **Secrets and variables** → **Actions** → **New repository secret**
+
+Add these 4 secrets:
+- `HF_TOKEN` – Your Hugging Face access token (from https://huggingface.co/settings/tokens)
+- `HF_DATASET_REPO` – e.g., `your-username/engine-maintenance-dataset`
+- `HF_MODEL_REPO` – e.g., `your-username/engine-maintenance-model`
+- `HF_SPACE_REPO` – e.g., `your-username/engine-maintenance-space`
+
+**C. Update README with GitHub Repo URL:**
+Add this section to your README (or in your final notebook):
+```markdown
+## GitHub Repository
+- **Repository URL**: https://github.com/your-username/engine-predictive-maintenance
+- **GitHub Actions**: https://github.com/your-username/engine-predictive-maintenance/actions
+```
+
+Once these values are set, you can run the scripts locally and/or via GitHub Actions to produce outputs that cover all the rubric sections (data registration, EDA, data prep, modeling, deployment, and automated workflow).
+
+**📖 For detailed setup instructions, see `CONFIGURATION_GUIDE.md`**

UPLOAD_GUIDE.md

@@ -0,0 +1,223 @@
+# File Upload Guide: Where Each File Goes
+
+This guide shows exactly which files are uploaded to which location (Hugging Face or GitHub) and when.
+
+---
+
+## Overview: Three Upload Destinations
+
+1. **Hugging Face Dataset Repo** (`ananttripathiak/engine-maintenance-dataset`)
+2. **Hugging Face Model Repo** (`ananttripathiak/engine-maintenance-model`)
+3. **Hugging Face Space** (`ananttripathiak/engine-maintenance-space`)
+4. **GitHub Repository** (`ananttripathi/engine-predictive-maintenance`)
+
+---
+
+## 1. Hugging Face Dataset Repo
+
+**Repo ID**: `ananttripathiak/engine-maintenance-dataset`  
+**Created by**: `src/data_register.py` and `src/data_prep.py`
+
+### Files Uploaded:
+
+#### A. Raw Data (via `src/data_register.py`)
+- **File**: `data/engine_data.csv`
+- **Uploaded to**: `data/engine_data.csv` in the dataset repo
+- **When**: Run `python src/data_register.py`
+
+#### B. Processed Data (via `src/data_prep.py`)
+- **File**: `data/processed/train.csv`
+- **Uploaded to**: `data/train.csv` in the dataset repo
+- **When**: Run `python src/data_prep.py`
+
+- **File**: `data/processed/test.csv`
+- **Uploaded to**: `data/test.csv` in the dataset repo
+- **When**: Run `python src/data_prep.py`
+
+**Scripts that upload here:**
+- `src/data_register.py` → uploads raw data
+- `src/data_prep.py` → uploads train/test splits
+
+---
+
+## 2. Hugging Face Model Repo
+
+**Repo ID**: `ananttripathiak/engine-maintenance-model`  
+**Created by**: `src/train.py`
+
+### Files Uploaded:
+
+- **File**: `models/best_model.joblib`
+- **Uploaded to**: `model.joblib` in the model repo
+- **When**: Run `python src/train.py` (after training completes)
+
+**Scripts that upload here:**
+- `src/train.py` → uploads the trained model
+
+---
+
+## 3. Hugging Face Space (Streamlit App)
+
+**Repo ID**: `ananttripathiak/engine-maintenance-space`  
+**Created by**: `src/deploy_to_hf.py`
+
+### Files Uploaded:
+
+The `src/deploy_to_hf.py` script uploads the entire project folder **except**:
+- `data/` (ignored - too large)
+- `mlruns/` (ignored - MLflow tracking data)
+- `models/` (ignored - model is in model repo)
+- `.github/` (ignored - GitHub-specific)
+
+**Files that ARE uploaded to Space:**
+- `src/app.py` ← **Main Streamlit app**
+- `src/inference.py` ← Inference utilities
+- `src/config.py` ← Configuration
+- `Dockerfile` ← Container definition
+- `requirements.txt` ← Python dependencies
+- `README.md` ← Documentation
+- Other `src/*.py` files (if needed by app)
+
+**Scripts that upload here:**
+- `src/deploy_to_hf.py` → uploads deployment files
+
+---
+
+## 4. GitHub Repository
+
+**Repo URL**: `https://github.com/ananttripathi/engine-predictive-maintenance`  
+**Created by**: You (manually via `git push`)
+
+### Files Uploaded:
+
+**Everything in the `mlops/` folder**, including:
+- ✅ `data/` (including `engine_data.csv`, `processed/train.csv`, `processed/test.csv`)
+- ✅ `src/` (all Python scripts)
+- ✅ `notebooks/` (EDA notebooks, etc.)
+- ✅ `.github/workflows/pipeline.yml` ← **GitHub Actions workflow**
+- ✅ `requirements.txt`
+- ✅ `Dockerfile`
+- ✅ `README.md`
+- ✅ `models/` (if you want to track model versions in git)
+- ✅ `mlruns/` (MLflow tracking data - optional)
+- ✅ All other project files
+
+**How to upload:**
+```bash
+cd /Users/ananttripathi/Desktop/mlops
+git init
+git add .
+git commit -m "Initial commit: Predictive maintenance MLOps pipeline"
+git remote add origin https://github.com/ananttripathi/engine-predictive-maintenance.git
+git push -u origin main
+```
+
+---
+
+## Upload Workflow Summary
+
+### Step-by-Step Upload Process:
+
+1. **Data Registration** → Hugging Face Dataset Repo
+   ```bash
+   python src/data_register.py
+   ```
+   - Uploads: `data/engine_data.csv` → HF Dataset Repo
+
+2. **Data Preparation** → Hugging Face Dataset Repo
+   ```bash
+   python src/data_prep.py
+   ```
+   - Uploads: `data/processed/train.csv` and `test.csv` → HF Dataset Repo
+
+3. **Model Training** → Hugging Face Model Repo
+   ```bash
+   python src/train.py
+   ```
+   - Uploads: `models/best_model.joblib` → HF Model Repo
+
+4. **Deploy App** → Hugging Face Space
+   ```bash
+   python src/deploy_to_hf.py
+   ```
+   - Uploads: `src/app.py`, `Dockerfile`, `requirements.txt`, etc. → HF Space
+
+5. **Push to GitHub** → GitHub Repository
+   ```bash
+   git add .
+   git commit -m "Complete MLOps pipeline"
+   git push origin main
+   ```
+   - Uploads: Everything → GitHub Repo
+
+---
+
+## What Gets Uploaded Automatically vs Manually
+
+### Automatic (via Scripts):
+- ✅ Hugging Face Dataset Repo → `src/data_register.py` and `src/data_prep.py`
+- ✅ Hugging Face Model Repo → `src/train.py`
+- ✅ Hugging Face Space → `src/deploy_to_hf.py`
+- ✅ GitHub Actions → Runs automatically when you push to GitHub
+
+### Manual:
+- ⚠️ **GitHub Repository** → You need to run `git push` yourself
+
+---
+
+## File Size Considerations
+
+### Large Files (may be ignored):
+- `data/engine_data.csv` → Uploaded to HF Dataset, but you might want to add to `.gitignore` for GitHub
+- `mlruns/` → MLflow tracking data (can be large) - ignored by HF Space deploy
+- `models/best_model.joblib` → Uploaded to HF Model Repo, but you might want to add to `.gitignore` for GitHub
+
+### Recommended `.gitignore`:
+```
+# Large data files
+data/*.csv
+data/processed/*.csv
+
+# MLflow tracking
+mlruns/
+
+# Model files (already in HF Model Repo)
+models/*.joblib
+
+# Python cache
+__pycache__/
+*.pyc
+.venv/
+```
+
+---
+
+## Quick Reference Table
+
+| File/Folder | HF Dataset | HF Model | HF Space | GitHub |
+|------------|------------|----------|----------|--------|
+| `data/engine_data.csv` | ✅ | ❌ | ❌ | ⚠️ Optional |
+| `data/processed/train.csv` | ✅ | ❌ | ❌ | ⚠️ Optional |
+| `data/processed/test.csv` | ✅ | ❌ | ❌ | ⚠️ Optional |
+| `models/best_model.joblib` | ❌ | ✅ | ❌ | ⚠️ Optional |
+| `src/app.py` | ❌ | ❌ | ✅ | ✅ |
+| `src/train.py` | ❌ | ❌ | ❌ | ✅ |
+| `src/data_prep.py` | ❌ | ❌ | ❌ | ✅ |
+| `Dockerfile` | ❌ | ❌ | ✅ | ✅ |
+| `requirements.txt` | ❌ | ❌ | ✅ | ✅ |
+| `.github/workflows/pipeline.yml` | ❌ | ❌ | ❌ | ✅ |
+| `README.md` | ❌ | ❌ | ✅ | ✅ |
+
+**Legend:**
+- ✅ = Uploaded automatically or should be uploaded
+- ❌ = Not uploaded to this location
+- ⚠️ Optional = Can be uploaded but might want to exclude from GitHub due to size
+
+---
+
+## Need Help?
+
+- **Hugging Face Dataset**: Check `src/hf_data_utils.py`
+- **Hugging Face Model**: Check `src/hf_model_utils.py`
+- **Hugging Face Space**: Check `src/deploy_to_hf.py`
+- **GitHub**: Standard git commands

USERNAME_SUMMARY.md

@@ -0,0 +1,69 @@
+# Username Configuration Summary
+
+## ✅ Updated Configuration
+
+All files have been updated with the correct usernames:
+
+- **Hugging Face Username**: `ananttripathiak` (with "ak" at the end)
+- **GitHub Username**: `ananttripathi` (no "ak")
+
+## Files Updated
+
+### 1. `src/config.py` ✅
+- **HF_DATASET_REPO**: `ananttripathiak/engine-maintenance-dataset`
+- **HF_MODEL_REPO**: `ananttripathiak/engine-maintenance-model`
+- **HF_SPACE_REPO**: `ananttripathiak/engine-maintenance-space`
+
+### 2. `README.md` ✅
+- Updated all Hugging Face repo examples to use `ananttripathiak`
+- GitHub repository URLs use `ananttripathi`
+
+### 3. `CONFIGURATION_GUIDE.md` ✅
+- Updated examples to show `ananttripathiak` for HF repos
+
+### 4. `GITHUB_REPO_INFO.md` ✅
+- Updated GitHub secrets examples to use `ananttripathiak` for HF repos
+- GitHub URLs use `ananttripathi`
+
+## What You Need to Do
+
+### 1. GitHub Secrets (in your GitHub repo settings)
+
+When you add secrets to your GitHub repository, use these exact values:
+
+- **`HF_TOKEN`**: Your Hugging Face access token
+- **`HF_DATASET_REPO`**: `ananttripathiak/engine-maintenance-dataset`
+- **`HF_MODEL_REPO`**: `ananttripathiak/engine-maintenance-model`
+- **`HF_SPACE_REPO`**: `ananttripathiak/engine-maintenance-space`
+
+### 2. Local Environment Variables (optional)
+
+If you want to override config.py, set these:
+
+```bash
+export HF_TOKEN="hf_your_token_here"
+export HF_DATASET_REPO="ananttripathiak/engine-maintenance-dataset"
+export HF_MODEL_REPO="ananttripathiak/engine-maintenance-model"
+export HF_SPACE_REPO="ananttripathiak/engine-maintenance-space"
+```
+
+### 3. GitHub Repository URLs
+
+Your GitHub repository will be:
+- **Repository**: `https://github.com/ananttripathi/engine-predictive-maintenance`
+- **Actions**: `https://github.com/ananttripathi/engine-predictive-maintenance/actions`
+
+### 4. Hugging Face Repos (will be created automatically)
+
+After running the scripts, these will be created:
+- **Dataset**: `https://huggingface.co/datasets/ananttripathiak/engine-maintenance-dataset`
+- **Model**: `https://huggingface.co/ananttripathiak/engine-maintenance-model`
+- **Space**: `https://huggingface.co/spaces/ananttripathiak/engine-maintenance-space`
+
+## Verification
+
+All configuration files are now correctly set. You can proceed with:
+1. Running the scripts locally
+2. Pushing to GitHub
+3. Setting up GitHub secrets
+4. Running the GitHub Actions workflow

WHAT_TO_UPLOAD.md

@@ -0,0 +1,265 @@
+# What to Upload: GitHub vs Hugging Face
+
+## Quick Summary
+
+| Destination | What to Upload | How |
+|------------|----------------|-----|
+| **GitHub** | **Everything** (entire project folder) | `git push` |
+| **HF Dataset** | Raw data + train/test splits | Scripts auto-upload |
+| **HF Model** | Trained model file | Scripts auto-upload |
+| **HF Space** | App files (code, Dockerfile, requirements) | Scripts auto-upload |
+
+---
+
+## 📦 GitHub Repository
+
+### Upload: **Everything in the `mlops/` folder**
+
+**What to include:**
+```
+mlops/
+├── data/
+│   ├── engine_data.csv          ✅ Upload
+│   └── processed/
+│       ├── train.csv            ✅ Upload
+│       └── test.csv             ✅ Upload
+├── src/
+│   ├── app.py                   ✅ Upload
+│   ├── config.py                ✅ Upload
+│   ├── data_prep.py             ✅ Upload
+│   ├── data_register.py         ✅ Upload
+│   ├── train.py                 ✅ Upload
+│   ├── inference.py             ✅ Upload
+│   ├── deploy_to_hf.py         ✅ Upload
+│   ├── eda.py                  ✅ Upload
+│   ├── hf_data_utils.py        ✅ Upload
+│   └── hf_model_utils.py       ✅ Upload
+├── notebooks/                   ✅ Upload (if you have EDA notebooks)
+├── models/
+│   └── best_model.joblib        ⚠️ Optional (large file)
+├── .github/
+│   └── workflows/
+│       └── pipeline.yml         ✅ Upload (IMPORTANT!)
+├── requirements.txt             ✅ Upload
+├── Dockerfile                   ✅ Upload
+├── README.md                    ✅ Upload
+└── *.md files                   ✅ Upload (documentation)
+
+❌ DON'T upload:
+├── .venv/                       ❌ Skip (virtual environment)
+├── __pycache__/                 ❌ Skip (Python cache)
+├── mlruns/                      ❌ Skip (MLflow tracking - can be large)
+└── .git/                        ❌ Skip (git metadata)
+```
+
+### How to Upload to GitHub:
+
+```bash
+cd /Users/ananttripathi/Desktop/mlops
+
+# Initialize git (if not already done)
+git init
+
+# Create .gitignore to exclude large/unnecessary files
+cat > .gitignore << EOF
+.venv/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+mlruns/
+*.log
+.DS_Store
+EOF
+
+# Add all files
+git add .
+
+# Commit
+git commit -m "Initial commit: Predictive Maintenance MLOps Pipeline"
+
+# Add remote (replace with your repo URL)
+git remote add origin https://github.com/ananttripathi/engine-predictive-maintenance.git
+
+# Push
+git push -u origin main
+```
+
+---
+
+## 🤗 Hugging Face - Dataset Repo
+
+**Repo**: `ananttripathiak/engine-maintenance-dataset`
+
+### Upload: **Data files only**
+
+**Files uploaded automatically by scripts:**
+- `data/engine_data.csv` → Uploaded as `data/engine_data.csv`
+- `data/processed/train.csv` → Uploaded as `data/train.csv`
+- `data/processed/test.csv` → Uploaded as `data/test.csv`
+
+### How to Upload:
+
+**Option 1: Run the scripts (automatic)**
+```bash
+# Step 1: Register raw data
+python src/data_register.py
+
+# Step 2: Prepare and upload train/test
+python src/data_prep.py
+```
+
+**Option 2: Manual upload via HF Hub**
+- Go to https://huggingface.co/datasets/ananttripathiak/engine-maintenance-dataset
+- Click "Add file" → Upload `data/engine_data.csv`
+- Upload `data/processed/train.csv` and `test.csv`
+
+---
+
+## 🤗 Hugging Face - Model Repo
+
+**Repo**: `ananttripathiak/engine-maintenance-model`
+
+### Upload: **Trained model file only**
+
+**File uploaded automatically:**
+- `models/best_model.joblib` → Uploaded as `model.joblib`
+
+### How to Upload:
+
+**Option 1: Run the training script (automatic)**
+```bash
+python src/train.py
+# This will:
+# 1. Train the model
+# 2. Save to models/best_model.joblib
+# 3. Upload to HF Model Repo automatically
+```
+
+**Option 2: Manual upload via HF Hub**
+- Go to https://huggingface.co/ananttripathiak/engine-maintenance-model
+- Click "Add file" → Upload `models/best_model.joblib`
+- Rename it to `model.joblib` in the repo
+
+---
+
+## 🤗 Hugging Face - Space (Streamlit App)
+
+**Repo**: `ananttripathiak/engine-maintenance-space`
+
+### Upload: **App deployment files**
+
+**Files uploaded automatically by script:**
+```
+✅ src/app.py                    (Main Streamlit app)
+✅ src/inference.py             (Inference utilities)
+✅ src/config.py                (Configuration)
+✅ Dockerfile                   (Container definition)
+✅ requirements.txt             (Dependencies)
+✅ README.md                    (Documentation)
+✅ Other src/*.py files         (If needed by app)
+
+❌ NOT uploaded (ignored):
+├── data/                       ❌ Too large
+├── mlruns/                     ❌ MLflow tracking
+├── models/                     ❌ Model is in Model Repo
+├── .github/                    ❌ GitHub-specific
+└── .venv/                      ❌ Virtual environment
+```
+
+### How to Upload:
+
+**Option 1: Run the deployment script (automatic)**
+```bash
+python src/deploy_to_hf.py
+# This will:
+# 1. Create/update the HF Space
+# 2. Upload all deployment files
+# 3. Configure it as a Streamlit app
+```
+
+**Option 2: Manual upload via HF Hub**
+- Go to https://huggingface.co/spaces/ananttripathiak/engine-maintenance-space
+- Upload files one by one or use HF CLI
+
+---
+
+## 📋 Complete Upload Checklist
+
+### ✅ Step 1: GitHub (Manual - Do First)
+- [ ] Create GitHub repository
+- [ ] Add `.gitignore` file
+- [ ] Push entire `mlops/` folder to GitHub
+- [ ] Add GitHub Secrets (HF_TOKEN, HF_DATASET_REPO, HF_MODEL_REPO, HF_SPACE_REPO)
+
+### ✅ Step 2: Hugging Face Dataset (Automatic)
+- [ ] Set `HF_TOKEN` environment variable
+- [ ] Run `python src/data_register.py` (uploads raw data)
+- [ ] Run `python src/data_prep.py` (uploads train/test)
+
+### ✅ Step 3: Hugging Face Model (Automatic)
+- [ ] Run `python src/train.py` (trains model and uploads to HF)
+
+### ✅ Step 4: Hugging Face Space (Automatic)
+- [ ] Run `python src/deploy_to_hf.py` (deploys app to HF Space)
+
+### ✅ Step 5: Verify
+- [ ] Check GitHub repo: https://github.com/ananttripathi/engine-predictive-maintenance
+- [ ] Check HF Dataset: https://huggingface.co/datasets/ananttripathiak/engine-maintenance-dataset
+- [ ] Check HF Model: https://huggingface.co/ananttripathiak/engine-maintenance-model
+- [ ] Check HF Space: https://huggingface.co/spaces/ananttripathiak/engine-maintenance-space
+
+---
+
+## 🎯 Key Differences
+
+| Aspect | GitHub | Hugging Face |
+|--------|--------|--------------|
+| **Purpose** | Code repository & version control | Data/Model/App hosting |
+| **What** | Entire project (code, data, docs) | Specific artifacts (data/model/app) |
+| **How** | Manual `git push` | Automatic via scripts |
+| **Size** | Can be large (includes everything) | Optimized (only what's needed) |
+| **Access** | Public/Private repo | Public datasets/models/spaces |
+| **CI/CD** | GitHub Actions workflow | HF Spaces auto-deploy |
+
+---
+
+## 💡 Pro Tips
+
+1. **GitHub First**: Always push to GitHub first, then run HF scripts
+2. **Use .gitignore**: Exclude large files like `mlruns/` and `.venv/` from GitHub
+3. **HF Scripts are Smart**: They automatically create repos if they don't exist
+4. **Check File Sizes**: HF has file size limits, so scripts exclude large files
+5. **GitHub Secrets**: Store HF credentials in GitHub Secrets for CI/CD
+
+---
+
+## 🚨 Common Mistakes to Avoid
+
+❌ **Don't upload to GitHub:**
+- Virtual environment (`.venv/`)
+- Large MLflow runs (`mlruns/`)
+- Python cache files (`__pycache__/`)
+
+❌ **Don't upload to HF Space:**
+- Raw data files (too large)
+- Model files (use Model Repo instead)
+- MLflow tracking data
+
+✅ **Do upload to GitHub:**
+- All source code
+- Configuration files
+- Documentation
+- GitHub Actions workflow
+
+✅ **Do upload to HF:**
+- Only what each repo type needs (data → Dataset, model → Model, app → Space)
+
+---
+
+## 📞 Need Help?
+
+- **GitHub Issues**: Check your repo settings and secrets
+- **HF Upload Errors**: Verify `HF_TOKEN` is set correctly
+- **File Size Issues**: Check HF file size limits (usually 10GB for datasets)

requirements.txt

@@ -0,0 +1,11 @@
+numpy
+pandas
+scikit-learn
+mlflow
+huggingface_hub
+streamlit
+joblib
+matplotlib
+seaborn
+plotly
+

src/app.py

@@ -0,0 +1,387 @@
+"""
+Enhanced Streamlit application for engine predictive maintenance.
+
+Intended to be run locally or deployed as a Hugging Face Space.
+Features an interactive, modern UI with real-time predictions,
+visualizations, and detailed insights.
+"""
+
+from __future__ import annotations
+
+import os
+import pandas as pd
+import plotly.graph_objects as go
+import plotly.express as px
+import streamlit as st
+
+import config
+from inference import predict_engine_condition
+
+
+def _get_default_source() -> str:
+    """Decide whether to load the model from HF or local based on env vars."""
+    if config.HF_TOKEN and config.HF_MODEL_REPO:
+        return "hf"
+    return "local"
+
+
+def create_gauge_chart(value: float, title: str, color: str) -> go.Figure:
+    """Create a gauge chart for sensor readings."""
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number",
+        value=value,
+        domain={'x': [0, 1], 'y': [0, 1]},
+        title={'text': title, 'font': {'size': 16}},
+        gauge={
+            'axis': {'range': [None, 100]},
+            'bar': {'color': color},
+            'steps': [
+                {'range': [0, 50], 'color': "lightgray"},
+                {'range': [50, 80], 'color': "gray"}
+            ],
+            'threshold': {
+                'line': {'color': "red", 'width': 4},
+                'thickness': 0.75,
+                'value': 90
+            }
+        }
+    ))
+    fig.update_layout(height=200, margin=dict(l=20, r=20, t=40, b=20))
+    return fig
+
+
+def create_sensor_comparison_chart(sensor_data: dict) -> go.Figure:
+    """Create a radar chart comparing sensor values."""
+    categories = list(sensor_data.keys())
+    values = list(sensor_data.values())
+    
+    # Normalize values for better visualization (0-100 scale)
+    max_values = {
+        "Engine_RPM": 4000,
+        "Lub_Oil_Pressure": 10,
+        "Fuel_Pressure": 30,
+        "Coolant_Pressure": 10,
+        "Lub_Oil_Temperature": 150,
+        "Coolant_Temperature": 150,
+    }
+    
+    normalized_values = [
+        (v / max_values.get(k, 100)) * 100 for k, v in zip(categories, values)
+    ]
+    
+    fig = go.Figure()
+    
+    fig.add_trace(go.Scatterpolar(
+        r=normalized_values + [normalized_values[0]],  # Close the loop
+        theta=[k.replace("_", " ") for k in categories] + [categories[0].replace("_", " ")],
+        fill='toself',
+        name='Current Readings',
+        line_color='#1f77b4'
+    ))
+    
+    fig.update_layout(
+        polar=dict(
+            radialaxis=dict(
+                visible=True,
+                range=[0, 100]
+            )),
+        showlegend=True,
+        height=400,
+        title="Sensor Readings Overview"
+    )
+    
+    return fig
+
+
+def main() -> None:
+    # MUST be first Streamlit command
+    st.set_page_config(
+        page_title="Engine Predictive Maintenance",
+        page_icon="🛠️",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+    
+    # Custom CSS for better styling
+    st.markdown("""
+    <style>
+        .main-header {
+            font-size: 2.5rem;
+            font-weight: bold;
+            color: #1f77b4;
+            text-align: center;
+            margin-bottom: 1rem;
+        }
+        .metric-card {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            padding: 1.5rem;
+            border-radius: 10px;
+            color: white;
+            text-align: center;
+            margin: 0.5rem 0;
+        }
+        .prediction-box {
+            padding: 2rem;
+            border-radius: 15px;
+            margin: 1.5rem 0;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+        .success-box {
+            background: linear-gradient(135deg, #11998e 0%, #38ef7d 100%);
+            color: white;
+        }
+        .warning-box {
+            background: linear-gradient(135deg, #ee0979 0%, #ff6a00 100%);
+            color: white;
+        }
+        .stSlider > div > div > div {
+            background-color: #1f77b4;
+        }
+        .stButton > button {
+            width: 100%;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            font-weight: bold;
+            font-size: 1.2rem;
+            padding: 0.75rem;
+            border-radius: 10px;
+            border: none;
+            transition: all 0.3s;
+        }
+        .stButton > button:hover {
+            transform: scale(1.05);
+            box-shadow: 0 5px 15px rgba(0, 0, 0, 0.3);
+        }
+    </style>
+    """, unsafe_allow_html=True)
+
+    # Compact Header
+    st.markdown('<h1 style="font-size: 2rem; text-align: center; color: #1f77b4; margin-bottom: 0.5rem;">🛠️ Engine Predictive Maintenance</h1>', unsafe_allow_html=True)
+    st.markdown('<p style="text-align: center; color: #666; margin-bottom: 1rem; font-size: 0.9rem;">AI-Powered Engine Health Monitoring & Failure Prediction</p>', unsafe_allow_html=True)
+
+    # Sidebar
+    with st.sidebar:
+        st.header("⚙�� Configuration")
+        
+        default_source = _get_default_source()
+        source = st.radio(
+            "📦 Model Source:",
+            options=["local", "hf"],
+            index=0 if default_source == "hf" else 1,
+            format_func=lambda x: "🤖 Hugging Face Hub" if x == "hf" else "💾 Local File",
+            help="Select where to load the trained model from"
+        )
+        
+        st.markdown("---")
+        
+        st.header("📊 Quick Stats")
+        if os.path.exists(config.BEST_MODEL_LOCAL_PATH):
+            st.success("✅ Model Available")
+            st.caption("Trained model found locally")
+        else:
+            st.warning("⚠️ Model Not Found")
+            st.caption("Run training script first")
+        
+        st.markdown("---")
+        
+        st.header("ℹ️ About")
+        st.markdown("""
+        This application uses machine learning to predict engine failures based on:
+        - Engine RPM
+        - Oil & Fuel Pressures
+        - Coolant Pressure
+        - Temperature Readings
+        
+        **Status**: 0 = Normal | 1 = Requires Maintenance
+        """)
+        
+        st.markdown("---")
+        st.caption("Built with ❤️ using Streamlit & Scikit-learn")
+
+    # Balanced layout - inputs on left, larger visualization on right
+    col_input, col_viz = st.columns([1, 1.2])
+    
+    with col_input:
+        # Input form
+        with st.form(key="engine_form", clear_on_submit=False):
+            st.markdown("### 🔧 Sensor Inputs")
+            
+            # 2 columns for inputs
+            col_a, col_b = st.columns(2)
+            
+            with col_a:
+                engine_rpm = st.number_input(
+                    "⚙️ Engine RPM",
+                    min_value=0.0,
+                    max_value=4000.0,
+                    value=800.0,
+                    step=10.0,
+                    help="Revolutions per minute"
+                )
+                lub_oil_pressure = st.number_input(
+                    "🛢️ Lub Oil Pressure",
+                    min_value=0.0,
+                    max_value=10.0,
+                    value=3.0,
+                    step=0.1,
+                    help="bar/kPa"
+                )
+                fuel_pressure = st.number_input(
+                    "⛽ Fuel Pressure",
+                    min_value=0.0,
+                    max_value=30.0,
+                    value=10.0,
+                    step=0.1,
+                    help="bar/kPa"
+                )
+            
+            with col_b:
+                coolant_pressure = st.number_input(
+                    "💧 Coolant Pressure",
+                    min_value=0.0,
+                    max_value=10.0,
+                    value=2.0,
+                    step=0.1,
+                    help="bar/kPa"
+                )
+                lub_oil_temp = st.number_input(
+                    "🌡️ Lub Oil Temp",
+                    min_value=0.0,
+                    max_value=150.0,
+                    value=80.0,
+                    step=0.5,
+                    help="°C"
+                )
+                coolant_temp = st.number_input(
+                    "🌡️ Coolant Temp",
+                    min_value=0.0,
+                    max_value=150.0,
+                    value=80.0,
+                    step=0.5,
+                    help="°C"
+                )
+            
+            submitted = st.form_submit_button("🚀 Predict Engine Condition", use_container_width=True)
+    
+    with col_viz:
+        st.markdown("### 📊 Sensor Visualization")
+        
+        # Real-time sensor visualization
+        sensor_data = {
+            "Engine_RPM": engine_rpm,
+            "Lub_Oil_Pressure": lub_oil_pressure,
+            "Fuel_Pressure": fuel_pressure,
+            "Coolant_Pressure": coolant_pressure,
+            "Lub_Oil_Temperature": lub_oil_temp,
+            "Coolant_Temperature": coolant_temp,
+        }
+        
+        # Larger, more readable radar chart
+        radar_fig = create_sensor_comparison_chart(sensor_data)
+        radar_fig.update_layout(height=450, margin=dict(l=40, r=40, t=50, b=40))  # Larger and more readable
+        st.plotly_chart(radar_fig, use_container_width=True, config={'displayModeBar': False})
+
+    # Prediction results
+    if submitted:
+        inputs = {
+            "Engine_RPM": engine_rpm,
+            "Lub_Oil_Pressure": lub_oil_pressure,
+            "Fuel_Pressure": fuel_pressure,
+            "Coolant_Pressure": coolant_pressure,
+            "Lub_Oil_Temperature": lub_oil_temp,
+            "Coolant_Temperature": coolant_temp,
+        }
+
+        with st.spinner("🤖 Loading model and analyzing sensor data..."):
+            try:
+                result = predict_engine_condition(inputs=inputs, source=source)
+            except Exception as e:
+                st.error(
+                    f"❌ **Prediction Failed**\n\n"
+                    f"Error: {str(e)}\n\n"
+                    f"**Troubleshooting:**\n"
+                    f"- Ensure the model is trained: `python src/train.py`\n"
+                    f"- Check model file exists: `models/best_model.joblib`\n"
+                    f"- Verify HF credentials if using Hugging Face Hub"
+                )
+                return
+
+        pred_label = result["prediction"]
+        prob_faulty = result["probability_faulty"]
+        prob_normal = 1 - prob_faulty
+
+        # Compact results section
+        st.markdown("---")
+        
+        result_col1, result_col2 = st.columns([1.5, 1])
+        
+        with result_col1:
+            if pred_label == 1:
+                st.markdown(
+                    f'<div class="prediction-box warning-box" style="padding: 1rem;">'
+                    f'<h2 style="color: white; margin: 0; font-size: 1.5rem;">🚨 MAINTENANCE REQUIRED</h2>'
+                    f'<p style="font-size: 1.1rem; margin: 0.5rem 0;">Engine is <b>LIKELY FAULTY</b> - Fault Probability: <b>{prob_faulty:.1%}</b></p>'
+                    f'</div>',
+                    unsafe_allow_html=True
+                )
+                with st.expander("🔧 Recommended Actions", expanded=False):
+                    st.markdown("""
+                    - Schedule immediate engine inspection
+                    - Verify sensor readings are accurate
+                    - Review maintenance history
+                    - Consult maintenance specialist
+                    """)
+            else:
+                st.markdown(
+                    f'<div class="prediction-box success-box" style="padding: 1rem;">'
+                    f'<h2 style="color: white; margin: 0; font-size: 1.5rem;">✅ ENGINE HEALTHY</h2>'
+                    f'<p style="font-size: 1.1rem; margin: 0.5rem 0;">Engine is <b>OPERATING NORMALLY</b> - Fault Probability: <b>{prob_faulty:.1%}</b></p>'
+                    f'</div>',
+                    unsafe_allow_html=True
+                )
+                st.success("✅ All sensors within normal ranges. Continue regular monitoring.")
+        
+        with result_col2:
+            # Compact probability gauge
+            fig = go.Figure(go.Indicator(
+                mode="gauge+number",
+                value=prob_faulty * 100,
+                domain={'x': [0, 1], 'y': [0, 1]},
+                title={'text': "Fault Risk %", 'font': {'size': 16}},
+                gauge={
+                    'axis': {'range': [None, 100]},
+                    'bar': {'color': "darkred" if pred_label == 1 else "darkgreen"},
+                    'steps': [
+                        {'range': [0, 30], 'color': "lightgreen"},
+                        {'range': [30, 70], 'color': "yellow"},
+                        {'range': [70, 100], 'color': "lightcoral"}
+                    ],
+                    'threshold': {
+                        'line': {'color': "red", 'width': 4},
+                        'thickness': 0.75,
+                        'value': 70
+                    }
+                }
+            ))
+            fig.update_layout(height=200, margin=dict(l=10, r=10, t=30, b=10))
+            st.plotly_chart(fig, use_container_width=True, config={'displayModeBar': False})
+            
+            # Compact metrics
+            col_m1, col_m2 = st.columns(2)
+            with col_m1:
+                st.metric("Normal", f"{prob_normal:.0%}")
+            with col_m2:
+                st.metric("Fault", f"{prob_faulty:.0%}")
+
+    # Compact Footer
+    st.markdown("---")
+    st.markdown("""
+    <div style='text-align: center; color: #666; padding: 0.5rem; font-size: 0.85rem;'>
+        <p>🛠️ <b>Predictive Maintenance System</b> | Built with Streamlit, Scikit-learn & Plotly | Developed by <b>Anant Tripathi</b></p>
+        <p style='font-size: 0.75rem; color: #888; margin-top: 0.25rem;'>⚠️ Use as decision-support tool, not replacement for expert diagnostics</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+if __name__ == "__main__":
+    main()

src/config.py

@@ -0,0 +1,89 @@
+import os
+from pathlib import Path
+
+"""
+Central configuration for the predictive maintenance project.
+
+Update the Hugging Face repo IDs to match your own account, or
+set them via environment variables.
+"""
+
+# Handle both local execution and GitHub Actions
+if Path(__file__).resolve().name == "config.py":
+    # Running from src/ directory
+    PROJECT_ROOT = Path(__file__).resolve().parents[1]
+else:
+    # Running as module
+    PROJECT_ROOT = Path(__file__).resolve().parent.parent
+
+# -------------------------------------------------------------------------
+# Data paths
+# -------------------------------------------------------------------------
+DATA_DIR = PROJECT_ROOT / "data"
+RAW_DATA_FILE = DATA_DIR / "engine_data.csv"
+PROCESSED_DIR = DATA_DIR / "processed"
+PROCESSED_DIR.mkdir(parents=True, exist_ok=True)
+
+TRAIN_FILE = PROCESSED_DIR / "train.csv"
+TEST_FILE = PROCESSED_DIR / "test.csv"
+
+# -------------------------------------------------------------------------
+# Target and feature configuration
+# -------------------------------------------------------------------------
+# Raw CSV column names (as they appear in engine_data.csv)
+RAW_COLUMN_RENAME_MAP = {
+    "Engine rpm": "Engine_RPM",
+    "Lub oil pressure": "Lub_Oil_Pressure",
+    "Fuel pressure": "Fuel_Pressure",
+    "Coolant pressure": "Coolant_Pressure",
+    "lub oil temp": "Lub_Oil_Temperature",
+    "Coolant temp": "Coolant_Temperature",
+    "Engine Condition": "Engine_Condition",
+}
+
+TARGET_COLUMN = "Engine_Condition"
+
+FEATURE_COLUMNS = [
+    "Engine_RPM",
+    "Lub_Oil_Pressure",
+    "Fuel_Pressure",
+    "Coolant_Pressure",
+    "Lub_Oil_Temperature",
+    "Coolant_Temperature",
+]
+
+RANDOM_STATE = 42
+TEST_SIZE = float(os.getenv("TEST_SIZE", "0.2"))
+
+# -------------------------------------------------------------------------
+# Hugging Face configuration
+# -------------------------------------------------------------------------
+HF_TOKEN = os.getenv("HF_TOKEN")  # set this in your environment or GitHub secrets
+
+# Default repo IDs can be overridden via environment variables
+# Hugging Face username: ananttripathiak
+# GitHub username: ananttripathi
+HF_DATASET_REPO = os.getenv(
+    "HF_DATASET_REPO", "ananttripathiak/engine-maintenance-dataset"
+)
+HF_MODEL_REPO = os.getenv("HF_MODEL_REPO", "ananttripathiak/engine-maintenance-model")
+HF_SPACE_REPO = os.getenv("HF_SPACE_REPO", "ananttripathiak/engine-maintenance-space")
+
+# -------------------------------------------------------------------------
+# MLflow configuration
+# -------------------------------------------------------------------------
+MLFLOW_TRACKING_URI = os.getenv(
+    "MLFLOW_TRACKING_URI", (PROJECT_ROOT / "mlruns").as_uri()
+)
+MLFLOW_EXPERIMENT_NAME = os.getenv(
+    "MLFLOW_EXPERIMENT_NAME", "engine_predictive_maintenance"
+)
+
+# -------------------------------------------------------------------------
+# Model artifacts
+# -------------------------------------------------------------------------
+MODELS_DIR = PROJECT_ROOT / "models"
+MODELS_DIR.mkdir(parents=True, exist_ok=True)
+
+BEST_MODEL_LOCAL_PATH = MODELS_DIR / "best_model.joblib"
+

src/data_prep.py

@@ -0,0 +1,154 @@
+"""
+Data preparation script for the predictive maintenance project.
+
+Responsibilities:
+- Load the raw engine dataset from the Hugging Face dataset repo (preferred)
+  or from the local data folder as a fallback.
+- Clean and preprocess the data (rename columns, handle missing values,
+  drop duplicates, basic sanity checks).
+- Split the cleaned data into train and test sets.
+- Save train and test CSVs locally.
+- Upload the resulting train and test CSVs back to the Hugging Face dataset repo.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Tuple
+
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+import config
+from hf_data_utils import download_dataset_file, upload_dataset_file
+
+
+def _load_raw_data_from_hf_or_local() -> pd.DataFrame:
+    """
+    Try to load the raw dataset from the Hugging Face dataset repo.
+    If that fails (e.g., no token or repo yet), fall back to the local CSV.
+    """
+    # Preferred: load from HF dataset repo if token and repo are configured
+    if config.HF_TOKEN and config.HF_DATASET_REPO:
+        try:
+            remote_path = download_dataset_file(
+                filename="data/engine_data.csv",
+                repo_id=config.HF_DATASET_REPO,
+                token=config.HF_TOKEN,
+                local_dir=config.DATA_DIR,
+            )
+            return pd.read_csv(remote_path)
+        except Exception:
+            # Fall back to local file
+            pass
+
+    # Local fallback
+    if not config.RAW_DATA_FILE.exists():
+        raise FileNotFoundError(
+            f"Raw data file not found at {config.RAW_DATA_FILE}. "
+            "Ensure engine_data.csv exists or upload it to the HF dataset repo."
+        )
+
+    return pd.read_csv(config.RAW_DATA_FILE)
+
+
+def _clean_data(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Perform basic cleaning and feature engineering.
+    """
+    # Standardize column names
+    df = df.rename(columns=config.RAW_COLUMN_RENAME_MAP)
+
+    # Keep only the expected columns (drop any extras, if present)
+    expected_cols = set(config.FEATURE_COLUMNS + [config.TARGET_COLUMN])
+    df = df[[col for col in df.columns if col in expected_cols]]
+
+    # Drop duplicate rows
+    df = df.drop_duplicates().reset_index(drop=True)
+
+    # Handle missing values: for this numeric dataset, fill with median
+    if df.isna().any().any():
+        df = df.fillna(df.median(numeric_only=True))
+
+    # Ensure target is integer/binary
+    df[config.TARGET_COLUMN] = df[config.TARGET_COLUMN].astype(int)
+
+    return df
+
+
+def _train_test_split(
+    df: pd.DataFrame,
+) -> Tuple[pd.DataFrame, pd.DataFrame]:
+    """
+    Split the cleaned dataframe into train and test sets.
+    """
+    X = df[config.FEATURE_COLUMNS]
+    y = df[config.TARGET_COLUMN]
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X,
+        y,
+        test_size=config.TEST_SIZE,
+        random_state=config.RANDOM_STATE,
+        stratify=y,
+    )
+
+    train_df = X_train.copy()
+    train_df[config.TARGET_COLUMN] = y_train
+
+    test_df = X_test.copy()
+    test_df[config.TARGET_COLUMN] = y_test
+
+    return train_df, test_df
+
+
+def main() -> None:
+    """
+    Execute the full data preparation pipeline.
+    """
+    print("Loading raw data...")
+    raw_df = _load_raw_data_from_hf_or_local()
+    print(f"Raw data shape: {raw_df.shape}")
+
+    print("Cleaning data...")
+    clean_df = _clean_data(raw_df)
+    print(f"Clean data shape: {clean_df.shape}")
+
+    print("Performing train/test split...")
+    train_df, test_df = _train_test_split(clean_df)
+    print(f"Train shape: {train_df.shape}, Test shape: {test_df.shape}")
+
+    # Save locally
+    config.PROCESSED_DIR.mkdir(parents=True, exist_ok=True)
+    train_df.to_csv(config.TRAIN_FILE, index=False)
+    test_df.to_csv(config.TEST_FILE, index=False)
+    print(f"Saved train to {config.TRAIN_FILE}")
+    print(f"Saved test to {config.TEST_FILE}")
+
+    # Upload to HF dataset repo, if configured
+    if config.HF_TOKEN and config.HF_DATASET_REPO:
+        try:
+            print("Uploading train and test splits to Hugging Face dataset repo...")
+            upload_dataset_file(
+                local_path=config.TRAIN_FILE,
+                repo_id=config.HF_DATASET_REPO,
+                repo_path="data/train.csv",
+                token=config.HF_TOKEN,
+            )
+            upload_dataset_file(
+                local_path=config.TEST_FILE,
+                repo_id=config.HF_DATASET_REPO,
+                repo_path="data/test.csv",
+                token=config.HF_TOKEN,
+            )
+            print("Upload to Hugging Face completed.")
+        except Exception as e:
+            print(
+                f"Warning: Failed to upload train/test to Hugging Face dataset repo: {e}"
+            )
+
+
+if __name__ == "__main__":
+    main()
+

src/data_register.py

@@ -0,0 +1,59 @@
+"""
+Data registration script for the predictive maintenance project.
+
+This script is the analogue of the notebook's `data_register.py`:
+- It ensures the Hugging Face dataset repo exists.
+- It uploads the raw engine dataset from the local `data/` folder
+  into the dataset repo so it can be consumed by other stages
+  (EDA, data preparation, model training) using a consistent source.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+try:
+    import config
+    from hf_data_utils import register_raw_engine_data_to_hf
+except ImportError as e:
+    print(f"ERROR: Failed to import modules: {e}", file=sys.stderr)
+    print(f"Python path: {sys.path}", file=sys.stderr)
+    sys.exit(1)
+
+
+def main() -> None:
+    try:
+        print(f"PROJECT_ROOT: {config.PROJECT_ROOT}")
+        print(f"RAW_DATA_FILE: {config.RAW_DATA_FILE}")
+        print(f"RAW_DATA_FILE exists: {config.RAW_DATA_FILE.exists()}")
+        print(f"HF_DATASET_REPO: {config.HF_DATASET_REPO}")
+        print(f"HF_TOKEN is set: {bool(config.HF_TOKEN)}")
+        
+        if not config.RAW_DATA_FILE.exists():
+            raise FileNotFoundError(
+                f"Expected raw data at {config.RAW_DATA_FILE}, "
+                "but the file does not exist. Make sure `engine_data.csv` "
+                "is placed in the `data/` folder."
+            )
+
+        if not config.HF_TOKEN:
+            raise ValueError(
+                "HF_TOKEN is not set. Please set it as an environment variable "
+                "or in GitHub Secrets."
+            )
+
+        print(f"Registering raw engine dataset from: {config.RAW_DATA_FILE}")
+        print(f"Target HF dataset repo: {config.HF_DATASET_REPO}")
+        register_raw_engine_data_to_hf()
+        print("✅ Dataset registration to Hugging Face completed.")
+    except Exception as e:
+        print(f"ERROR: {type(e).__name__}: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
+

src/deploy_to_hf.py

@@ -0,0 +1,68 @@
+"""
+Helper script to push the Streamlit app and deployment files
+to a Hugging Face Space.
+
+This script mirrors the behaviour of the notebook's `hosting.py`:
+- Ensures the Space exists (creating it if necessary),
+- Uploads only the files required for deployment (code, Dockerfile,
+  and requirements), excluding data, MLflow artifacts, etc.
+"""
+
+from __future__ import annotations
+
+import os
+
+from huggingface_hub import HfApi
+
+import config
+
+
+def main() -> None:
+    token = config.HF_TOKEN or os.getenv("HF_TOKEN")
+    if not token:
+        raise ValueError(
+            "HF_TOKEN is not set. Please export HF_TOKEN or configure it in config.py."
+        )
+
+    space_repo = config.HF_SPACE_REPO or os.getenv("HF_SPACE_REPO")
+    if not space_repo:
+        raise ValueError(
+            "HF_SPACE_REPO is not set. Set it as an environment variable or in config.py."
+        )
+
+    api = HfApi(token=token)
+
+    # Create the Space if it does not exist
+    # Use "docker" SDK since we're deploying with Dockerfile
+    api.create_repo(
+        repo_id=space_repo,
+        repo_type="space",
+        space_sdk="docker",
+        exist_ok=True,
+    )
+
+    # Upload project files needed for deployment.
+    # We ignore large local artifacts like raw data, mlruns, and models,
+    # similar to how the reference notebook uploads only the deployment folder.
+    api.upload_folder(
+        folder_path=str(config.PROJECT_ROOT),
+        path_in_repo=".",
+        repo_id=space_repo,
+        repo_type="space",
+        ignore_patterns=[
+            "data/*",
+            "mlruns/*",
+            "models/*",
+            ".git/*",
+            "__pycache__/*",
+            ".github/*",
+        ],
+    )
+
+    print(f"Deployment files pushed to Hugging Face Space: {space_repo}")
+
+
+if __name__ == "__main__":
+    main()
+
+

src/eda.py

@@ -0,0 +1,85 @@
+"""
+Exploratory Data Analysis (EDA) script for the predictive maintenance project.
+
+This script covers:
+- Data overview (shape, types, missing values, basic statistics)
+- Univariate analysis (distributions of features, target balance)
+- Bivariate/multivariate analysis (correlations and pairwise relationships)
+
+Figures are saved under `notebooks/figures/` for easy inclusion in reports.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+import config
+from data_prep import _clean_data, _load_raw_data_from_hf_or_local
+
+
+FIGURES_DIR = config.PROJECT_ROOT / "notebooks" / "figures"
+FIGURES_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def run_eda() -> None:
+    # Load and clean data using the same logic as the pipeline
+    raw_df = _load_raw_data_from_hf_or_local()
+    df = _clean_data(raw_df)
+
+    print("=== DATA OVERVIEW ===")
+    print(f"Shape: {df.shape}")
+    print("\nData types:")
+    print(df.dtypes)
+    print("\nMissing values per column:")
+    print(df.isna().sum())
+    print("\nSummary statistics:")
+    print(df.describe())
+
+    # Univariate analysis: target distribution
+    plt.figure(figsize=(4, 4))
+    sns.countplot(x=config.TARGET_COLUMN, data=df)
+    plt.title("Engine Condition Distribution")
+    plt.xlabel("Engine Condition (0 = Normal, 1 = Faulty)")
+    plt.ylabel("Count")
+    plt.tight_layout()
+    plt.savefig(FIGURES_DIR / "target_distribution.png")
+    plt.close()
+
+    # Univariate analysis: histograms for features
+    df[config.FEATURE_COLUMNS].hist(bins=30, figsize=(12, 8))
+    plt.suptitle("Feature Distributions", y=1.02)
+    plt.tight_layout()
+    plt.savefig(FIGURES_DIR / "feature_histograms.png")
+    plt.close()
+
+    # Correlation heatmap (multivariate)
+    plt.figure(figsize=(8, 6))
+    corr = df[config.FEATURE_COLUMNS + [config.TARGET_COLUMN]].corr()
+    sns.heatmap(corr, annot=True, cmap="coolwarm", fmt=".2f")
+    plt.title("Correlation Heatmap")
+    plt.tight_layout()
+    plt.savefig(FIGURES_DIR / "correlation_heatmap.png")
+    plt.close()
+
+    # Pairplot for a subset of features (bivariate relationships)
+    subset_cols = ["Engine_RPM", "Lub_Oil_Pressure", "Fuel_Pressure", config.TARGET_COLUMN]
+    sns.pairplot(
+        df[subset_cols],
+        hue=config.TARGET_COLUMN,
+        diag_kind="hist",
+        corner=True,
+    )
+    plt.suptitle("Pairwise Relationships (subset of features)", y=1.02)
+    plt.tight_layout()
+    plt.savefig(FIGURES_DIR / "pairplot_subset.png")
+    plt.close()
+
+    print(f"\nEDA figures saved to: {FIGURES_DIR}")
+
+
+if __name__ == "__main__":
+    run_eda()
+

src/hf_data_utils.py

@@ -0,0 +1,143 @@
+"""
+Utility functions for interacting with the Hugging Face Hub for DATASETS.
+
+These helpers are used to:
+- Register the raw engine dataset as a Hugging Face dataset repo.
+- Upload processed train/test splits back to the dataset repo.
+- Download files from the dataset repo for use in data preparation and modeling.
+
+All functions expect a valid HF token to be available, typically via:
+- The HF_TOKEN environment variable, or
+- An explicit argument.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+from huggingface_hub import HfApi, hf_hub_download
+
+import config
+
+
+def _get_token(explicit_token: Optional[str] = None) -> str:
+    token = explicit_token or config.HF_TOKEN
+    if not token:
+        raise ValueError(
+            "Hugging Face token is not set. "
+            "Set HF_TOKEN in the environment or pass token explicitly."
+        )
+    return token
+
+
+def create_or_get_dataset_repo(
+    repo_id: str, token: Optional[str] = None, private: bool = False
+) -> None:
+    """
+    Create the dataset repo on Hugging Face Hub if it does not already exist.
+    """
+    token = _get_token(token)
+    api = HfApi(token=token)
+    api.create_repo(
+        repo_id=repo_id,
+        repo_type="dataset",
+        private=private,
+        exist_ok=True,
+    )
+
+
+def upload_dataset_file(
+    local_path: Path,
+    repo_id: Optional[str] = None,
+    repo_path: Optional[str] = None,
+    token: Optional[str] = None,
+) -> None:
+    """
+    Upload a single file to the Hugging Face dataset repo.
+
+    Parameters
+    ----------
+    local_path : Path
+        The local file to upload.
+    repo_id : str, optional
+        The dataset repo ID (e.g., 'username/engine-maintenance-dataset').
+        Defaults to config.HF_DATASET_REPO.
+    repo_path : str, optional
+        The path inside the repo (e.g., 'data/train.csv'). Defaults to the
+        file name if not provided.
+    token : str, optional
+        Hugging Face token. Defaults to config.HF_TOKEN.
+    """
+    token = _get_token(token)
+    repo_id = repo_id or config.HF_DATASET_REPO
+    repo_path = repo_path or local_path.name
+
+    api = HfApi(token=token)
+    create_or_get_dataset_repo(repo_id=repo_id, token=token)
+
+    api.upload_file(
+        path_or_fileobj=str(local_path),
+        path_in_repo=repo_path,
+        repo_id=repo_id,
+        repo_type="dataset",
+    )
+
+
+def download_dataset_file(
+    filename: str,
+    repo_id: Optional[str] = None,
+    token: Optional[str] = None,
+    local_dir: Optional[Path] = None,
+) -> Path:
+    """
+    Download a file from the Hugging Face dataset repo and return its local path.
+
+    Parameters
+    ----------
+    filename : str
+        The filename inside the dataset repo (e.g., 'data/engine_data.csv').
+    repo_id : str, optional
+        The dataset repo ID. Defaults to config.HF_DATASET_REPO.
+    token : str, optional
+        Hugging Face token.
+    local_dir : Path, optional
+        Directory to place the downloaded file. Defaults to config.DATA_DIR.
+    """
+    token = _get_token(token)
+    repo_id = repo_id or config.HF_DATASET_REPO
+    local_dir = local_dir or config.DATA_DIR
+    local_dir.mkdir(parents=True, exist_ok=True)
+
+    downloaded_path = hf_hub_download(
+        repo_id=repo_id,
+        filename=filename,
+        repo_type="dataset",
+        token=token,
+        local_dir=str(local_dir),
+        local_dir_use_symlinks=False,
+    )
+    return Path(downloaded_path)
+
+
+def register_raw_engine_data_to_hf(
+    token: Optional[str] = None,
+    repo_id: Optional[str] = None,
+) -> None:
+    """
+    Convenience function to register the original engine_data.csv
+    in the dataset repo under 'data/engine_data.csv'.
+    """
+    repo_id = repo_id or config.HF_DATASET_REPO
+    local_path = config.RAW_DATA_FILE
+    if not local_path.exists():
+        raise FileNotFoundError(
+            f"Raw data file not found at {local_path}. "
+            "Ensure engine_data.csv is present in the data/ folder."
+        )
+
+    upload_dataset_file(
+        local_path=local_path,
+        repo_id=repo_id,
+        repo_path="data/engine_data.csv",
+        token=token,
+    )
+

src/hf_model_utils.py

@@ -0,0 +1,91 @@
+"""
+Utility functions for interacting with the Hugging Face Hub for MODELS.
+
+Used to:
+- Upload the best trained model to a model repo.
+- Download the registered model for inference or deployment.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import joblib
+from huggingface_hub import HfApi, hf_hub_download
+
+import config
+
+
+def _get_token(explicit_token: Optional[str] = None) -> str:
+    token = explicit_token or config.HF_TOKEN
+    if not token:
+        raise ValueError(
+            "Hugging Face token is not set. "
+            "Set HF_TOKEN in the environment or pass token explicitly."
+        )
+    return token
+
+
+def create_or_get_model_repo(
+    repo_id: str, token: Optional[str] = None, private: bool = False
+) -> None:
+    """
+    Create the model repo on Hugging Face Hub if it does not already exist.
+    """
+    token = _get_token(token)
+    api = HfApi(token=token)
+    api.create_repo(
+        repo_id=repo_id,
+        repo_type="model",
+        private=private,
+        exist_ok=True,
+    )
+
+
+def upload_model(
+    local_model_path: Path,
+    repo_id: Optional[str] = None,
+    repo_path: str = "model.joblib",
+    token: Optional[str] = None,
+) -> None:
+    """
+    Upload the trained model artifact to the Hugging Face model hub.
+    """
+    token = _get_token(token)
+    repo_id = repo_id or config.HF_MODEL_REPO
+
+    api = HfApi(token=token)
+    create_or_get_model_repo(repo_id=repo_id, token=token)
+
+    api.upload_file(
+        path_or_fileobj=str(local_model_path),
+        path_in_repo=repo_path,
+        repo_id=repo_id,
+        repo_type="model",
+    )
+
+
+def download_model(
+    repo_id: Optional[str] = None,
+    filename: str = "model.joblib",
+    token: Optional[str] = None,
+    local_dir: Optional[Path] = None,
+):
+    """
+    Download a model artifact from the Hugging Face model hub and load it.
+    """
+    token = _get_token(token)
+    repo_id = repo_id or config.HF_MODEL_REPO
+    local_dir = local_dir or config.MODELS_DIR
+    local_dir.mkdir(parents=True, exist_ok=True)
+
+    downloaded_path = hf_hub_download(
+        repo_id=repo_id,
+        filename=filename,
+        repo_type="model",
+        token=token,
+        local_dir=str(local_dir),
+        local_dir_use_symlinks=False,
+    )
+
+    return joblib.load(downloaded_path)
+

src/inference.py

@@ -0,0 +1,97 @@
+"""
+Inference utilities for the predictive maintenance model.
+
+These functions are used both by scripts and by the Streamlit app
+to load a trained model (from local storage or Hugging Face) and
+generate predictions from raw sensor values.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, Iterable, Optional
+
+import joblib
+import numpy as np
+import pandas as pd
+
+import config
+from hf_model_utils import download_model
+
+
+def load_local_model() -> object:
+    """
+    Load the best trained model from the local models directory.
+    """
+    if not config.BEST_MODEL_LOCAL_PATH.exists():
+        raise FileNotFoundError(
+            f"Local model not found at {config.BEST_MODEL_LOCAL_PATH}. "
+            "Run train.py to create it, or configure HF model loading."
+        )
+    return joblib.load(config.BEST_MODEL_LOCAL_PATH)
+
+
+def load_hf_model() -> object:
+    """
+    Load the model directly from the Hugging Face model hub.
+    """
+    return download_model()
+
+
+def build_input_dataframe(
+    inputs: Dict[str, float],
+) -> pd.DataFrame:
+    """
+    Convert a dictionary of feature values into a single-row DataFrame
+    with columns ordered according to config.FEATURE_COLUMNS.
+    """
+    data = {col: float(inputs.get(col, 0.0)) for col in config.FEATURE_COLUMNS}
+    return pd.DataFrame([data])
+
+
+def predict_engine_condition(
+    inputs: Dict[str, float],
+    model: Optional[object] = None,
+    source: str = "local",
+) -> Dict[str, float]:
+    """
+    Predict whether the engine requires maintenance.
+
+    Parameters
+    ----------
+    inputs : dict
+        Keys correspond to feature names in config.FEATURE_COLUMNS.
+    model : object, optional
+        Pre-loaded sklearn Pipeline model. If None, it will be loaded
+        from `source`.
+    source : {'local', 'hf'}
+        If model is None, determines where to load it from.
+
+    Returns
+    -------
+    dict
+        Contains the predicted class label (0/1) and the probability
+        of the positive class.
+    """
+    if model is None:
+        if source == "hf":
+            model = load_hf_model()
+        else:
+            model = load_local_model()
+
+    df = build_input_dataframe(inputs)
+    proba = model.predict_proba(df)[0, 1]
+    pred = int(proba >= 0.5)
+
+    return {
+        "prediction": pred,
+        "probability_faulty": float(proba),
+    }
+
+
+__all__ = [
+    "load_local_model",
+    "load_hf_model",
+    "build_input_dataframe",
+    "predict_engine_condition",
+]
+

src/train.py

@@ -0,0 +1,202 @@
+"""
+Model training and experimentation tracking script.
+
+Responsibilities:
+- Load prepared train and test datasets (preferably from Hugging Face dataset repo).
+- Define a model pipeline (Random Forest by default) and hyperparameter search space.
+- Run hyperparameter tuning with cross-validation.
+- Log all tuned parameters and evaluation metrics with MLflow.
+- Save the best model locally.
+- Register/upload the best model to the Hugging Face model hub.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, Tuple
+
+import joblib
+import mlflow
+import mlflow.sklearn  # noqa: F401
+import numpy as np
+import pandas as pd
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score
+from sklearn.model_selection import RandomizedSearchCV
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+
+import config
+from hf_data_utils import download_dataset_file
+from hf_model_utils import upload_model
+
+
+def _load_train_test_from_hf_or_local() -> Tuple[pd.DataFrame, pd.DataFrame]:
+    """
+    Load train and test data from the HF dataset repo if available,
+    otherwise fall back to local CSVs created by data_prep.py.
+    """
+    if config.HF_TOKEN and config.HF_DATASET_REPO:
+        try:
+            train_path = download_dataset_file(
+                filename="data/train.csv",
+                repo_id=config.HF_DATASET_REPO,
+                token=config.HF_TOKEN,
+                local_dir=config.DATA_DIR,
+            )
+            test_path = download_dataset_file(
+                filename="data/test.csv",
+                repo_id=config.HF_DATASET_REPO,
+                token=config.HF_TOKEN,
+                local_dir=config.DATA_DIR,
+            )
+            train_df = pd.read_csv(train_path)
+            test_df = pd.read_csv(test_path)
+            return train_df, test_df
+        except Exception:
+            # Fall back to local
+            pass
+
+    if not config.TRAIN_FILE.exists() or not config.TEST_FILE.exists():
+        raise FileNotFoundError(
+            "Train/test files not found locally or in the HF dataset repo. "
+            "Run data_prep.py first to generate the splits."
+        )
+
+    train_df = pd.read_csv(config.TRAIN_FILE)
+    test_df = pd.read_csv(config.TEST_FILE)
+    return train_df, test_df
+
+
+def _build_model_and_search_space() -> Tuple[Pipeline, Dict]:
+    """
+    Build a sklearn Pipeline and define the hyperparameter search space.
+
+    We use a RandomForestClassifier with a StandardScaler on numeric features.
+    """
+    clf = RandomForestClassifier(random_state=config.RANDOM_STATE)
+
+    pipeline = Pipeline(
+        steps=[
+            ("scaler", StandardScaler()),
+            ("clf", clf),
+        ]
+    )
+
+    param_distributions = {
+        "clf__n_estimators": [100, 200, 300, 400],
+        "clf__max_depth": [None, 5, 10, 20],
+        "clf__min_samples_split": [2, 5, 10],
+        "clf__min_samples_leaf": [1, 2, 4],
+        # 'auto' is deprecated in recent sklearn versions; use valid options only
+        "clf__max_features": ["sqrt", "log2", None],
+        "clf__bootstrap": [True, False],
+    }
+
+    return pipeline, param_distributions
+
+
+def _evaluate_model(
+    model: Pipeline, X_test: pd.DataFrame, y_test: pd.Series
+) -> Dict[str, float]:
+    """
+    Compute standard binary classification metrics.
+    """
+    y_pred = model.predict(X_test)
+    metrics = {
+        "accuracy": accuracy_score(y_test, y_pred),
+        "precision": precision_score(y_test, y_pred, zero_division=0),
+        "recall": recall_score(y_test, y_pred, zero_division=0),
+        "f1": f1_score(y_test, y_pred, zero_division=0),
+    }
+    return metrics
+
+
+def main() -> None:
+    """
+    Execute the training, tuning, logging, and model registration pipeline.
+    """
+    print("Loading train and test data...")
+    train_df, test_df = _load_train_test_from_hf_or_local()
+
+    X_train = train_df[config.FEATURE_COLUMNS]
+    y_train = train_df[config.TARGET_COLUMN]
+    X_test = test_df[config.FEATURE_COLUMNS]
+    y_test = test_df[config.TARGET_COLUMN]
+
+    print("Building model and hyperparameter search space...")
+    pipeline, param_distributions = _build_model_and_search_space()
+
+    search = RandomizedSearchCV(
+        estimator=pipeline,
+        param_distributions=param_distributions,
+        n_iter=20,
+        cv=5,
+        scoring="f1",
+        n_jobs=-1,
+        verbose=1,
+        random_state=config.RANDOM_STATE,
+    )
+
+    # Configure MLflow
+    mlflow.set_tracking_uri(config.MLFLOW_TRACKING_URI)
+    mlflow.set_experiment(config.MLFLOW_EXPERIMENT_NAME)
+
+    print("Starting hyperparameter tuning with MLflow tracking...")
+    with mlflow.start_run(run_name="RandomForest_random_search"):
+        search.fit(X_train, y_train)
+
+        best_model: Pipeline = search.best_estimator_
+        best_params = search.best_params_
+
+        # Log all evaluated parameter combinations as nested runs,
+        # similar to the reference notebook pattern.
+        results = search.cv_results_
+        for i in range(len(results["params"])):
+            param_set = results["params"][i]
+            mean_score = results["mean_test_score"][i]
+            with mlflow.start_run(nested=True):
+                mlflow.log_params(param_set)
+                mlflow.log_metric("mean_cv_f1", float(mean_score))
+
+        # Evaluation
+        metrics = _evaluate_model(best_model, X_test, y_test)
+
+        # Log parameters and metrics
+        mlflow.log_params(best_params)
+        for name, value in metrics.items():
+            mlflow.log_metric(name, float(value))
+
+        # Save model locally
+        config.MODELS_DIR.mkdir(parents=True, exist_ok=True)
+        joblib.dump(best_model, config.BEST_MODEL_LOCAL_PATH)
+        mlflow.log_artifact(str(config.BEST_MODEL_LOCAL_PATH), artifact_path="artifacts")
+
+        # Also log the model in MLflow's model registry format
+        mlflow.sklearn.log_model(best_model, artifact_path="engine_model")
+
+        print("Best parameters found:")
+        for k, v in best_params.items():
+            print(f"  {k}: {v}")
+
+        print("Evaluation metrics on test set:")
+        for k, v in metrics.items():
+            print(f"  {k}: {v:.4f}")
+
+    # Upload best model to Hugging Face model hub, if configured
+    if config.HF_TOKEN and config.HF_MODEL_REPO:
+        try:
+            print("Uploading best model to Hugging Face model hub...")
+            upload_model(
+                local_model_path=config.BEST_MODEL_LOCAL_PATH,
+                repo_id=config.HF_MODEL_REPO,
+                repo_path="model.joblib",
+                token=config.HF_TOKEN,
+            )
+            print("Model upload to Hugging Face completed.")
+        except Exception as e:
+            print(f"Warning: Failed to upload model to Hugging Face: {e}")
+
+
+if __name__ == "__main__":
+    main()
+