Initial upload of SmartWatt Backend API

.env.example

@@ -0,0 +1,140 @@
+# =====================================================
+# SmartWatt Backend - Environment Configuration
+# =====================================================
+# 
+# Instructions:
+# 1. Copy this file to .env
+# 2. Fill in your actual values
+# 3. Never commit .env to version control
+#
+# =====================================================
+
+# ============================
+# Server Configuration
+# ============================
+
+# Server host (use 0.0.0.0 to allow external connections)
+HOST=0.0.0.0
+
+# Server port
+PORT=8000
+
+# Environment mode (development | staging | production)
+ENVIRONMENT=development
+
+# Debug mode (true | false) - Disable in production!
+DEBUG=true
+
+# ============================
+# CORS Configuration
+# ============================
+
+# Allowed origins (comma-separated list of URLs)
+# Add your frontend URL(s) here
+# Example: http://localhost:3000,https://yourdomain.com
+ALLOWED_ORIGINS=http://localhost:3000,http://localhost:3001,https://smartwatt-frontend.vercel.app
+
+# ============================
+# Database Configuration
+# ============================
+
+# Supabase Configuration (Optional - for cloud training data storage)
+# Sign up at https://supabase.com to get these credentials
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_KEY=your-anon-key-here
+SUPABASE_SERVICE_KEY=your-service-role-key-here
+
+# ============================
+# AI/ML Configuration
+# ============================
+
+# Model confidence threshold (0.0 - 1.0)
+# Predictions below this confidence will trigger warnings
+MODEL_CONFIDENCE_THRESHOLD=0.85
+
+# Enable/disable model caching for faster predictions
+ENABLE_MODEL_CACHING=true
+
+# Maximum batch size for /predict-all endpoint
+MAX_BATCH_SIZE=100
+
+# ============================
+# Logging Configuration
+# ============================
+
+# Log level (DEBUG | INFO | WARNING | ERROR | CRITICAL)
+LOG_LEVEL=INFO
+
+# Enable request logging
+LOG_REQUESTS=true
+
+# Log file path (leave empty to disable file logging)
+LOG_FILE_PATH=logs/smartwatt.log
+
+# ============================
+# Security Configuration
+# ============================
+
+# API Key for protected endpoints (optional)
+# API_KEY=your-secret-api-key-here
+
+# Rate limiting (requests per minute)
+RATE_LIMIT=60
+
+# Enable HTTPS redirect in production
+FORCE_HTTPS=false
+
+# ============================
+# External Services
+# ============================
+
+# Weather API (optional - for temperature-based predictions)
+# WEATHER_API_KEY=your-openweather-api-key
+# WEATHER_API_URL=https://api.openweathermap.org/data/2.5
+
+# Notification service (optional)
+# EMAIL_SERVICE_API_KEY=your-sendgrid-api-key
+# SMS_SERVICE_API_KEY=your-twilio-api-key
+
+# ============================
+# Feature Flags
+# ============================
+
+# Enable experimental features
+ENABLE_EXPERIMENTAL_FEATURES=false
+
+# Enable self-learning system
+ENABLE_SELF_LEARNING=true
+
+# Enable anomaly detection
+ENABLE_ANOMALY_DETECTION=true
+
+# ============================
+# Performance Tuning
+# ============================
+
+# Number of worker processes (recommended: number of CPU cores)
+WORKERS=4
+
+# Worker timeout in seconds
+TIMEOUT=60
+
+# Keep-alive timeout
+KEEP_ALIVE=5
+
+# ============================
+# Development Only
+# ============================
+
+# Enable auto-reload on code changes (development only)
+RELOAD=true
+
+# Enable detailed error messages (disable in production)
+SHOW_ERROR_DETAILS=true
+
+# =====================================================
+# Notes:
+# - All values are optional unless marked as required
+# - Default values are used if not specified
+# - See README.md for detailed configuration guide
+# =====================================================

.gitattributes

@@ -1,35 +1,5 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
+kerala_realworld_dataset_v4.csv filter=lfs diff=lfs merge=lfs -text
+kerala_realworld_dataset.csv filter=lfs diff=lfs merge=lfs -text
+*.keras filter=lfs diff=lfs merge=lfs -text
 *.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+.env
+*.env
+__pycache__/
+node_modules/

.python-version

@@ -0,0 +1 @@
+3.11.11

Analysis_Tools/analyze_dataset_issues.py

@@ -0,0 +1,93 @@
+import numpy as np
+import pandas as pd
+
+df = pd.read_csv("kerala_smartwatt_ai.csv")
+
+print("=" * 80)
+print("DATASET ISSUE ANALYSIS")
+print("=" * 80)
+
+print("\n1. AC AGE VALUES (Date Formatting Issue?)")
+print("-" * 80)
+print(df["ac_age_years"].value_counts())
+print(f"\nSample AC age values: {df['ac_age_years'].unique()[:10]}")
+
+print("\n2. AC USAGE PATTERN FOR NON-AC HOUSEHOLDS")
+print("-" * 80)
+print(f"Total households: {len(df)}")
+print(f"Has AC (has_ac=1): {df['has_ac'].sum()}")
+print(f"No AC (has_ac=0): {(df['has_ac']==0).sum()}")
+print(f"\nPattern distribution for NO-AC households:")
+print(df[df["has_ac"] == 0]["ac_usage_pattern"].value_counts())
+
+print("\n3. SAMPLE NON-AC HOUSEHOLD DATA")
+print("-" * 80)
+print(
+    df[df["has_ac"] == 0][
+        [
+            "has_ac",
+            "ac_age_years",
+            "ac_type",
+            "ac_usage_pattern",
+            "ac_real_effective_hours",
+            "ac_kwh",
+        ]
+    ].head(15)
+)
+
+print("\n4. CHECKING OTHER APPLIANCES FOR SIMILAR ISSUES")
+print("-" * 80)
+
+# Check refrigerator
+print("\nREFRIGERATOR:")
+print(f"Has fridge: {df['has_refrigerator'].sum()}")
+print(f"No fridge: {(df['has_refrigerator']==0).sum()}")
+non_fridge_patterns = df[df["has_refrigerator"] == 0][
+    "refrigerator_usage_pattern"
+].value_counts()
+print(f"Non-fridge pattern distribution:\n{non_fridge_patterns[:5]}")
+
+# Check television
+print("\nTELEVISION:")
+print(f"Has TV: {df['has_television'].sum()}")
+print(f"No TV: {(df['has_television']==0).sum()}")
+non_tv_patterns = df[df["has_television"] == 0][
+    "television_usage_pattern"
+].value_counts()
+print(f"Non-TV pattern distribution:\n{non_tv_patterns[:5]}")
+
+# Check iron
+print("\nIRON:")
+print(f"Has iron: {df['has_iron'].sum()}")
+print(f"No iron: {(df['has_iron']==0).sum()}")
+non_iron_patterns = df[df["has_iron"] == 0]["iron_usage_pattern"].value_counts()
+print(f"Non-iron pattern distribution:\n{non_iron_patterns[:5]}")
+
+print("\n5. CHECKING FOR ZERO VALUES WITH NON-ZERO PATTERNS")
+print("-" * 80)
+issues = df[
+    (df["has_ac"] == 0)
+    & (df["ac_usage_pattern"] != "unknown")
+    & (df["ac_usage_pattern"] != "none")
+]
+print(f"AC: {len(issues)} households without AC but have usage_pattern assigned")
+
+issues_fridge = df[
+    (df["has_refrigerator"] == 0)
+    & (df["refrigerator_usage_pattern"] != "unknown")
+    & (df["refrigerator_usage_pattern"] != "none")
+]
+print(
+    f"Fridge: {len(issues_fridge)} households without fridge but have usage_pattern assigned"
+)
+
+issues_tv = df[
+    (df["has_television"] == 0)
+    & (df["television_usage_pattern"] != "unknown")
+    & (df["television_usage_pattern"] != "none")
+]
+print(f"TV: {len(issues_tv)} households without TV but have usage_pattern assigned")
+
+print("\n" + "=" * 80)
+print("ANALYSIS COMPLETE")
+print("=" * 80)

Analysis_Tools/evaluate_all_models.py

@@ -0,0 +1,298 @@
+"""
+Evaluate All Models Script
+Loads all 22 trained models and generates a detailed performance report.
+"""
+
+import os
+
+import joblib
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
+from tensorflow import keras
+
+
+def load_data():
+    if not os.path.exists("kerala_smartwatt_ai.csv"):
+        print("❌ Dataset not found!")
+        return None
+    return pd.read_csv("kerala_smartwatt_ai.csv")
+
+
+def evaluate_models():
+    df = load_data()
+    if df is None:
+        return
+
+    # List of all 22 models to evaluate
+    tasks = [
+        (
+            "ac",
+            "ac",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "ac_tonnage",
+                "ac_star_rating",
+                "ac_type",
+                "ac_age_years",
+                "ac_usage_pattern",
+            ],
+        ),
+        (
+            "fridge",
+            "fridge",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "fridge_capacity",
+                "fridge_age",
+                "fridge_star_rating",
+                "fridge_type",
+                "refrigerator_usage_pattern",
+            ],
+        ),
+        (
+            "ceiling_fan",
+            "ceiling_fan",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "fan_type",
+                "num_fans",
+                "fan_usage_pattern",
+            ],
+        ),
+        (
+            "television",
+            "television",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "television_type",
+                "tv_size",
+                "television_usage_pattern",
+            ],
+        ),
+        (
+            "washing_machine",
+            "washing_machine",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "wm_type",
+                "wm_capacity",
+                "wm_star_rating",
+                "wm_cycles_per_week",
+            ],
+        ),
+        (
+            "water_pump",
+            "water_pump",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "water_pump_hp",
+                "pump_usage_pattern",
+            ],
+        ),
+        (
+            "water_heater",
+            "water_heater",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "water_heater_type",
+                "water_heater_capacity",
+                "geyser_usage_pattern",
+            ],
+        ),
+        (
+            "iron",
+            "iron",
+            ["n_occupants", "season", "location_type", "iron_usage_pattern"],
+        ),
+        (
+            "kettle",
+            "kettle",
+            ["n_occupants", "season", "location_type", "kettle_usage_pattern"],
+        ),
+        (
+            "induction",
+            "induction",
+            ["n_occupants", "season", "location_type", "induction_usage_pattern"],
+        ),
+        (
+            "desktop",
+            "desktop",
+            ["n_occupants", "season", "location_type", "desktop_usage_pattern"],
+        ),
+        (
+            "microwave",
+            "microwave",
+            ["n_occupants", "season", "location_type", "microwave_usage_pattern"],
+        ),
+        (
+            "mixer",
+            "mixer",
+            ["n_occupants", "season", "location_type", "mixer_usage_pattern"],
+        ),
+        (
+            "rice_cooker",
+            "rice_cooker",
+            ["n_occupants", "season", "location_type", "rice_cooker_usage_pattern"],
+        ),
+        (
+            "toaster",
+            "toaster",
+            ["n_occupants", "season", "location_type", "toaster_usage_pattern"],
+        ),
+        (
+            "food_processor",
+            "food_processor",
+            ["n_occupants", "season", "location_type", "food_processor_usage_pattern"],
+        ),
+        (
+            "laptop",
+            "laptop",
+            ["n_occupants", "season", "location_type", "laptop_usage_pattern"],
+        ),
+        (
+            "hair_dryer",
+            "hair_dryer",
+            ["n_occupants", "season", "location_type", "hair_dryer_usage_pattern"],
+        ),
+        (
+            "vacuum",
+            "vacuum",
+            ["n_occupants", "season", "location_type", "vacuum_usage_pattern"],
+        ),
+        (
+            "led_lights",
+            "led_lights",
+            ["n_occupants", "season", "location_type", "led_lights_usage_pattern"],
+        ),
+        (
+            "cfl_lights",
+            "cfl_lights",
+            ["n_occupants", "season", "location_type", "cfl_lights_usage_pattern"],
+        ),
+        (
+            "tube_lights",
+            "tube_lights",
+            ["n_occupants", "season", "location_type", "tube_lights_usage_pattern"],
+        ),
+    ]
+
+    results_data = []
+
+    print(
+        f"{'APPLIANCE':<20} | {'EFFICIENCY MAE':<15} | {'HOURS MAE':<10} | {'SAMPLES':<8}"
+    )
+    print("-" * 65)
+
+    for name, prefix, feats in tasks:
+        model_path = f"models/{name}_model.keras"
+        preprocessor_path = f"models/{name}_preprocessor.pkl"
+
+        if not os.path.exists(model_path) or not os.path.exists(preprocessor_path):
+            print(f"⚠️ {name}: Model/Preprocessor not found")
+            continue
+
+        try:
+            # Load artifacts
+            model = keras.models.load_model(model_path)
+            preprocessor = joblib.load(preprocessor_path)
+
+            # Filter data
+            if f"has_{name}" in df.columns:
+                df_app = df[df[f"has_{name}"] == 1].copy()
+            elif name == "fridge":
+                df_app = df[df["has_refrigerator"] == 1].copy()
+            elif name == "desktop":
+                df_app = df[df["has_computer"] == 1].copy()
+            elif name == "kettle":
+                df_app = df[df["has_electric_kettle"] == 1].copy()
+            elif name in [
+                "microwave",
+                "mixer",
+                "rice_cooker",
+                "toaster",
+                "food_processor",
+                "laptop",
+                "hair_dryer",
+                "vacuum",
+            ]:
+                df_app = df[df[f"has_{name}"] == 1].copy()
+            elif name in ["led_lights", "cfl_lights", "tube_lights"]:
+                df_app = df[df[f"has_{name}"] == 1].copy()
+            else:
+                df_app = df.copy()
+
+            if len(df_app) == 0:
+                print(f"⚠️ {name}: No data")
+                continue
+
+            # Prepare inputs/targets
+            X = preprocessor.transform(df_app[feats])
+            y_eff_true = df_app[f"{prefix}_real_efficiency_factor"].values
+            y_hours_true = df_app[f"{prefix}_real_effective_hours"].values
+
+            # Predict
+            preds = model.predict(X, verbose=0)
+            y_eff_pred = preds[0].flatten()
+            y_hours_pred = preds[1].flatten()
+
+            # Calculate Metrics
+            mae_eff = mean_absolute_error(y_eff_true, y_eff_pred)
+            mae_hours = mean_absolute_error(y_hours_true, y_hours_pred)
+
+            # Additional logic to handle very large R2 errors if any
+            r2_eff = r2_score(y_eff_true, y_eff_pred)
+            r2_hours = r2_score(y_hours_true, y_hours_pred)
+
+            print(
+                f"{name:<20} | {mae_eff:<15.4f} | {mae_hours:<10.2f} | {len(df_app):<8}"
+            )
+
+            results_data.append(
+                {
+                    "Appliance": name.replace("_", " ").title(),
+                    "Efficiency MAE": f"{mae_eff:.4f}",
+                    "Hours MAE": f"{mae_hours:.2f}",
+                    "Efficiency R²": f"{r2_eff:.3f}",
+                    "Hours R²": f"{r2_hours:.3f}",
+                    "Samples": len(df_app),
+                }
+            )
+
+        except Exception as e:
+            print(f"❌ {name}: Error - {str(e)}")
+
+    # Save to Markdown
+    with open("training_results_table.md", "w") as f:
+        f.write("# SmartWatt AI Model Performance Report\n\n")
+        f.write(
+            "| Appliance | Efficiency MAE | Usage Hours MAE | Efficiency R² | Hours R² | Samples |\n"
+        )
+        f.write(
+            "|-----------|----------------|-----------------|---------------|----------|---------|\n"
+        )
+        for r in results_data:
+            f.write(
+                f"| {r['Appliance']} | {r['Efficiency MAE']} | {r['Hours MAE']} | {r['Efficiency R²']} | {r['Hours R²']} | {r['Samples']} |\n"
+            )
+
+    print("\n✅ Report saved to training_results_table.md")
+
+
+if __name__ == "__main__":
+    evaluate_models()

Analysis_Tools/show_real_data.py

@@ -0,0 +1,29 @@
+import pandas as pd
+
+df = pd.read_csv("kerala_smartwatt_ai.csv")
+
+print("\n" + "=" * 80)
+print("VERIFICATION: What Python/Training Script Actually Sees")
+print("=" * 80)
+
+print("\nAC Age Values Distribution:")
+print(df["ac_age_years"].value_counts())
+
+print("\n" + "=" * 80)
+print("Sample AC Households (First 15 with AC):")
+print("=" * 80)
+sample = df[df["has_ac"] == 1][
+    ["ac_age_years", "ac_type", "ac_usage_pattern", "ac_real_effective_hours"]
+].head(15)
+print(sample.to_string())
+
+print("\n" + "=" * 80)
+print("CONCLUSION:")
+print("=" * 80)
+print("- ac_age_years shows: '3-5', '6-10', '0-2', '10+', 'unknown'")
+print("- These are TEXT RANGES stored correctly in CSV")
+print("- Python reads them correctly (no date conversion)")
+print("- Training script works perfectly with these values")
+print("\nThe 'dates' you saw ONLY exist in Excel's display!")
+print("The actual data is CORRECT and ready for training.")
+print("=" * 80)

Analysis_Tools/test_auto_train_local.py

@@ -0,0 +1,127 @@
+"""
+Auto-Train Pipeline for SmartWatt  (The "Self-Improving" System)
+------------------------------------------------------------------
+This script is the "Gym" for our AI.
+Every time we run this, the AI gets smarter.
+
+Workflow:
+1. GENERATE: Create a new "Virtual World" of Kerala households (Physics-based Ground Truth).
+2. TRAIN: Teach the AI models using this fresh data.
+3. DEPLOY: Save the brain files (.keras) so the backend can use them.
+
+Why?
+Because static AI gets stale. We want an AI that can learn from new physics rules instantly.
+"""
+
+import os
+import sys
+
+from dotenv import load_dotenv
+from supabase import create_client
+
+# Load environment variables
+load_dotenv()
+
+
+# Add parent directory to path to import backend modules
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+try:
+    import newdataset
+    import train
+except ImportError as e:
+    print(f"❌ Error importing Backend modules: {e}")
+    print("Ensure you are running this from the Backend/ root directory.")
+    sys.exit(1)
+
+
+def run_pipeline():
+    print("\n" + "=" * 60)
+    print(" 🚀 SMARTWATT : AUTO-TRAIN PIPELINE STARTING")
+    print("=" * 60)
+
+    # --- STEP 0: CHECK REAL WORLD DATA (Gatekeeper) ---
+    # We only want to burn compute if we have enough real user data to matter.
+    # Checks the "smartwatt_training" vault in Supabase.
+    try:
+        url = os.environ.get("SUPABASE_URL")
+        key = os.environ.get("SUPABASE_KEY")
+
+        if not url or not key:
+            print("⚠️ Skipped Supabase Check: Missing credentials.")
+        else:
+            print("\n[Step 0/2] Checking Real World Data Maturity...")
+            supabase = create_client(url, key)
+            # Count entries (head=True is efficient, doesn't fetch body)
+            count = (
+                supabase.table("smartwatt_training")
+                .select("*", count="exact", head=True)
+                .execute()
+                .count
+            )
+
+            print(f"   📊 Found {count} real user entries in Database.")
+
+            if count < 10:
+                print(f"   🛑 HALTING: Not enough data ({count}/10).")
+                print("   The AI refuses to learn from an empty world.")
+                print("   Come back when you have at least 10 entries.")
+                return
+            else:
+                print("   ✅ PROCEEDING: Data maturity threshold met.")
+
+    except Exception as e:
+        print(f"⚠️ Supabase Check Warning: {e}")
+        # We don't stop strictly on error, unless user wants strict mode.
+        # But user said "only train if...", so maybe we SHOULD return on error?
+        # User said "only train if supabase contain minimum 10 entries".
+        # If we can't verify, we can't be sure. Safe default is to Proceed?
+        # No, "only train if...". If check fails, condition is not met.
+        # But for robustness, I'll print warning and Return to be safe/strict.
+        print("   🛑 Check failed, skipping training to be safe.")
+        return
+
+    # --- STEP 1: DATA REGENERATION ---
+    print("\n[Step 1/2] Regenerating Synthetic Ground Truth Data...")
+    try:
+        sim = newdataset.KeralaRealWorldSimulator()
+        df = sim.generate()
+
+        # Save to root directory
+        csv_path = "kerala_smartwatt_ai.csv"
+        df.to_csv(csv_path, index=False)
+        print(f"   ✅ New Dataset Generated: {csv_path} ({len(df)} samples)")
+
+    except Exception as e:
+        print(f"   ❌ Data Generation Failed: {e}")
+        return
+
+    # --- STEP 2: MODEL RETRAINING ---
+    print("\n[Step 2/2] Retraining  Hybrid Models...")
+    # This calls the "Teacher" script (train.py) to update the neural networks.
+    try:
+        train.run_training()
+    except Exception as e:
+        print(f"   ❌ Training Failed: {e}")
+        return
+
+    print("\n" + "=" * 60)
+    print(" ✅ PIPELINE COMPLETE: AI IS NOW SMARTER!")
+    print("=" * 60)
+
+
+"""
+--- LEGACY V1 SUPABASE SNIPPET (ARCHIVED) ---
+The V1 Auto-Train logic fetched user data from Supabase.
+In , we require 'Efficiency' & 'Hours' ground truth, which basic user input lacks.
+Future Scope: Integrate IoT sensors to collect this ground truth, then uncomment below.
+
+# from supabase import create_client
+# ...
+# def fetch_training_data_original():
+#     response = supabase.table('smartwatt_training').select("*").execute()
+#     ...
+"""
+
+if __name__ == "__main__":
+    run_pipeline()

Analysis_Tools/test_clean_architecture.py

@@ -0,0 +1,97 @@
+"""
+Test script to demonstrate new clean batch prediction architecture
+"""
+
+import json
+
+import requests
+
+# Test data - household with multiple appliances
+test_request = {
+    "requests": [
+        {
+            "appliance_name": "ac",
+            "total_bill": 150.0,
+            "details": {
+                "num_people": 3,
+                "season": "monsoon",
+                "ac_tonnage": 1.5,
+                "ac_star": 3,
+                "ac_hours": 6,
+            },
+        },
+        {
+            "appliance_name": "fridge",
+            "total_bill": 150.0,
+            "details": {
+                "num_people": 3,
+                "season": "monsoon",
+                "fridge_capacity_liters": 250,
+                "fridge_age_years": 5,
+                "fridge_star": 4,
+            },
+        },
+        {
+            "appliance_name": "ceiling_fan",
+            "total_bill": 150.0,
+            "details": {
+                "num_people": 3,
+                "season": "monsoon",
+                "num_ceiling_fans": 4,
+                "fan_hours": 12,
+            },
+        },
+        {
+            "appliance_name": "led_light",
+            "total_bill": 150.0,
+            "details": {
+                "num_people": 3,
+                "season": "monsoon",
+                "num_led": 10,
+                "led_hours": 5,
+            },
+        },
+        {
+            "appliance_name": "television",
+            "total_bill": 150.0,
+            "details": {
+                "num_people": 3,
+                "season": "monsoon",
+                "tv_size_inches": 43,
+                "tv_type": "LED",
+                "tv_pattern": "moderate",
+            },
+        },
+    ]
+}
+
+print("=" * 80)
+print("TESTING NEW CLEAN BATCH PREDICTION ARCHITECTURE")
+print("=" * 80)
+print(f"\nSending batch request with {len(test_request['requests'])} appliances...")
+print()
+
+# Make request
+response = requests.post("http://localhost:8000/predict-all", json=test_request)
+
+if response.status_code == 200:
+    results = response.json()
+    print("\n" + "=" * 80)
+    print("API RESPONSE RECEIVED")
+    print("=" * 80)
+
+    total_kwh = 0
+    for appliance, data in results.items():
+        kwh = data.get("prediction", 0)
+        total_kwh += kwh
+        source = data.get("insights", {}).get("source", "Unknown")
+        print(f"{appliance:20}: {kwh:6.2f} kWh ({source})")
+
+    print("-" * 80)
+    print(f"{'TOTAL':20}: {total_kwh:6.2f} kWh")
+    print("=" * 80)
+else:
+    print(f"Error: {response.status_code}")
+    print(response.text)
+
+print("\n\nCheck the backend console for CLEAN LOGGING OUTPUT!")

Analysis_Tools/verify_patterns.py

@@ -0,0 +1,84 @@
+import pandas as pd
+
+df = pd.read_csv("kerala_smartwatt_ai.csv")
+
+print("\n" + "=" * 70)
+print("USAGE PATTERN vs EFFECTIVE HOURS VERIFICATION")
+print("=" * 70)
+
+# AC
+print("\n1. AIR CONDITIONER:")
+print(
+    df[df["has_ac"] == 1][["ac_usage_pattern", "ac_real_effective_hours"]]
+    .groupby("ac_usage_pattern")["ac_real_effective_hours"]
+    .agg(["count", "mean", "min", "max"])
+    .round(2)
+)
+
+# Fridge
+print("\n2. REFRIGERATOR:")
+print(
+    df[df["has_refrigerator"] == 1][
+        ["refrigerator_usage_pattern", "fridge_real_effective_hours"]
+    ]
+    .groupby("refrigerator_usage_pattern")["fridge_real_effective_hours"]
+    .agg(["count", "mean", "min", "max"])
+    .round(2)
+)
+
+# Television
+print("\n3. TELEVISION:")
+print(
+    df[df["has_television"] == 1][
+        ["television_usage_pattern", "television_real_effective_hours"]
+    ]
+    .groupby("television_usage_pattern")["television_real_effective_hours"]
+    .agg(["count", "mean", "min", "max"])
+    .round(2)
+)
+
+# Iron
+print("\n4. IRON:")
+print(
+    df[df["has_iron"] == 1][["iron_usage_pattern", "iron_real_effective_hours"]]
+    .groupby("iron_usage_pattern")["iron_real_effective_hours"]
+    .agg(["count", "mean", "min", "max"])
+    .round(2)
+)
+
+# Kettle
+print("\n5. ELECTRIC KETTLE:")
+print(
+    df[df["has_electric_kettle"] == 1][
+        ["kettle_usage_pattern", "kettle_real_effective_hours"]
+    ]
+    .groupby("kettle_usage_pattern")["kettle_real_effective_hours"]
+    .agg(["count", "mean", "min", "max"])
+    .round(2)
+)
+
+# Water Pump
+print("\n6. WATER PUMP:")
+print(
+    df[df["has_water_pump"] == 1][
+        ["pump_usage_pattern", "water_pump_real_effective_hours"]
+    ]
+    .groupby("pump_usage_pattern")["water_pump_real_effective_hours"]
+    .agg(["count", "mean", "min", "max"])
+    .round(2)
+)
+
+# Geyser
+print("\n7. WATER HEATER (GEYSER):")
+print(
+    df[df["has_water_heater"] == 1][
+        ["geyser_usage_pattern", "water_heater_real_effective_hours"]
+    ]
+    .groupby("geyser_usage_pattern")["water_heater_real_effective_hours"]
+    .agg(["count", "mean", "min", "max"])
+    .round(2)
+)
+
+print("\n" + "=" * 70)
+print("✅ VERIFICATION COMPLETE")
+print("=" * 70)

Dockerfile

@@ -0,0 +1,35 @@
+# Use official lightweight Python image
+FROM python:3.9-slim
+
+# Set environment variables to prevent Python from writing pyc files and buffering stdout
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Install system dependencies (if needed for TensorFlow/Scikit-learn)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set up a new user named "user" with user ID 1000
+# Hugging Face Spaces requires running Docker containers as a non-root user
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+# Copy requirements first to leverage Docker cache
+COPY --chown=user requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY --chown=user . $HOME/app
+
+# Expose the API port 7860 for Hugging Face
+EXPOSE 7860
+
+# Command to run the application on Hugging Face port 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SmartWatt AI Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Migration_Scripts/migrate_kwh_columns.py

@@ -0,0 +1,158 @@
+"""
+Migration Script: Populate predicted_kwh and input_kwh columns
+================================================================
+This script extracts data from existing JSON columns and populates
+the new dedicated columns for faster self-learning.
+"""
+
+import json
+import os
+
+from dotenv import load_dotenv
+from supabase import create_client
+
+# Load environment variables
+load_dotenv()
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+
+
+def get_supabase_client():
+    """Initialize Supabase client"""
+    if not SUPABASE_URL or not SUPABASE_KEY:
+        raise ValueError(
+            "Missing SUPABASE_URL or SUPABASE_KEY in environment variables"
+        )
+    return create_client(SUPABASE_URL, SUPABASE_KEY)
+
+
+def extract_predicted_kwh(final_breakdown):
+    """Extract AI's predicted kWh from final_breakdown.rawTotal"""
+    try:
+        if not final_breakdown:
+            return None
+
+        # Parse JSON string if needed
+        if isinstance(final_breakdown, str):
+            final_breakdown = json.loads(final_breakdown)
+
+        if not isinstance(final_breakdown, dict):
+            return None
+
+        # Get rawTotal (AI's prediction)
+        raw_total = final_breakdown.get("rawTotal")
+        if raw_total and 0 < raw_total < 100000:  # Sanity check
+            return float(raw_total)
+
+        # Fallback: sum predictions dictionary
+        predictions = final_breakdown.get("predictions", {})
+        if predictions:
+            total = sum(
+                float(v) for v in predictions.values() if isinstance(v, (int, float))
+            )
+            if 0 < total < 100000:
+                return total
+
+        return None
+
+    except Exception as e:
+        print(f"      Error extracting predicted_kwh: {e}")
+        return None
+
+
+def migrate_data():
+    """Migrate existing data to populate new columns"""
+    print("=" * 70)
+    print("🔄 MIGRATION: Populating predicted_kwh and input_kwh columns")
+    print("=" * 70)
+
+    supabase = get_supabase_client()
+
+    # Fetch all records
+    print("\n📥 Fetching all records from smartwatt_training...")
+    response = supabase.table("smartwatt_training").select("*").execute()
+
+    if not response.data:
+        print("❌ No records found!")
+        return
+
+    total_records = len(response.data)
+    print(f"✅ Found {total_records} records\n")
+
+    # Process each record
+    updated_count = 0
+    skipped_count = 0
+
+    for idx, record in enumerate(response.data, 1):
+        record_id = record.get("id", "unknown")[:8]
+        print(f"\n[{idx}/{total_records}] Processing record {record_id}...")
+
+        updates = {}
+
+        # Extract input_kwh (actual from user's KSEB bill)
+        bi_monthly_kwh = record.get("bi_monthly_kwh")
+        if bi_monthly_kwh and bi_monthly_kwh > 0:
+            updates["input_kwh"] = float(bi_monthly_kwh)
+            print(f"   ✓ input_kwh: {bi_monthly_kwh} kWh")
+        else:
+            print(f"   ⚠ No valid bi_monthly_kwh")
+
+        # Extract predicted_kwh (from final_breakdown.rawTotal)
+        final_breakdown = record.get("final_breakdown")
+        if final_breakdown:
+            predicted = extract_predicted_kwh(final_breakdown)
+            if predicted:
+                updates["predicted_kwh"] = predicted
+                print(f"   ✓ predicted_kwh: {predicted:.2f} kWh")
+            else:
+                print(f"   ⚠ Could not extract predicted_kwh")
+        else:
+            print(f"   ⚠ No final_breakdown data")
+
+        # Update record if we have data
+        if updates:
+            try:
+                supabase.table("smartwatt_training").update(updates).eq(
+                    "id", record["id"]
+                ).execute()
+
+                if len(updates) == 2:
+                    error = updates["input_kwh"] - updates["predicted_kwh"]
+                    error_pct = (error / updates["input_kwh"]) * 100
+                    print(f"   ✅ Updated! Error: {error:+.1f} kWh ({error_pct:+.1f}%)")
+                else:
+                    print(f"   ⚠ Partial update (missing data)")
+
+                updated_count += 1
+            except Exception as e:
+                print(f"   ❌ Update failed: {e}")
+                skipped_count += 1
+        else:
+            print(f"   ⏭️  Skipped (no data to update)")
+            skipped_count += 1
+
+    # Summary
+    print("\n" + "=" * 70)
+    print("📊 MIGRATION SUMMARY")
+    print("=" * 70)
+    print(f"Total Records: {total_records}")
+    print(f"✅ Updated: {updated_count}")
+    print(f"⏭️  Skipped: {skipped_count}")
+    print("=" * 70)
+
+    if updated_count > 0:
+        print("\n🎉 Migration completed successfully!")
+        print("   You can now run auto_train.py to use the new columns.")
+    else:
+        print("\n⚠️  No records were updated. Check if data exists in the table.")
+
+
+if __name__ == "__main__":
+    try:
+        migrate_data()
+    except Exception as e:
+        print(f"\n❌ Migration failed: {e}")
+        import traceback
+
+        traceback.print_exc()

Migration_Scripts/scheduled_self_learning.py

@@ -0,0 +1,150 @@
+"""
+Scheduled Self-Learning System
+Automatically checks for new user data and triggers retraining when threshold is met.
+Run this as a background service for continuous learning.
+"""
+
+import os
+import subprocess
+import time
+from datetime import datetime
+
+import schedule
+from dotenv import load_dotenv
+from supabase import Client, create_client
+
+load_dotenv()
+
+# Supabase Configuration
+SUPABASE_URL = os.environ.get("NEXT_PUBLIC_SUPABASE_URL") or os.environ.get(
+    "SUPABASE_URL"
+)
+SUPABASE_KEY = os.environ.get("NEXT_PUBLIC_SUPABASE_ANON_KEY") or os.environ.get(
+    "SUPABASE_KEY"
+)
+
+if not SUPABASE_URL or not SUPABASE_KEY:
+    print("❌ Error: Supabase credentials not found")
+    exit(1)
+
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+# Configuration
+MIN_NEW_SAMPLES = 20  # Minimum new predictions before retraining
+LAST_TRAINED_FILE = "training_logs/last_training_timestamp.txt"
+
+
+def get_last_training_timestamp():
+    """Get the timestamp of the last training session"""
+    if os.path.exists(LAST_TRAINED_FILE):
+        with open(LAST_TRAINED_FILE, "r") as f:
+            return f.read().strip()
+    return "1970-01-01T00:00:00"  # Beginning of time
+
+
+def update_last_training_timestamp():
+    """Update the last training timestamp"""
+    os.makedirs("training_logs", exist_ok=True)
+    with open(LAST_TRAINED_FILE, "w") as f:
+        f.write(datetime.now().isoformat())
+
+
+def count_new_predictions():
+    """Count predictions made since last training"""
+    try:
+        last_trained = get_last_training_timestamp()
+
+        # Count records with final_breakdown updated after last training
+        result = (
+            supabase.table("smartwatt_training")
+            .select("*", count="exact")
+            .filter("updated_at", "gte", last_trained)
+            .filter("final_breakdown", "neq", "null")
+            .execute()
+        )
+
+        count = result.count if hasattr(result, "count") else len(result.data)
+        return count
+    except Exception as e:
+        print(f"Error counting predictions: {e}")
+        return 0
+
+
+def check_and_retrain():
+    """Check if retraining is needed and execute if threshold met"""
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    print("\n" + "=" * 70)
+    print(f"🔍 SELF-LEARNING CHECK at {timestamp}")
+    print("=" * 70)
+
+    try:
+        new_count = count_new_predictions()
+
+        print(f"   New predictions since last training: {new_count}")
+        print(f"   Threshold for retraining: {MIN_NEW_SAMPLES}")
+
+        if new_count >= MIN_NEW_SAMPLES:
+            print(f"\n✅ Threshold met! Starting automatic retraining...")
+            print(f"   🧠 AI will learn from {new_count} new real-world predictions\n")
+
+            # Run auto_train.py
+            result = subprocess.run(
+                ["python", "auto_train.py"],
+                cwd=os.path.dirname(__file__),
+                capture_output=True,
+                text=True,
+            )
+
+            if result.returncode == 0:
+                print("\n✅ Retraining completed successfully!")
+                update_last_training_timestamp()
+                print(
+                    f"   Next training will occur after {MIN_NEW_SAMPLES} more predictions"
+                )
+            else:
+                print(f"\n❌ Retraining failed with error:")
+                print(result.stderr)
+        else:
+            remaining = MIN_NEW_SAMPLES - new_count
+            print(f"\n⏳ Waiting for more data...")
+            print(f"   Need {remaining} more predictions before retraining")
+            print(f"   Current: {new_count}/{MIN_NEW_SAMPLES}")
+
+    except Exception as e:
+        print(f"\n❌ Error during check: {e}")
+
+    print("=" * 70 + "\n")
+
+
+def run_scheduler():
+    """Main scheduler loop"""
+    print("\n" + "=" * 70)
+    print("🚀 SMARTWATT SELF-LEARNING SCHEDULER STARTED")
+    print("=" * 70)
+    print(f"   Check interval: Every 6 hours")
+    print(f"   Retraining threshold: {MIN_NEW_SAMPLES} new predictions")
+    print(f"   Status: Monitoring for new user data...")
+    print("=" * 70 + "\n")
+
+    # Schedule checks every 6 hours
+    schedule.every(6).hours.do(check_and_retrain)
+
+    # For testing: check every 10 minutes (uncomment to use)
+    # schedule.every(10).minutes.do(check_and_retrain)
+
+    # Run initial check
+    check_and_retrain()
+
+    # Keep running
+    try:
+        while True:
+            schedule.run_pending()
+            time.sleep(60)  # Check every minute for scheduled tasks
+    except KeyboardInterrupt:
+        print("\n\n🛑 Scheduler stopped by user")
+        print("   Self-learning will resume when scheduler is restarted")
+
+
+if __name__ == "__main__":
+    run_scheduler()

Procfile

@@ -0,0 +1 @@
+web: uvicorn main:app --host 0.0.0.0 --port $PORT

README.md

@@ -1,11 +1,104 @@
----
-title: Smartwatt Backend
-emoji: 🐠
-colorFrom: pink
-colorTo: pink
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<p align="center">
+	<img src="https://img.shields.io/badge/Python-3.10%2B-3776AB" alt="Python" />
+	<img src="https://img.shields.io/badge/FastAPI-0.110-009688" alt="FastAPI" />
+	<img src="https://img.shields.io/badge/TensorFlow-2.16-FF6F00" alt="TensorFlow" />
+	<img src="https://img.shields.io/badge/Scikit--learn-1.7-F7931E" alt="Scikit-learn" />
+	<img src="https://img.shields.io/badge/License-MIT-2E7D32" alt="License" />
+</p>
+
+# SmartWatt Backend
+
+SmartWatt Backend is a FastAPI service for appliance-level electricity estimation. It combines trained machine learning models with deterministic physics rules to provide stable and explainable predictions for Kerala household usage patterns.
+
+## Core Capabilities
+
+- Hybrid inference pipeline: model-based inference for complex loads and physics-first calculations for linear loads.
+- Batch and single-appliance prediction APIs.
+- KSEB slab-aware bill estimation.
+- Anomaly diagnostics and confidence metadata.
+- Simulation endpoint for what-if savings scenarios.
+- Self-learning bias adjustment for recurring users.
+
+## Interface Preview
+
+| API Documentation | Backend Outputs |
+|---|---|
+| <img src="../docs/screenshots/backend-api-docs.png" alt="Backend API docs" width="100%" /> | <img src="../docs/screenshots/smartwatt-results.png" alt="Backend output sample" width="100%" /> |
+
+If images are not visible yet, add files in `docs/screenshots/` from the repository root.
+
+## Technology Stack
+
+- Python 3.10+
+- FastAPI 0.110
+- TensorFlow 2.16
+- Scikit-learn 1.7
+- Pandas and NumPy
+
+## Project Layout
+
+- `main.py`: application bootstrap and base endpoints.
+- `routers/appliances.py`: prediction and simulation routes.
+- `predictor.py`: model loading, hybrid inference, and confidence logic.
+- `physics_engine.py`: deterministic appliance power rules.
+- `kseb_tariff.py`: tariff and billing computations.
+- `services/`: normalization, batch prediction, load balancing, and learning pipeline.
+- `tests/`: unit, integration, e2e, system, and validation suites.
+
+## Local Setup
+
+1. Move to the backend directory.
+
+```bash
+cd Backend
+```
+
+2. Create and activate a virtual environment.
+
+```bash
+python -m venv .venv
+.venv\Scripts\activate
+```
+
+3. Install dependencies.
+
+```bash
+pip install --upgrade pip
+pip install -r requirements.txt
+```
+
+4. Start the API server.
+
+```bash
+python -m uvicorn main:app --reload --port 8000
+```
+
+## API Endpoints
+
+- `GET /`: service status.
+- `GET /health`: health probe.
+- `POST /calculate-bill`: KSEB bill calculation.
+- `POST /predict-appliance`: single appliance prediction.
+- `POST /predict-all`: batch prediction across appliances.
+- `POST /simulate-savings`: scenario-based optimization insights.
+
+## Runtime Characteristics
+
+- Preloads appliance models during startup for faster first-response behavior.
+- Uses schema validation and field mapping before prediction execution.
+- Balances modeled appliances with capped system load for realistic totals.
+- Supports anomaly flags and confidence metadata in response insights.
+
+## Testing
+
+Run tests from the backend directory.
+
+```bash
+pytest tests/unit
+pytest tests/integration
+python tests/system/run_backend_tests.py
+```
+
+## License
+
+Licensed under the MIT License. See `LICENSE`.

Training_Scripts/future_train.py

@@ -0,0 +1,1093 @@
+import json
+import os
+import shutil
+from datetime import datetime
+
+import joblib
+import numpy as np
+import pandas as pd
+from dotenv import load_dotenv
+from supabase import Client, create_client
+
+# 1. Environment Setup
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
+load_dotenv()
+
+import tensorflow as tf
+from sklearn.compose import ColumnTransformer
+from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
+# Machine Learning & Deep Learning Libraries
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+from tensorflow.keras.callbacks import EarlyStopping
+from tensorflow.keras.layers import BatchNormalization, Dense, Dropout
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.optimizers import Adam
+
+# Supabase Configuration
+SUPABASE_URL = os.environ.get("NEXT_PUBLIC_SUPABASE_URL") or os.environ.get(
+    "SUPABASE_URL"
+)
+SUPABASE_KEY = os.environ.get("NEXT_PUBLIC_SUPABASE_ANON_KEY") or os.environ.get(
+    "SUPABASE_KEY"
+)
+
+if not SUPABASE_URL or not SUPABASE_KEY:
+    print("❌ Error: Supabase credentials not found in environment variables.")
+    print(
+        "Please set SUPABASE_URL and SUPABASE_KEY (or NEXT_PUBLIC_...) in your .env file or environment."
+    )
+    exit(1)
+
+# Initialize Supabase Client
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+# Create directories for models and backups
+if not os.path.exists("models"):
+    os.makedirs("models")
+if not os.path.exists("models/backups"):
+    os.makedirs("models/backups")
+if not os.path.exists("training_data"):
+    os.makedirs("training_data")
+if not os.path.exists("training_logs"):
+    os.makedirs("training_logs")
+
+# Training History File
+TRAINING_HISTORY_FILE = "training_logs/training_history.json"
+PERFORMANCE_LOG_CSV = "training_logs/model_performance_log.csv"
+
+
+def load_training_history():
+    """Load training history from JSON file."""
+    if os.path.exists(TRAINING_HISTORY_FILE):
+        with open(TRAINING_HISTORY_FILE, "r") as f:
+            return json.load(f)
+    return {}
+
+
+def save_training_history(history):
+    """Save training history to JSON file."""
+    with open(TRAINING_HISTORY_FILE, "w") as f:
+        json.dump(history, f, indent=2)
+
+
+def backup_existing_model(appliance_name):
+    """Backup existing model files before training new one."""
+    model_path = f"models/{appliance_name}_model.keras"
+    preprocessor_path = f"models/{appliance_name}_preprocessor.pkl"
+
+    if os.path.exists(model_path):
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_dir = f"models/backups/{appliance_name}"
+        os.makedirs(backup_dir, exist_ok=True)
+
+        shutil.copy2(model_path, f"{backup_dir}/model_{timestamp}.keras")
+        if os.path.exists(preprocessor_path):
+            shutil.copy2(
+                preprocessor_path, f"{backup_dir}/preprocessor_{timestamp}.pkl"
+            )
+
+        print(f"  📦 Backed up existing model to {backup_dir}/")
+        return True
+    return False
+
+
+def compare_models(appliance_name, new_metrics, old_metrics=None):
+    """
+    Compare new model with old model performance.
+    Returns True if new model is better.
+    """
+    if old_metrics is None:
+        print(f"  ✨ First model for {appliance_name} - Auto-accepting")
+        return True
+
+    # Compare based on multiple metrics
+    mae_improvement = (
+        (old_metrics["mae"] - new_metrics["mae"]) / old_metrics["mae"]
+    ) * 100
+    r2_improvement = (
+        (new_metrics["r2"] - old_metrics.get("r2", 0))
+        / max(old_metrics.get("r2", 0.01), 0.01)
+    ) * 100
+
+    print(f"\n  📊 Performance Comparison:")
+    print(
+        f"     MAE: {old_metrics['mae']:.3f} → {new_metrics['mae']:.3f} ({mae_improvement:+.1f}%)"
+    )
+    print(
+        f"     R²:  {old_metrics.get('r2', 0):.3f} → {new_metrics['r2']:.3f} ({r2_improvement:+.1f}%)"
+    )
+
+    # Decision logic: Accept if MAE improved OR R2 improved significantly
+    if new_metrics["mae"] < old_metrics["mae"] or new_metrics["r2"] > old_metrics.get(
+        "r2", 0
+    ):
+        print(f"  ✅ New model is BETTER - Accepting")
+        return True
+    else:
+        print(f"  ❌ Old model is BETTER - Keeping existing")
+        return False
+
+
+def restore_backup_model(appliance_name):
+    """Restore the most recent backup if new model is worse."""
+    backup_dir = f"models/backups/{appliance_name}"
+    if not os.path.exists(backup_dir):
+        return False
+
+    backups = sorted([f for f in os.listdir(backup_dir) if f.startswith("model_")])
+    if not backups:
+        return False
+
+    latest_backup = backups[-1]
+    timestamp = latest_backup.replace("model_", "").replace(".keras", "")
+
+    shutil.copy2(
+        f"{backup_dir}/model_{timestamp}.keras", f"models/{appliance_name}_model.keras"
+    )
+    shutil.copy2(
+        f"{backup_dir}/preprocessor_{timestamp}.pkl",
+        f"models/{appliance_name}_preprocessor.pkl",
+    )
+
+    print(f"  ↩️  Restored previous model from backup")
+    return True
+
+
+def log_performance_to_csv(appliance_name, metrics, accepted):
+    """Log model performance to CSV for analysis."""
+    log_entry = {
+        "timestamp": datetime.now().isoformat(),
+        "appliance": appliance_name,
+        "mae": metrics["mae"],
+        "rmse": metrics["rmse"],
+        "r2": metrics["r2"],
+        "samples": metrics["samples"],
+        "accepted": accepted,
+    }
+
+    df_new = pd.DataFrame([log_entry])
+
+    if os.path.exists(PERFORMANCE_LOG_CSV):
+        df_existing = pd.read_csv(PERFORMANCE_LOG_CSV)
+        df_combined = pd.concat([df_existing, df_new], ignore_index=True)
+        df_combined.to_csv(PERFORMANCE_LOG_CSV, index=False)
+    else:
+        df_new.to_csv(PERFORMANCE_LOG_CSV, index=False)
+
+
+def export_training_data_to_csv(df, filename="training_data/latest_training_data.csv"):
+    """Export the current training dataset to CSV for analysis."""
+    df.to_csv(filename, index=False)
+    print(f"\n💾 Training data exported to: {filename}")
+    print(f"   Total records: {len(df)}")
+    print(f"   File size: {os.path.getsize(filename) / 1024:.1f} KB")
+
+
+def fetch_training_data():
+    """
+    Fetches all data from the smartwatt_training table.
+    Extracts ACTUAL vs PREDICTED kWh and calculates prediction errors for self-learning.
+    """
+    print("🔄 Connecting to Supabase...")
+    try:
+        # Fetch all rows (Supabase limits to 1000 by default, using range for more if needed)
+        # For now, assuming < 1000 rows or simple fetch is enough.
+        # For production with >1000 rows, you'd need pagination.
+        response = supabase.table("smartwatt_training").select("*").execute()
+        data = response.data
+
+        if not data:
+            print("⚠️ No data found in 'smartwatt_training' table.")
+            return None
+
+        df = pd.DataFrame(data)
+        print(f"✅ Successfully fetched {len(df)} training records from Supabase.")
+
+        # === DEBUG: Check what's in final_breakdown ===
+        print(f"\n🔍 DEBUG: Checking final_breakdown column...")
+        print(f"   Column exists: {'final_breakdown' in df.columns}")
+        if "final_breakdown" in df.columns:
+            non_null = df["final_breakdown"].notna().sum()
+            print(f"   Non-null final_breakdown: {non_null}/{len(df)}")
+            if non_null > 0:
+                # Show first non-null sample
+                first_result = df[df["final_breakdown"].notna()].iloc[0][
+                    "final_breakdown"
+                ]
+                print(f"   Sample type: {type(first_result)}")
+                if isinstance(first_result, str):
+                    print(f"   Sample (first 200 chars): {first_result[:200]}...")
+                elif isinstance(first_result, dict):
+                    print(f"   Sample keys: {list(first_result.keys())}")
+
+        # === SELF-LEARNING: EXTRACT ACTUAL VS PREDICTED kWh ===
+        print("\n🧮 Calculating Prediction Errors for Self-Learning...")
+
+        # Use dedicated columns directly (much faster than JSON parsing)
+        print("   ✅ Using dedicated input_kwh and predicted_kwh columns")
+        df["actual_kwh"] = df["input_kwh"].fillna(0)
+        df["predicted_total_kwh"] = df["predicted_kwh"].fillna(0)
+
+        # Debug: Show sample of what was extracted
+        samples_with_predictions = df[df["predicted_total_kwh"] > 0]
+        print(f"   Found {len(samples_with_predictions)} records with predictions")
+        if len(samples_with_predictions) > 0:
+            sample_row = samples_with_predictions.iloc[0]
+            print(
+                f"   Sample: Actual={sample_row.get('actual_kwh', 0):.1f} kWh, Predicted={sample_row.get('predicted_total_kwh', 0):.1f} kWh"
+            )
+
+        # Calculate Prediction Error (Core of Self-Learning)
+        df["prediction_error"] = df["actual_kwh"] - df["predicted_total_kwh"]
+        df["error_percentage"] = (
+            (df["prediction_error"] / df["actual_kwh"]) * 100
+        ).fillna(0)
+
+        # Absolute error for filtering
+        df["abs_error_percentage"] = df["error_percentage"].abs()
+
+        # Print Error Statistics
+        valid_predictions = df[df["predicted_total_kwh"] > 0]
+        if len(valid_predictions) > 0:
+            print(f"\n📊 Error Analysis:")
+            print(f"   Total Samples: {len(df)}")
+            print(f"   With Predictions: {len(valid_predictions)}")
+            print(
+                f"   Average Error: {valid_predictions['prediction_error'].mean():.2f} kWh"
+            )
+            print(
+                f"   Average Error %: {valid_predictions['error_percentage'].abs().mean():.2f}%"
+            )
+            print(
+                f"   Median Error %: {valid_predictions['error_percentage'].abs().median():.2f}%"
+            )
+            print(
+                f"   Max Over-prediction: {valid_predictions['prediction_error'].min():.2f} kWh"
+            )
+            print(
+                f"   Max Under-prediction: {valid_predictions['prediction_error'].max():.2f} kWh"
+            )
+
+            # Count accuracy tiers
+            high_accuracy = len(
+                valid_predictions[valid_predictions["abs_error_percentage"] <= 10]
+            )
+            medium_accuracy = len(
+                valid_predictions[
+                    (valid_predictions["abs_error_percentage"] > 10)
+                    & (valid_predictions["abs_error_percentage"] <= 20)
+                ]
+            )
+            low_accuracy = len(
+                valid_predictions[valid_predictions["abs_error_percentage"] > 20]
+            )
+
+            print(f"\n   Accuracy Tiers:")
+            print(
+                f"   ✅ High (<10% error): {high_accuracy} samples ({high_accuracy/len(valid_predictions)*100:.1f}%)"
+            )
+            print(
+                f"   ⚠️  Medium (10-20%): {medium_accuracy} samples ({medium_accuracy/len(valid_predictions)*100:.1f}%)"
+            )
+            print(
+                f"   ❌ Low (>20% error): {low_accuracy} samples ({low_accuracy/len(valid_predictions)*100:.1f}%)"
+            )
+
+            # === DETAILED ACTUAL VS PREDICTED COMPARISON ===
+            print(f"\n" + "=" * 80)
+            print(f"📋 ACTUAL vs PREDICTED COMPARISON (All Records)")
+            print(f"=" * 80)
+            print(
+                f"{'ID':<8} {'Actual kWh':<12} {'Predicted kWh':<15} {'Error':<10} {'Error %':<10} {'Status':<15}"
+            )
+            print(f"-" * 80)
+
+            for idx, row in valid_predictions.iterrows():
+                record_id = (
+                    row.get("id", idx)[:8]
+                    if isinstance(row.get("id"), str)
+                    else str(idx)[:8]
+                )
+                actual = row["actual_kwh"]
+                predicted = row["predicted_total_kwh"]
+                error = row["prediction_error"]
+                error_pct = row["error_percentage"]
+                abs_error_pct = row["abs_error_percentage"]
+
+                # Determine status
+                if abs_error_pct <= 10:
+                    status = "✅ High Acc"
+                elif abs_error_pct <= 20:
+                    status = "⚠️  Medium Acc"
+                else:
+                    status = "❌ Low Acc"
+
+                # Format error percentage as string with % symbol
+                error_pct_str = f"{error_pct:.1f}%"
+                print(
+                    f"{record_id:<8} {actual:<12.1f} {predicted:<15.1f} {error:<10.1f} {error_pct_str:<10} {status:<15}"
+                )
+
+            print(f"=" * 80)
+            print(
+                f"Summary: {high_accuracy} excellent, {medium_accuracy} good, {low_accuracy} needs improvement"
+            )
+            print(f"=" * 80 + "\n")
+
+        print(f"\n✅ Successfully fetched {len(df)} training records from Supabase.")
+
+        # --- DATA TRANSFORMATION: EXTRACT PER-APPLIANCE TARGETS ---
+        print("\n🔍 Extracting per-appliance consumption targets...")
+
+        # Helper to extract kwh from final_breakdown predictions
+        def extract_appliance_kwh(row, appliance_key):
+            """Extract predicted kWh for specific appliance"""
+            try:
+                results = row.get("final_breakdown")
+                if not results:
+                    return 0.0
+
+                # Handle JSON string (Supabase returns JSONB as string sometimes)
+                if isinstance(results, str):
+                    import json
+
+                    results = json.loads(results)
+
+                if not isinstance(results, dict):
+                    return 0.0
+
+                predictions = results.get("predictions", {})
+                return float(predictions.get(appliance_key, 0.0))
+            except:
+                return 0.0
+
+        # Calculate CORRECTION RATIO for each appliance
+        # This is the KEY to self-learning: actual/predicted ratio
+        def calculate_correction_ratio(row, appliance_key):
+            """
+            Calculate how much the model needs to adjust.
+            If predicted = 100 kWh and actual total suggests 120 kWh needed,
+            then correction_ratio = 1.2 (need to predict 20% higher)
+            """
+            try:
+                appliance_pred = extract_appliance_kwh(row, appliance_key)
+                if appliance_pred == 0:
+                    return 1.0  # No prediction, no correction needed
+
+                total_pred = row.get("predicted_total_kwh", 0)
+                actual = row.get("actual_kwh", 0)
+
+                if total_pred == 0 or actual == 0:
+                    return 1.0
+
+                # Global correction factor: actual/predicted
+                global_factor = actual / total_pred
+
+                # Apply to this appliance (proportional correction)
+                return global_factor
+            except:
+                return 1.0
+
+        # Map of training target columns to JSON keys (matching your ai_results structure)
+        target_map = {
+            "ac_kwh": "ac",
+            "refrigerator_kwh": "fridge",
+            "washing_machine_kwh": "washing_machine",
+            "water_heater_kwh": "water_heater",
+            "water_pump_kwh": "water_pump",
+            "television_kwh": "television",
+            "ceiling_fans_kwh": "ceiling_fan",
+            "led_lights_kwh": "led_light",
+            "tube_lights_kwh": "tube_light",
+            "cfl_bulbs_kwh": "cfl_bulb",
+            "mixer_grinder_kwh": "mixer_grinder",
+            "microwave_kwh": "microwave",
+            "desktop_kwh": "desktop",
+            "laptop_kwh": "laptop",
+            "iron_kwh": "iron",
+            "kettle_kwh": "kettle",
+            "induction_kwh": "induction",
+            "rice_cooker_kwh": "rice_cooker",
+        }
+
+        for col, key in target_map.items():
+            # Original predicted value
+            df[col] = df.apply(lambda row: extract_appliance_kwh(row, key), axis=1)
+
+            # SELF-LEARNING: Corrected target (what model SHOULD have predicted)
+            correction_col = f"{col}_corrected"
+            df[correction_col] = df.apply(
+                lambda row: extract_appliance_kwh(row, key)
+                * calculate_correction_ratio(row, key),
+                axis=1,
+            )
+
+        print(f"✅ Extracted {len(target_map)} appliance types with correction ratios")
+
+        # --- EXTRACT FEATURES FROM APPLIANCE_USAGE ---
+        print("\n📋 Extracting features from appliance_usage JSON...")
+
+        def extract_feature(row, feature_key):
+            try:
+                usage = row.get("appliance_usage")
+                if not usage:
+                    return 0.0
+
+                # Handle JSON string (Supabase returns JSONB as string sometimes)
+                if isinstance(usage, str):
+                    import json
+
+                    usage = json.loads(usage)
+
+                if isinstance(usage, list):
+                    return 0.0  # Handle legacy list format if any
+
+                # Check direct key match
+                if feature_key in usage:
+                    return usage[feature_key]
+
+                # Fallback: hours_per_day -> hours (frontend saves as _hours)
+                if feature_key.endswith("_hours_per_day"):
+                    short_key = feature_key.replace("_hours_per_day", "_hours")
+                    if short_key in usage:
+                        return usage[short_key]
+
+                return usage.get(feature_key, 0.0)
+            except:
+                return 0.0
+
+        # List of all possible feature columns needed for training
+        all_features = [
+            "ac_hours_per_day",
+            "ac_tonnage",
+            "ac_star_rating",
+            "num_ac_units",
+            "ac_category",
+            "ac_min_hours",
+            "ac_max_hours",
+            "fridge_capacity_liters",
+            "fridge_age_years",
+            "fridge_star_rating",
+            "fridge_category",
+            "fridge_min_hours",
+            "fridge_max_hours",
+            "wm_cycles_per_week",
+            "wm_capacity_kg",
+            "wm_star_rating",
+            "wm_category",
+            "wm_min_hours",
+            "wm_max_hours",
+            "water_heater_usage_hours",
+            "water_heater_capacity_liters",
+            "geyser_category",
+            "geyser_min_hours",
+            "geyser_max_hours",
+            "water_pump_usage_hours_per_day",
+            "water_pump_hp",
+            "pump_category",
+            "pump_min_hours",
+            "pump_max_hours",
+            "tv_hours_per_day",
+            "tv_size_inches",
+            "num_televisions",
+            "tv_category",
+            "tv_min_hours",
+            "tv_max_hours",
+            "mixer_grinder_usage_minutes_per_day",
+            "mixer_grinder_wattage",
+            "mixer_category",
+            "mixer_min_hours",
+            "mixer_max_hours",
+            "microwave_usage_minutes_per_day",
+            "microwave_capacity_liters",
+            "microwave_category",
+            "microwave_min_hours",
+            "microwave_max_hours",
+            "desktop_hours_per_day",
+            "desktop_category",
+            "desktop_min_hours",
+            "desktop_max_hours",
+            "laptop_hours_per_day",
+            "laptop_category",
+            "laptop_min_hours",
+            "laptop_max_hours",
+            "iron_hours_per_day",
+            "iron_category",
+            "iron_min_hours",
+            "iron_max_hours",
+            "kettle_hours_per_day",
+            "kettle_category",
+            "kettle_min_hours",
+            "kettle_max_hours",
+            "induction_hours_per_day",
+            "induction_category",
+            "induction_min_hours",
+            "induction_max_hours",
+            "rice_cooker_hours_per_day",
+            "rice_cooker_category",
+            "rice_cooker_min_hours",
+            "rice_cooker_max_hours",
+            "num_ceiling_fans",
+            "fan_hours_per_day",
+            "fan_star_rating",
+            "fan_category",
+            "fan_min_hours",
+            "fan_max_hours",
+            "num_led_lights",
+            "light_hours_per_day",
+            "led_category",
+            "led_min_hours",
+            "led_max_hours",
+            "num_tube_lights",
+            "tube_category",
+            "tube_min_hours",
+            "tube_max_hours",
+            "num_cfl_bulbs",
+            "cfl_category",
+            "cfl_min_hours",
+            "cfl_max_hours",
+            "toaster_hours_per_day",
+            "toaster_category",
+            "toaster_min_hours",
+            "toaster_max_hours",
+            "food_processor_hours_per_day",
+            "food_processor_category",
+            "food_processor_min_hours",
+            "food_processor_max_hours",
+            "hair_dryer_hours_per_day",
+            "hair_dryer_category",
+            "hair_dryer_min_hours",
+            "hair_dryer_max_hours",
+            "vacuum_hours_per_day",
+            "vacuum_category",
+            "vacuum_min_hours",
+            "vacuum_max_hours",
+        ]
+
+        # Extract all features
+        print(f"\n📋 Extracting features from appliance_usage JSON...")
+
+        # Build a dict to batch-add columns (avoids DataFrame fragmentation)
+        feature_data = {}
+        for feat in all_features:
+            # If column already exists in top-level (e.g. from SQL schema), prefer it
+            if feat not in df.columns:
+                feature_data[feat] = df.apply(
+                    lambda row: extract_feature(row, feat), axis=1
+                )
+
+        # Add all new columns at once to avoid fragmentation
+        if feature_data:
+            feature_df = pd.DataFrame(feature_data, index=df.index)
+            df = pd.concat([df, feature_df], axis=1)
+
+        print(f"✅ Extracted {len(all_features)} feature columns")
+        print(f"   Total columns in dataset: {len(df.columns)}")
+
+        return df
+    except Exception as e:
+        print(f"❌ Error fetching data from Supabase: {e}")
+        return None
+
+
+def build_and_train_model(
+    df, appliance_name, target_col, filter_col, numeric_features, categorical_features
+):
+    """
+    Generic function with SELF-LEARNING: builds, trains, compares, and selects best model.
+    NOW USES CORRECTED TARGETS based on actual vs predicted errors!
+    """
+    print(f"\n" + "=" * 60)
+    print(f"TRAINING MODEL FOR: {appliance_name.upper()}")
+    print(f"=" * 60)
+
+    # --- Step A: Data Preparation with SELF-LEARNING ---
+    # Use CORRECTED target if available (learned from actual vs predicted)
+    corrected_target_col = f"{target_col}_corrected"
+
+    if corrected_target_col in df.columns:
+        print(f"🎓 Using SELF-LEARNING corrected targets from actual user data!")
+        actual_target = corrected_target_col
+    else:
+        print(f"📊 Using original targets (no correction data available yet)")
+        actual_target = target_col
+
+    # Check if required columns exist
+    missing_cols = [
+        col
+        for col in numeric_features + categorical_features + [target_col]
+        if col not in df.columns
+    ]
+    if missing_cols:
+        print(f"⚠️ Skipping {appliance_name}: Missing columns in data: {missing_cols}")
+        return
+
+    # 1. Filter: Only learn from homes that HAVE this appliance
+    print(f"🔍 Filtering for {appliance_name}...")
+    if filter_col:
+        if filter_col not in df.columns:
+            print(f"   {filter_col} missing. Using {target_col} > 0")
+            appliance_df = df[df[target_col] > 0].copy()
+        else:
+            appliance_df = df[df[filter_col] == 1].copy()
+    else:
+        appliance_df = df[df[target_col] > 0].copy()
+
+    # SELF-LEARNING: Filter out samples with extreme errors (outliers that would harm training)
+    if "abs_error_percentage" in appliance_df.columns:
+        before_filter = len(appliance_df)
+        appliance_df = appliance_df[
+            appliance_df["abs_error_percentage"] <= 100
+        ].copy()  # Remove >100% errors
+        if len(appliance_df) < before_filter:
+            print(
+                f"   🧹 Filtered out {before_filter - len(appliance_df)} extreme outlier samples"
+            )
+
+    print(f"   {appliance_name} samples: {len(appliance_df)}")
+
+    if len(appliance_df) < 10:
+        print(
+            f"⚠️ Skipping {appliance_name}: Not enough data samples ({len(appliance_df)}). Need at least 10."
+        )
+        return
+
+    # 2. Features: Always include total_kwh_monthly (bi_monthly_kwh / 2) if available
+    if "total_kwh_monthly" not in appliance_df.columns:
+        if "bi_monthly_kwh" in appliance_df.columns:
+            appliance_df["total_kwh_monthly"] = appliance_df["bi_monthly_kwh"] / 2
+        else:
+            print(
+                f"⚠️ Skipping {appliance_name}: 'bi_monthly_kwh' column missing for context."
+            )
+            return
+
+    features = numeric_features + categorical_features + ["total_kwh_monthly"]
+
+    # Fill NaNs with 0 or appropriate defaults to prevent crashes
+    appliance_df[numeric_features] = appliance_df[numeric_features].fillna(0)
+    for cat in categorical_features:
+        appliance_df[cat] = appliance_df[cat].fillna("unknown")
+
+    X = appliance_df[features]
+    y = appliance_df[actual_target]  # Use corrected target!
+
+    # Show learning statistics
+    if actual_target != target_col:
+        original_avg = appliance_df[target_col].mean()
+        corrected_avg = appliance_df[actual_target].mean()
+        adjustment_pct = (
+            ((corrected_avg - original_avg) / original_avg * 100)
+            if original_avg > 0
+            else 0
+        )
+        print(
+            f"   📈 Learning Adjustment: {adjustment_pct:+.1f}% (Original: {original_avg:.1f} → Corrected: {corrected_avg:.1f} kWh)"
+        )
+
+    print(f"   Training samples: {len(X)}")
+
+    # Split Data
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42
+    )
+
+    # --- Step B: Preprocessing ---
+    preprocessor = ColumnTransformer(
+        transformers=[
+            ("num", StandardScaler(), numeric_features + ["total_kwh_monthly"]),
+            (
+                "cat",
+                OneHotEncoder(handle_unknown="ignore", sparse_output=False),
+                categorical_features,
+            ),
+        ]
+    )
+
+    X_train_processed = preprocessor.fit_transform(X_train)
+    X_test_processed = preprocessor.transform(X_test)
+
+    # --- SELF-LEARNING: Backup existing model ---
+    had_old_model = backup_existing_model(appliance_name)
+
+    # Save NEW Preprocessor (temporary - will be kept or restored based on performance)
+    joblib.dump(preprocessor, f"models/{appliance_name}_preprocessor_temp.pkl")
+
+    # --- Step C: Neural Network Architecture ---
+    model = Sequential(
+        [
+            Dense(64, activation="relu", input_shape=(X_train_processed.shape[1],)),
+            BatchNormalization(),
+            Dropout(0.2),
+            Dense(32, activation="relu"),
+            BatchNormalization(),
+            Dropout(0.15),
+            Dense(16, activation="relu"),
+            Dense(1, activation="linear"),
+        ]
+    )
+
+    model.compile(
+        optimizer=Adam(learning_rate=0.001), loss="mean_squared_error", metrics=["mae"]
+    )
+
+    early_stop = EarlyStopping(
+        monitor="val_loss", patience=10, restore_best_weights=True, verbose=0
+    )
+
+    # --- Step D: Training ---
+    print("🧠 Neural Network is learning...")
+    history = model.fit(
+        X_train_processed,
+        y_train,
+        validation_data=(X_test_processed, y_test),
+        epochs=100,
+        batch_size=32,
+        verbose=0,
+        callbacks=[early_stop],
+    )
+
+    # --- Step E: Evaluation ---
+    y_pred = model.predict(X_test_processed, verbose=0).flatten()
+    mae = mean_absolute_error(y_test, y_pred)
+    rmse = np.sqrt(mean_squared_error(y_test, y_pred))
+    r2 = r2_score(y_test, y_pred)
+
+    new_metrics = {
+        "mae": mae,
+        "rmse": rmse,
+        "r2": r2,
+        "samples": len(X_train),
+        "timestamp": datetime.now().isoformat(),
+    }
+
+    print(f"📈 New Model Performance: MAE={mae:.2f}, RMSE={rmse:.2f}, R²={r2:.3f}")
+
+    # --- SELF-LEARNING: Compare with old model ---
+    training_history = load_training_history()
+    old_metrics = training_history.get(appliance_name, {}).get("best_metrics")
+
+    should_accept = compare_models(appliance_name, new_metrics, old_metrics)
+
+    if should_accept:
+        # Save NEW model as the current best
+        model.save(f"models/{appliance_name}_model.keras")
+
+        # Move temp preprocessor to final location
+        os.rename(
+            f"models/{appliance_name}_preprocessor_temp.pkl",
+            f"models/{appliance_name}_preprocessor.pkl",
+        )
+
+        # Update training history
+        training_history[appliance_name] = {
+            "best_metrics": new_metrics,
+            "training_history": training_history.get(appliance_name, {}).get(
+                "training_history", []
+            )
+            + [new_metrics],
+            "last_trained": datetime.now().isoformat(),
+        }
+        save_training_history(training_history)
+
+        print(f"✅ Model SAVED successfully")
+    else:
+        # Restore old model
+        if had_old_model:
+            restore_backup_model(appliance_name)
+            os.remove(f"models/{appliance_name}_preprocessor_temp.pkl")
+        print(f"⏮️  Kept existing model (better performance)")
+
+    # Log to CSV for analysis
+    log_performance_to_csv(appliance_name, new_metrics, should_accept)
+
+
+def main():
+    print("\n" + "=" * 70)
+    print(" 🎓 SELF-LEARNING AI TRAINING SYSTEM")
+    print(" 📊 Learning from ACTUAL vs PREDICTED kWh errors")
+    print("=" * 70)
+
+    # 1. Fetch Data with Error Calculations
+    df = fetch_training_data()
+    if df is None:
+        return
+
+    # Check if we have enough data to train
+    valid_samples = len(df[df["predicted_total_kwh"] > 0])
+    if valid_samples < 10:
+        print(
+            f"\n⚠️ Not enough data to train (only {valid_samples} samples with predictions)"
+        )
+        print("   Need at least 10 user predictions to start self-learning.")
+        print(
+            "   Continue using the system - training will happen automatically as data accumulates!"
+        )
+        return
+
+    print(
+        f"\n✅ Found {valid_samples} samples with predictions - starting self-learning!"
+    )
+
+    # 2. Train All Models with SELF-LEARNING
+    # Note: We map the Supabase columns to the expected feature names.
+
+    # --- MAJOR APPLIANCES ---
+    build_and_train_model(
+        df,
+        "ac",
+        "ac_kwh",
+        "has_ac",
+        [
+            "ac_hours_per_day",
+            "ac_tonnage",
+            "ac_star_rating",
+            "num_ac_units",
+            "ac_min_hours",
+            "ac_max_hours",
+        ],
+        ["ac_type", "ac_category"],
+    )
+    build_and_train_model(
+        df,
+        "fridge",
+        "refrigerator_kwh",
+        "has_refrigerator",
+        [
+            "fridge_capacity_liters",
+            "fridge_age_years",
+            "fridge_star_rating",
+            "fridge_min_hours",
+            "fridge_max_hours",
+        ],
+        ["fridge_type", "fridge_category"],
+    )
+    build_and_train_model(
+        df,
+        "washing_machine",
+        "washing_machine_kwh",
+        "has_washing_machine",
+        [
+            "wm_cycles_per_week",
+            "wm_capacity_kg",
+            "wm_star_rating",
+            "wm_min_hours",
+            "wm_max_hours",
+        ],
+        ["wm_type", "wm_category"],
+    )
+    build_and_train_model(
+        df,
+        "water_heater",
+        "water_heater_kwh",
+        "has_water_heater",
+        [
+            "water_heater_usage_hours",
+            "water_heater_capacity_liters",
+            "geyser_min_hours",
+            "geyser_max_hours",
+        ],
+        ["water_heater_type", "geyser_category"],
+    )
+    build_and_train_model(
+        df,
+        "water_pump",
+        "water_pump_kwh",
+        "has_water_pump",
+        [
+            "water_pump_usage_hours_per_day",
+            "water_pump_hp",
+            "pump_min_hours",
+            "pump_max_hours",
+        ],
+        ["pump_category"],
+    )
+    build_and_train_model(
+        df,
+        "television",
+        "television_kwh",
+        "has_television",
+        [
+            "tv_hours_per_day",
+            "tv_size_inches",
+            "num_televisions",
+            "tv_min_hours",
+            "tv_max_hours",
+        ],
+        ["tv_type", "tv_category"],
+    )
+
+    # --- KITCHEN & SMALL APPLIANCES ---
+    build_and_train_model(
+        df,
+        "mixer_grinder",
+        "mixer_grinder_kwh",
+        "has_mixer_grinder",
+        [
+            "mixer_grinder_usage_minutes_per_day",
+            "mixer_grinder_wattage",
+            "mixer_min_hours",
+            "mixer_max_hours",
+        ],
+        ["mixer_category"],
+    )
+    build_and_train_model(
+        df,
+        "microwave",
+        "microwave_kwh",
+        "has_microwave",
+        [
+            "microwave_usage_minutes_per_day",
+            "microwave_capacity_liters",
+            "microwave_min_hours",
+            "microwave_max_hours",
+        ],
+        ["microwave_category"],
+    )
+
+    # --- COOLING & LIGHTING ---
+    build_and_train_model(
+        df,
+        "ceiling_fan",
+        "ceiling_fans_kwh",
+        None,
+        [
+            "num_ceiling_fans",
+            "fan_hours_per_day",
+            "fan_star_rating",
+            "fan_min_hours",
+            "fan_max_hours",
+        ],
+        ["fan_category"],
+    )
+    build_and_train_model(
+        df,
+        "led_light",
+        "led_lights_kwh",
+        None,
+        ["num_led_lights", "light_hours_per_day", "led_min_hours", "led_max_hours"],
+        ["led_category"],
+    )
+    build_and_train_model(
+        df,
+        "tube_light",
+        "tube_lights_kwh",
+        None,
+        ["num_tube_lights", "light_hours_per_day", "tube_min_hours", "tube_max_hours"],
+        ["tube_category"],
+    )
+    build_and_train_model(
+        df,
+        "cfl_bulb",
+        "cfl_bulbs_kwh",
+        None,
+        ["num_cfl_bulbs", "light_hours_per_day", "cfl_min_hours", "cfl_max_hours"],
+        ["cfl_category"],
+    )
+
+    # --- NEW APPLIANCES ---
+    build_and_train_model(
+        df,
+        "desktop",
+        "desktop_kwh",
+        "has_computer",
+        ["desktop_hours_per_day", "desktop_min_hours", "desktop_max_hours"],
+        ["desktop_category"],
+    )
+    build_and_train_model(
+        df,
+        "laptop",
+        "laptop_kwh",
+        "has_laptop",
+        ["laptop_hours_per_day", "laptop_min_hours", "laptop_max_hours"],
+        ["laptop_category"],
+    )
+    build_and_train_model(
+        df,
+        "iron",
+        "iron_kwh",
+        "has_iron",
+        ["iron_hours_per_day", "iron_min_hours", "iron_max_hours"],
+        ["iron_category"],
+    )
+    build_and_train_model(
+        df,
+        "kettle",
+        "kettle_kwh",
+        "has_electric_kettle",
+        ["kettle_hours_per_day", "kettle_min_hours", "kettle_max_hours"],
+        ["kettle_category"],
+    )
+    build_and_train_model(
+        df,
+        "induction",
+        "induction_kwh",
+        "has_induction",
+        ["induction_hours_per_day", "induction_min_hours", "induction_max_hours"],
+        ["induction_category"],
+    )
+    build_and_train_model(
+        df,
+        "rice_cooker",
+        "rice_cooker_kwh",
+        "has_rice_cooker",
+        ["rice_cooker_hours_per_day", "rice_cooker_min_hours", "rice_cooker_max_hours"],
+        ["rice_cooker_category"],
+    )
+    build_and_train_model(
+        df,
+        "toaster",
+        "toaster_kwh",
+        "has_toaster",
+        ["toaster_hours_per_day", "toaster_min_hours", "toaster_max_hours"],
+        ["toaster_category"],
+    )
+    build_and_train_model(
+        df,
+        "food_processor",
+        "food_processor_kwh",
+        "has_food_processor",
+        [
+            "food_processor_hours_per_day",
+            "food_processor_min_hours",
+            "food_processor_max_hours",
+        ],
+        ["food_processor_category"],
+    )
+    build_and_train_model(
+        df,
+        "hair_dryer",
+        "hair_dryer_kwh",
+        "has_hair_dryer",
+        ["hair_dryer_hours_per_day", "hair_dryer_min_hours", "hair_dryer_max_hours"],
+        ["hair_dryer_category"],
+    )
+    build_and_train_model(
+        df,
+        "vacuum",
+        "vacuum_kwh",
+        "has_vacuum",
+        ["vacuum_hours_per_day", "vacuum_min_hours", "vacuum_max_hours"],
+        ["vacuum_category"],
+    )
+
+    # --- Export Training Data ---
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    export_training_data_to_csv(df, f"training_data/training_data_{timestamp}.csv")
+    export_training_data_to_csv(
+        df, "training_data/latest_training_data.csv"
+    )  # Always keep latest
+
+    print("\n" + "=" * 70)
+    print(" 🎓 SELF-LEARNING TRAINING SESSION COMPLETE")
+    print("=" * 70)
+    print(f"\n📊 Training Logs:")
+    print(f"   - History: {TRAINING_HISTORY_FILE}")
+    print(f"   - Performance CSV: {PERFORMANCE_LOG_CSV}")
+    print(f"   - Model Backups: models/backups/")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()

Training_Scripts/newdataset.py

@@ -0,0 +1,1008 @@
+"""
+Enhanced Monte Carlo Simulation  (Multi-Output Targets - Kerala Context)
+Author: SmartWatt Team
+Date: 2025-12-11
+Purpose: Generates dataset with 'Ground Truth' Efficiency and Effective Hours for Integrated Hybrid AI
+"""
+
+import warnings
+
+import numpy as np
+import pandas as pd
+
+warnings.filterwarnings("ignore")
+
+
+class KeralaRealWorldSimulator:
+    def __init__(self, n_households: int = 12000, random_seed: int = 42):
+        self.n = n_households
+        np.random.seed(random_seed)
+
+        # --- KERALA CONTEXT VARIABLES ---
+        # High Humidity -> Fans run longer
+        # Voltage Fluctuation -> Rural areas have lower efficiency
+        # Old Grid -> 10% transmission loss simulation
+
+    def generate_demographics(self):
+        data = {
+            "household_id": [f"KL__{i}" for i in range(self.n)],
+            "n_occupants": np.random.choice(
+                [2, 3, 4, 5, 6], size=self.n, p=[0.1, 0.25, 0.40, 0.15, 0.1]
+            ),
+            "location_type": np.random.choice(
+                ["urban", "rural"], size=self.n, p=[0.6, 0.4]
+            ),
+            "total_kwh_monthly": np.zeros(self.n),  # Will sum up later
+        }
+        return pd.DataFrame(data)
+
+    def generate_ac_data(self, df):
+        # 45% Penetration
+        has_ac = np.random.random(self.n) < 0.45
+        df["has_ac"] = has_ac.astype(int)
+
+        # 1. Specs (What kind of AC do they have?)
+        df["ac_tonnage"] = np.where(
+            has_ac, np.random.choice([1.0, 1.5], size=self.n, p=[0.3, 0.7]), 0
+        )
+        df["ac_star_rating"] = np.where(
+            has_ac, np.random.choice([3, 5], size=self.n, p=[0.6, 0.4]), 0
+        )
+
+        # New Field: ac_age_years (Integrated from add_ac_age.py)
+        df["ac_age_years"] = np.where(
+            has_ac,
+            np.random.choice(
+                ["0-2", "3-5", "6-10", "10+"], size=self.n, p=[0.20, 0.35, 0.30, 0.15]
+            ),
+            "unknown",
+        )
+
+        # UI Fields: ac_type, ac_usage_pattern
+        df["ac_type"] = np.where(
+            has_ac,
+            np.random.choice(
+                ["split", "window", "inverter"], size=self.n, p=[0.6, 0.2, 0.2]
+            ),
+            "unknown",
+        )
+        df["ac_usage_pattern"] = np.where(
+            has_ac,
+            np.random.choice(
+                ["heavy", "moderate", "light"], size=self.n, p=[0.2, 0.5, 0.3]
+            ),
+            "none",
+        )
+
+        # 2. BEHAVIOR (The 'Secret' Human Factor)
+        # Generate hours based on usage pattern (AI learns this correlation)
+        # In Kerala, humidity makes AC run longer than expected
+        base_hours = np.where(
+            df["ac_usage_pattern"] == "light",
+            np.random.uniform(2, 6, self.n),
+            np.where(
+                df["ac_usage_pattern"] == "moderate",
+                np.random.uniform(6, 10, self.n),
+                np.where(
+                    df["ac_usage_pattern"] == "heavy",
+                    np.random.uniform(10, 14, self.n),
+                    0,
+                ),
+            ),
+        )
+
+        # Kerala humidity factor (compressor works harder)
+        humidity_factor = np.random.normal(
+            1.15, 0.05, self.n
+        )  # 15% extra load due to humidity
+        df["ac_real_effective_hours"] = np.where(
+            has_ac, base_hours * humidity_factor, 0
+        )
+
+        # 3. EFFICIENCY (The 'Wear and Tear' Factor)
+        # Rural areas often suffer from voltage drops.
+        # A low voltage supply makes the AC compressor struggle, reducing efficiency by ~10%.
+        efficiency = np.random.normal(
+            0.95, 0.05, self.n
+        )  # Most ACs work at 95% optimal efficiency
+        rural_mask = (df["location_type"] == "rural") & has_ac
+        efficiency[rural_mask] -= 0.10  # Penalty for rural grid quality
+        df["ac_real_efficiency_factor"] = np.where(has_ac, efficiency.clip(0.6, 1.1), 0)
+
+        # 4. The Physics Calculation (Ground Truth)
+        # Physics Formula: Watts = Tons * 1200 / Efficiency
+        watts = (df["ac_tonnage"] * 1200) * (1 + (5 - df["ac_star_rating"]) * 0.1)
+
+        # If efficiency is low (e.g., 0.8), power consumption goes UP.
+        # It's an inverse relationship: Worse Efficiency = Higher Bill.
+        watts = watts / df["ac_real_efficiency_factor"]
+
+        # Final Bill Calculation: (Watts * Hours * 30 days) / 1000 to get units (kWh)
+        df["ac_kwh"] = (watts * df["ac_real_effective_hours"] * 30) / 1000
+        return df
+
+    def generate_fridge_data(self, df):
+        # 95% Penetration
+        has_fridge = np.random.random(self.n) < 0.95
+        df["has_refrigerator"] = has_fridge.astype(int)
+
+        # Specs
+        df["fridge_capacity"] = np.where(
+            has_fridge, np.random.choice([190, 260], size=self.n), 0
+        )
+        df["fridge_age"] = np.where(
+            has_fridge, np.random.choice([2, 5, 10], size=self.n, p=[0.3, 0.4, 0.3]), 0
+        )
+        df["fridge_star_rating"] = np.where(
+            has_fridge,
+            np.random.choice([2, 3, 4, 5], size=self.n, p=[0.2, 0.3, 0.3, 0.2]),
+            0,
+        )
+
+        # UI Fields: fridge_type
+        df["fridge_type"] = np.where(
+            has_fridge,
+            np.random.choice(["frost_free", "direct_cool"], size=self.n, p=[0.7, 0.3]),
+            "unknown",
+        )
+
+        # BEHAVIOR: AI Pattern Learning
+        df["refrigerator_usage_pattern"] = np.where(
+            has_fridge,
+            np.random.choice(
+                ["manual", "light", "normal", "always"],
+                size=self.n,
+                p=[0.05, 0.10, 0.20, 0.65],
+            ),
+            "unknown",
+        )
+
+        # Pattern-based hour ranges
+        pattern_hours_map = {
+            "manual": np.random.uniform(8, 14, self.n),  # Turn off at night
+            "light": np.random.uniform(14, 18, self.n),  # Off during low usage
+            "normal": np.random.uniform(18, 22, self.n),  # Mostly on
+            "always": np.full(self.n, 24.0),  # 24/7 operation
+        }
+        hours = np.zeros(self.n)
+        for pattern, hours_range in pattern_hours_map.items():
+            hours = np.where(
+                df["refrigerator_usage_pattern"] == pattern, hours_range, hours
+            )
+
+        df["fridge_real_effective_hours"] = np.where(has_fridge, hours, 0)
+
+        # EFFICIENCY:
+        # In the hot Kerala climate, rubber seals on fridges degrade faster.
+        # An old fridge leaks cold air, making the motor run longer. We deduct 4% efficiency per year.
+        eff = np.ones(self.n)
+        eff -= df["fridge_age"] * 0.04
+        df["fridge_real_efficiency_factor"] = np.where(
+            has_fridge, eff.clip(0.5, 1.0), 0
+        )
+
+        # Calculation
+        watts = (df["fridge_capacity"] / 250) * 200  # Baseline
+        watts = watts / df["fridge_real_efficiency_factor"]
+        df["fridge_kwh"] = (watts * df["fridge_real_effective_hours"] * 30) / 1000
+        return df
+
+    def generate_fan_data(self, df):
+        # 98% Penetration (Essential in Kerala)
+        df["has_ceiling_fan"] = (np.random.random(self.n) < 0.98).astype(int)
+
+        # UI Fields: fan_type, num_fans
+        df["fan_type"] = np.where(
+            df["has_ceiling_fan"],
+            np.random.choice(["standard", "bldc"], size=self.n, p=[0.8, 0.2]),
+            "unknown",
+        )
+        df["num_fans"] = np.where(
+            df["has_ceiling_fan"],
+            np.random.choice(
+                [2, 3, 4, 5, 6], size=self.n, p=[0.1, 0.25, 0.35, 0.2, 0.1]
+            ),
+            0,
+        )
+
+        # BEHAVIOR: AI Pattern Learning
+        df["fan_usage_pattern"] = np.where(
+            df["has_ceiling_fan"],
+            np.random.choice(
+                ["rarely", "few", "most", "all"],
+                size=self.n,
+                p=[0.05, 0.20, 0.50, 0.25],
+            ),
+            "unknown",
+        )
+
+        # Pattern-based hour ranges (Kerala humidity = high usage)
+        pattern_hours_map = {
+            "rarely": np.random.uniform(2, 5, self.n),  # AC users
+            "few": np.random.uniform(5, 10, self.n),  # Few rooms
+            "most": np.random.uniform(10, 16, self.n),  # Most rooms
+            "all": np.random.uniform(16, 22, self.n),  # All rooms all day
+        }
+        base_hours = np.zeros(self.n)
+        for pattern, hours_range in pattern_hours_map.items():
+            base_hours = np.where(
+                df["fan_usage_pattern"] == pattern, hours_range, base_hours
+            )
+
+        # Humidity boost (Kerala climate)
+        humidity_boost = np.random.normal(1.2, 0.1, self.n)
+        df["ceiling_fan_real_effective_hours"] = np.where(
+            df["has_ceiling_fan"], (base_hours * humidity_boost).clip(2, 24), 0
+        )
+
+        # EFFICIENCY: Old fans get slow/power hungry
+        df["ceiling_fan_age"] = np.random.choice(
+            [2, 5, 10, 15], size=self.n, p=[0.2, 0.3, 0.3, 0.2]
+        )
+        eff = np.ones(self.n) - (df["ceiling_fan_age"] * 0.01)  # 1% drop/year
+        df["ceiling_fan_real_efficiency_factor"] = np.where(
+            df["has_ceiling_fan"], eff.clip(0.7, 1.0), 0
+        )
+
+        # Power calculation
+        watts = 75 / df["ceiling_fan_real_efficiency_factor"]
+        df["ceiling_fan_kwh"] = (
+            watts * df["ceiling_fan_real_effective_hours"] * df["num_fans"] * 30
+        ) / 1000
+        return df
+
+    def generate_tv_data(self, df):
+        # 95% Penetration
+        df["has_television"] = (np.random.random(self.n) < 0.95).astype(int)
+
+        # BEHAVIOR: The "Serial" factor.
+        # In Kerala households, evening TV serials and news are a staple.
+        # We assume 4-6 hours of usage is standard usage.
+        # Generate usage patterns first (light/moderate/heavy/always)
+        df["television_usage_pattern"] = np.where(
+            df["has_television"],
+            np.random.choice(
+                ["light", "moderate", "heavy", "always"],
+                size=self.n,
+                p=[0.25, 0.45, 0.25, 0.05],
+            ),
+            "none",
+        )
+
+        # Generate hours based on pattern + household context (AI will learn this correlation)
+        base_hours = np.where(
+            df["television_usage_pattern"] == "light",
+            np.random.uniform(1, 3, self.n),
+            np.where(
+                df["television_usage_pattern"] == "moderate",
+                np.random.uniform(3, 5, self.n),
+                np.where(
+                    df["television_usage_pattern"] == "heavy",
+                    np.random.uniform(5, 8, self.n),
+                    np.where(
+                        df["television_usage_pattern"] == "always",
+                        np.random.uniform(8, 12, self.n),
+                        0,
+                    ),
+                ),
+            ),
+        )
+
+        # Add household context influence (more people = slightly more hours)
+        occupant_factor = (
+            1 + (df["n_occupants"] - 4) * 0.05
+        )  # ±5% per person difference from 4
+        hours = (base_hours * occupant_factor).clip(1, 14)
+
+        df["television_real_effective_hours"] = np.where(df["has_television"], hours, 0)
+
+        # Efficiency (LED vs CRT/LCD)
+        df["television_type"] = np.random.choice(
+            ["LED", "CRT", "LCD"], size=self.n, p=[0.7, 0.1, 0.2]
+        )
+
+        # UI Fields: tv_size
+        df["tv_size"] = np.where(
+            df["has_television"],
+            np.random.choice([32, 43, 55], size=self.n, p=[0.4, 0.4, 0.2]),
+            0,
+        )
+
+        base_watts = np.where(
+            df["television_type"] == "LED",
+            80,
+            np.where(df["television_type"] == "LCD", 120, 150),
+        )
+        eff = np.ones(self.n)
+        df["television_real_efficiency_factor"] = np.where(df["has_television"], eff, 0)
+        df["television_kwh"] = (
+            base_watts * df["television_real_effective_hours"] * 30
+        ) / 1000
+        return df
+
+    def generate_wm_data(self, df):
+        # 60% Penetration
+        df["has_washing_machine"] = (np.random.random(self.n) < 0.60).astype(int)
+
+        # UI Fields: wm_type, wm_capacity, wm_star_rating, wm_cycles_per_week
+        df["wm_type"] = np.where(
+            df["has_washing_machine"],
+            np.random.choice(
+                ["top_load", "front_load", "semi_automatic"],
+                size=self.n,
+                p=[0.5, 0.35, 0.15],
+            ),
+            "unknown",
+        )
+        df["wm_capacity"] = np.where(
+            df["has_washing_machine"],
+            np.random.choice([5, 6, 7, 8], size=self.n, p=[0.2, 0.3, 0.3, 0.2]),
+            0,
+        )
+        df["wm_star_rating"] = np.where(
+            df["has_washing_machine"],
+            np.random.choice([2, 3, 4, 5], size=self.n, p=[0.2, 0.3, 0.3, 0.2]),
+            0,
+        )
+
+        # BEHAVIOR: Cycles Per Week dependent on Occupants
+        # 2 people -> 2 cycles/week
+        # 4+ people -> 4-6 cycles/week
+        cycles = (df["n_occupants"] * 1.2) + np.random.normal(0, 1, self.n)
+        df["wm_cycles_per_week"] = np.where(
+            df["has_washing_machine"], cycles.clip(1, 10), 0
+        )
+        df["washing_machine_real_effective_hours"] = df[
+            "wm_cycles_per_week"
+        ]  # Storing Cycles as "Hours" for simplicity in training
+
+        # Efficiency
+        df["washing_machine_real_efficiency_factor"] = 1.0
+
+        base_kwh_per_cycle = 0.5  # Avg
+        df["washing_machine_kwh"] = (
+            base_kwh_per_cycle * df["washing_machine_real_effective_hours"] * 4.3
+        )
+        return df
+
+    def generate_pump_data(self, df):
+        # 70% Penetration (Well Water is common in Kerala)
+        df["has_water_pump"] = (np.random.random(self.n) < 0.70).astype(int)
+
+        # UI Fields: water_pump_hp
+        df["water_pump_hp"] = np.where(
+            df["has_water_pump"],
+            np.random.choice([0.5, 1.0, 1.5], size=self.n, p=[0.3, 0.5, 0.2]),
+            0,
+        )
+
+        # BEHAVIOR: AI Pattern Learning
+        df["pump_usage_pattern"] = np.where(
+            df["has_water_pump"],
+            np.random.choice(
+                ["minimal", "light", "moderate", "heavy"],
+                size=self.n,
+                p=[0.15, 0.35, 0.40, 0.10],
+            ),
+            "unknown",
+        )
+
+        # Pattern-based minute ranges
+        pattern_mins_map = {
+            "minimal": np.random.uniform(10, 20, self.n),  # Municipal backup
+            "light": np.random.uniform(20, 40, self.n),  # Occasional pumping
+            "moderate": np.random.uniform(40, 70, self.n),  # Regular well usage
+            "heavy": np.random.uniform(70, 120, self.n),  # Primary water source
+        }
+        base_mins = np.zeros(self.n)
+        for pattern, mins in pattern_mins_map.items():
+            base_mins = np.where(df["pump_usage_pattern"] == pattern, mins, base_mins)
+
+        # Occupancy influence (more people = more water)
+        occupant_factor = 1 + (df["n_occupants"] - 4) * 0.12
+        hours = (base_mins * occupant_factor) / 60
+        df["water_pump_real_effective_hours"] = np.where(
+            df["has_water_pump"], hours.clip(0.15, 2.5), 0
+        )
+
+        # Efficiency (Old pumps are terrible)
+        eff = np.random.normal(0.8, 0.1, self.n).clip(0.5, 1.0)
+        df["water_pump_real_efficiency_factor"] = np.where(df["has_water_pump"], eff, 0)
+
+        watts = (df["water_pump_hp"] * 746) / df[
+            "water_pump_real_efficiency_factor"
+        ]  # HP to Watts
+        df["water_pump_kwh"] = (
+            watts * df["water_pump_real_effective_hours"] * 30
+        ) / 1000
+        return df
+
+    def generate_geyser_data(self, df):
+        # 40% Penetration (Urban mainly)
+        df["has_water_heater"] = (np.random.random(self.n) < 0.40).astype(int)
+
+        # UI Fields: water_heater_type, water_heater_capacity
+        df["water_heater_type"] = np.where(
+            df["has_water_heater"],
+            np.random.choice(
+                ["instant", "storage", "gas", "solar"],
+                size=self.n,
+                p=[0.4, 0.4, 0.1, 0.1],
+            ),
+            "unknown",
+        )
+        df["water_heater_capacity"] = np.where(
+            df["has_water_heater"],
+            np.random.choice([10, 15, 25, 35], size=self.n, p=[0.3, 0.4, 0.2, 0.1]),
+            0,
+        )
+
+        # BEHAVIOR: AI Pattern Learning + Seasonality
+        df["season"] = np.random.choice(["summer", "monsoon", "winter"], size=self.n)
+
+        df["geyser_usage_pattern"] = np.where(
+            df["has_water_heater"],
+            np.random.choice(
+                ["minimal", "light", "moderate", "heavy"],
+                size=self.n,
+                p=[0.20, 0.40, 0.30, 0.10],
+            ),
+            "unknown",
+        )
+
+        # Pattern-based hour ranges
+        pattern_hours_map = {
+            "minimal": np.random.uniform(0.2, 0.5, self.n),  # Quick showers
+            "light": np.random.uniform(0.5, 1.0, self.n),  # 1-2 showers/day
+            "moderate": np.random.uniform(1.0, 1.8, self.n),  # Regular family use
+            "heavy": np.random.uniform(1.8, 3.0, self.n),  # Multiple long showers
+        }
+        base_hours = np.zeros(self.n)
+        for pattern, hours_range in pattern_hours_map.items():
+            base_hours = np.where(
+                df["geyser_usage_pattern"] == pattern, hours_range, base_hours
+            )
+
+        # Season multiplier (winter = more hot water)
+        season_factor = np.where(
+            df["season"] == "summer", 0.5, np.where(df["season"] == "monsoon", 1.0, 2.0)
+        )
+
+        # Occupancy influence
+        occupant_factor = 1 + (df["n_occupants"] - 4) * 0.10
+
+        hours = base_hours * season_factor * occupant_factor
+
+        df["water_heater_real_effective_hours"] = np.where(
+            df["has_water_heater"], hours, 0
+        )
+        df["water_heater_real_efficiency_factor"] = 1.0  # Static
+
+        df["water_heater_kwh"] = (
+            2000 * df["water_heater_real_effective_hours"] * 30
+        ) / 1000
+        return df
+
+    def generate_misc_data(self, df):
+        # 1. Iron Box (90% Penetration)
+        df["has_iron"] = (np.random.random(self.n) < 0.90).astype(int)
+
+        # Add usage pattern for iron
+        df["iron_usage_pattern"] = np.where(
+            df["has_iron"],
+            np.random.choice(
+                ["rarely", "light", "moderate", "heavy"],
+                size=self.n,
+                p=[0.15, 0.50, 0.30, 0.05],
+            ),
+            "none",
+        )
+
+        # Generate hours based on pattern + household context
+        base_hours = np.where(
+            df["iron_usage_pattern"] == "rarely",
+            np.random.uniform(0.08, 0.25, self.n),  # 5-15 min
+            np.where(
+                df["iron_usage_pattern"] == "light",
+                np.random.uniform(0.25, 0.50, self.n),  # 15-30 min
+                np.where(
+                    df["iron_usage_pattern"] == "moderate",
+                    np.random.uniform(0.50, 1.0, self.n),  # 30-60 min
+                    np.where(
+                        df["iron_usage_pattern"] == "heavy",
+                        np.random.uniform(1.0, 2.0, self.n),
+                        0,
+                    ),
+                ),
+            ),
+        )  # 1-2 hrs
+
+        occupant_factor = (
+            1 + (df["n_occupants"] - 4) * 0.10
+        )  # More people = more clothes
+        df["iron_real_effective_hours"] = np.where(
+            df["has_iron"], (base_hours * occupant_factor).clip(0.08, 2.5), 0
+        )
+        df["iron_real_efficiency_factor"] = 1.0
+
+        # 2. Electric Kettle (45%) - AI Pattern Learning
+        df["has_electric_kettle"] = (np.random.random(self.n) < 0.45).astype(int)
+        df["kettle_usage_pattern"] = np.where(
+            df["has_electric_kettle"],
+            np.random.choice(
+                ["rarely", "light", "moderate", "heavy"],
+                size=self.n,
+                p=[0.15, 0.35, 0.40, 0.10],
+            ),
+            "unknown",
+        )
+        # Pattern-based minute ranges
+        pattern_mins_map = {
+            "rarely": np.random.uniform(3, 8, self.n),  # Occasional tea/coffee
+            "light": np.random.uniform(8, 15, self.n),  # 1-2 times/day
+            "moderate": np.random.uniform(15, 25, self.n),  # 3-4 times/day
+            "heavy": np.random.uniform(25, 40, self.n),  # Frequent use
+        }
+        base_mins = np.zeros(self.n)
+        for pattern, mins in pattern_mins_map.items():
+            base_mins = np.where(df["kettle_usage_pattern"] == pattern, mins, base_mins)
+
+        occupant_factor = 1 + (df["n_occupants"] - 4) * 0.06
+        df["kettle_real_effective_hours"] = np.where(
+            df["has_electric_kettle"],
+            ((base_mins * occupant_factor) / 60).clip(0.05, 0.8),
+            0,
+        )
+        df["kettle_real_efficiency_factor"] = 1.0
+
+        # 3. Induction (65%) - AI Pattern Learning
+        df["has_induction"] = (np.random.random(self.n) < 0.65).astype(int)
+        df["induction_usage_pattern"] = np.where(
+            df["has_induction"],
+            np.random.choice(
+                ["light", "moderate", "heavy", "very_heavy"],
+                size=self.n,
+                p=[0.25, 0.45, 0.25, 0.05],
+            ),
+            "unknown",
+        )
+        # Pattern-based hour ranges
+        pattern_hours_map = {
+            "light": np.random.uniform(0.3, 0.8, self.n),  # Backup cooking
+            "moderate": np.random.uniform(0.8, 1.5, self.n),  # Regular use
+            "heavy": np.random.uniform(1.5, 2.5, self.n),  # Primary cooking
+            "very_heavy": np.random.uniform(2.5, 4.0, self.n),  # All meals
+        }
+        base_hours = np.zeros(self.n)
+        for pattern, hours in pattern_hours_map.items():
+            base_hours = np.where(
+                df["induction_usage_pattern"] == pattern, hours, base_hours
+            )
+
+        occupant_factor = 1 + (df["n_occupants"] - 4) * 0.08
+        df["induction_real_effective_hours"] = np.where(
+            df["has_induction"], (base_hours * occupant_factor).clip(0.3, 4.5), 0
+        )
+        df["induction_real_efficiency_factor"] = 1.0
+
+        # 4. PC/Desktop (55%)
+        df["has_computer"] = (np.random.random(self.n) < 0.55).astype(int)
+
+        # Add usage pattern for desktop
+        df["desktop_usage_pattern"] = np.where(
+            df["has_computer"],
+            np.random.choice(
+                ["light", "moderate", "heavy", "always"],
+                size=self.n,
+                p=[0.30, 0.40, 0.25, 0.05],
+            ),
+            "none",
+        )
+
+        # Generate hours based on pattern
+        pc_hours = np.where(
+            df["desktop_usage_pattern"] == "light",
+            np.random.uniform(1, 2, self.n),
+            np.where(
+                df["desktop_usage_pattern"] == "moderate",
+                np.random.uniform(3, 5, self.n),
+                np.where(
+                    df["desktop_usage_pattern"] == "heavy",
+                    np.random.uniform(6, 10, self.n),
+                    np.where(
+                        df["desktop_usage_pattern"] == "always",
+                        np.random.uniform(20, 24, self.n),
+                        0,
+                    ),
+                ),
+            ),
+        )
+
+        df["desktop_real_effective_hours"] = np.where(df["has_computer"], pc_hours, 0)
+        df["desktop_real_efficiency_factor"] = 1.0
+
+        # Calc kWh
+        df["iron_kwh"] = (1000 * df["iron_real_effective_hours"] * 30) / 1000
+        df["kettle_kwh"] = (1500 * df["kettle_real_effective_hours"] * 30) / 1000
+        df["induction_kwh"] = (2000 * df["induction_real_effective_hours"] * 30) / 1000
+        df["desktop_kwh"] = (250 * df["desktop_real_effective_hours"] * 30) / 1000
+
+        return df
+
+    def generate_kitchen_others(self, df):
+        # Microwave (30%) - AI Pattern Learning
+        df["has_microwave"] = (np.random.random(self.n) < 0.30).astype(int)
+        df["microwave_usage_pattern"] = np.where(
+            df["has_microwave"],
+            np.random.choice(
+                ["rarely", "light", "moderate", "heavy"],
+                size=self.n,
+                p=[0.15, 0.40, 0.35, 0.10],
+            ),
+            "unknown",
+        )
+        # Pattern-based minute ranges
+        pattern_mins_map = {
+            "rarely": np.random.uniform(3, 8, self.n),  # Occasional reheating
+            "light": np.random.uniform(8, 15, self.n),  # Few times/week
+            "moderate": np.random.uniform(15, 25, self.n),  # Daily usage
+            "heavy": np.random.uniform(25, 40, self.n),  # Multiple daily uses
+        }
+        base_mins = np.zeros(self.n)
+        for pattern, mins in pattern_mins_map.items():
+            base_mins = np.where(
+                df["microwave_usage_pattern"] == pattern, mins, base_mins
+            )
+
+        occupant_factor = 1 + (df["n_occupants"] - 4) * 0.05
+        df["microwave_real_effective_hours"] = np.where(
+            df["has_microwave"], ((base_mins * occupant_factor) / 60).clip(0.05, 0.8), 0
+        )
+        df["microwave_real_efficiency_factor"] = 1.0
+
+        # Mixer (95%) - AI Pattern Learning
+        df["has_mixer"] = (np.random.random(self.n) < 0.95).astype(int)
+        df["mixer_usage_pattern"] = np.where(
+            df["has_mixer"],
+            np.random.choice(
+                ["rarely", "light", "moderate", "heavy"],
+                size=self.n,
+                p=[0.10, 0.30, 0.45, 0.15],
+            ),
+            "unknown",
+        )
+        # Pattern-based minute ranges
+        pattern_mins_map = {
+            "rarely": np.random.uniform(5, 10, self.n),  # Occasional use
+            "light": np.random.uniform(10, 20, self.n),  # Few times/week
+            "moderate": np.random.uniform(20, 35, self.n),  # Daily grinding
+            "heavy": np.random.uniform(35, 50, self.n),  # Heavy kitchen work
+        }
+        base_mins = np.zeros(self.n)
+        for pattern, mins in pattern_mins_map.items():
+            base_mins = np.where(df["mixer_usage_pattern"] == pattern, mins, base_mins)
+
+        occupant_factor = 1 + (df["n_occupants"] - 4) * 0.06
+        df["mixer_real_effective_hours"] = np.where(
+            df["has_mixer"], ((base_mins * occupant_factor) / 60).clip(0.08, 1.0), 0
+        )
+        df["mixer_real_efficiency_factor"] = 1.0
+
+        # Rice Cooker (20%) - AI Pattern Learning
+        df["has_rice_cooker"] = (np.random.random(self.n) < 0.20).astype(int)
+        df["rice_cooker_usage_pattern"] = np.where(
+            df["has_rice_cooker"],
+            np.random.choice(
+                ["rarely", "light", "moderate", "heavy"],
+                size=self.n,
+                p=[0.15, 0.35, 0.40, 0.10],
+            ),
+            "unknown",
+        )
+        # Pattern-based minute ranges
+        pattern_mins_map = {
+            "rarely": np.random.uniform(15, 25, self.n),  # Once/twice a week
+            "light": np.random.uniform(20, 30, self.n),  # Few times/week
+            "moderate": np.random.uniform(30, 40, self.n),  # Daily cooking
+            "heavy": np.random.uniform(40, 60, self.n),  # Multiple meals
+        }
+        base_mins = np.zeros(self.n)
+        for pattern, mins in pattern_mins_map.items():
+            base_mins = np.where(
+                df["rice_cooker_usage_pattern"] == pattern, mins, base_mins
+            )
+
+        occupant_factor = 1 + (df["n_occupants"] - 4) * 0.07
+        df["rice_cooker_real_effective_hours"] = np.where(
+            df["has_rice_cooker"],
+            ((base_mins * occupant_factor) / 60).clip(0.25, 1.2),
+            0,
+        )
+        df["rice_cooker_real_efficiency_factor"] = 1.0
+
+        # Toaster (10%) - AI Pattern Learning
+        df["has_toaster"] = (np.random.random(self.n) < 0.10).astype(int)
+        df["toaster_usage_pattern"] = np.where(
+            df["has_toaster"],
+            np.random.choice(
+                ["rarely", "light", "moderate", "heavy"],
+                size=self.n,
+                p=[0.25, 0.40, 0.25, 0.10],
+            ),
+            "unknown",
+        )
+        # Pattern-based minute ranges
+        pattern_mins_map = {
+            "rarely": np.random.uniform(2, 5, self.n),  # Weekend breakfast
+            "light": np.random.uniform(5, 10, self.n),  # Few times/week
+            "moderate": np.random.uniform(10, 15, self.n),  # Daily breakfast
+            "heavy": np.random.uniform(15, 25, self.n),  # Multiple daily use
+        }
+        base_mins = np.zeros(self.n)
+        for pattern, mins in pattern_mins_map.items():
+            base_mins = np.where(
+                df["toaster_usage_pattern"] == pattern, mins, base_mins
+            )
+
+        occupant_factor = 1 + (df["n_occupants"] - 4) * 0.04
+        df["toaster_real_effective_hours"] = np.where(
+            df["has_toaster"], ((base_mins * occupant_factor) / 60).clip(0.03, 0.5), 0
+        )
+        df["toaster_real_efficiency_factor"] = 1.0
+
+        # Food Processor (15%) - AI Pattern Learning
+        df["has_food_processor"] = (np.random.random(self.n) < 0.15).astype(int)
+        df["food_processor_usage_pattern"] = np.where(
+            df["has_food_processor"],
+            np.random.choice(
+                ["rarely", "light", "moderate", "heavy"],
+                size=self.n,
+                p=[0.20, 0.40, 0.30, 0.10],
+            ),
+            "unknown",
+        )
+        # Pattern-based minute ranges
+        pattern_mins_map = {
+            "rarely": np.random.uniform(5, 10, self.n),  # Occasional prep
+            "light": np.random.uniform(10, 18, self.n),  # Weekly usage
+            "moderate": np.random.uniform(18, 30, self.n),  # Regular cooking
+            "heavy": np.random.uniform(30, 45, self.n),  # Daily food prep
+        }
+        base_mins = np.zeros(self.n)
+        for pattern, mins in pattern_mins_map.items():
+            base_mins = np.where(
+                df["food_processor_usage_pattern"] == pattern, mins, base_mins
+            )
+
+        occupant_factor = 1 + (df["n_occupants"] - 4) * 0.05
+        df["food_processor_real_effective_hours"] = np.where(
+            df["has_food_processor"],
+            ((base_mins * occupant_factor) / 60).clip(0.08, 0.9),
+            0,
+        )
+        df["food_processor_real_efficiency_factor"] = 1.0
+
+        # Calc kWh
+        df["microwave_kwh"] = (1200 * df["microwave_real_effective_hours"] * 30) / 1000
+        df["mixer_kwh"] = (750 * df["mixer_real_effective_hours"] * 30) / 1000
+        df["rice_cooker_kwh"] = (
+            600 * df["rice_cooker_real_effective_hours"] * 30
+        ) / 1000
+        df["toaster_kwh"] = (800 * df["toaster_real_effective_hours"] * 30) / 1000
+        df["food_processor_kwh"] = (
+            600 * df["food_processor_real_effective_hours"] * 30
+        ) / 1000
+        return df
+
+    def generate_personal_others(self, df):
+        # Laptop (40%) - AI Pattern Learning
+        df["has_laptop"] = (np.random.random(self.n) < 0.40).astype(int)
+        df["laptop_usage_pattern"] = np.where(
+            df["has_laptop"],
+            np.random.choice(
+                ["light", "moderate", "heavy", "always"],
+                size=self.n,
+                p=[0.30, 0.40, 0.25, 0.05],
+            ),
+            "unknown",
+        )
+        # Pattern-based hour ranges (work/study related)
+        pattern_hours_map = {
+            "light": np.random.uniform(1, 3, self.n),  # Light browsing
+            "moderate": np.random.uniform(3, 6, self.n),  # Regular work
+            "heavy": np.random.uniform(6, 12, self.n),  # Professional use
+            "always": np.random.uniform(12, 20, self.n),  # WFH/Developers
+        }
+        base_hours = np.zeros(self.n)
+        for pattern, hours in pattern_hours_map.items():
+            base_hours = np.where(
+                df["laptop_usage_pattern"] == pattern, hours, base_hours
+            )
+
+        # Occupancy influence: More people = more usage
+        occupant_factor = 1 + (df["n_occupants"] - 4) * 0.03
+        df["laptop_real_effective_hours"] = np.where(
+            df["has_laptop"], (base_hours * occupant_factor).clip(0.5, 20), 0
+        )
+        df["laptop_real_efficiency_factor"] = 1.0
+
+        # Hair Dryer (20%) - AI Pattern Learning
+        df["has_hair_dryer"] = (np.random.random(self.n) < 0.20).astype(int)
+        df["hair_dryer_usage_pattern"] = np.where(
+            df["has_hair_dryer"],
+            np.random.choice(
+                ["rarely", "light", "moderate", "heavy"],
+                size=self.n,
+                p=[0.30, 0.40, 0.20, 0.10],
+            ),
+            "unknown",
+        )
+        # Pattern-based minute ranges
+        pattern_mins_map = {
+            "rarely": np.random.uniform(2, 5, self.n),  # Once/twice a week
+            "light": np.random.uniform(5, 10, self.n),  # Few times a week
+            "moderate": np.random.uniform(10, 20, self.n),  # Daily short use
+            "heavy": np.random.uniform(20, 40, self.n),  # Daily long hair
+        }
+        base_mins = np.zeros(self.n)
+        for pattern, mins in pattern_mins_map.items():
+            base_mins = np.where(
+                df["hair_dryer_usage_pattern"] == pattern, mins, base_mins
+            )
+
+        # Occupancy influence (more family members = more usage)
+        occupant_factor = 1 + (df["n_occupants"] - 4) * 0.08
+        df["hair_dryer_real_effective_hours"] = np.where(
+            df["has_hair_dryer"],
+            ((base_mins * occupant_factor) / 60).clip(0.03, 0.8),
+            0,
+        )
+        df["hair_dryer_real_efficiency_factor"] = 1.0
+
+        # Vacuum (15%) - AI Pattern Learning
+        df["has_vacuum"] = (np.random.random(self.n) < 0.15).astype(int)
+        df["vacuum_usage_pattern"] = np.where(
+            df["has_vacuum"],
+            np.random.choice(
+                ["rarely", "light", "moderate", "heavy"],
+                size=self.n,
+                p=[0.20, 0.40, 0.30, 0.10],
+            ),
+            "unknown",
+        )
+        # Pattern-based minute ranges
+        pattern_mins_map = {
+            "rarely": np.random.uniform(5, 15, self.n),  # Once/twice a month
+            "light": np.random.uniform(10, 20, self.n),  # Weekly cleaning
+            "moderate": np.random.uniform(20, 40, self.n),  # 2-3 times/week
+            "heavy": np.random.uniform(40, 60, self.n),  # Daily cleaning
+        }
+        base_mins = np.zeros(self.n)
+        for pattern, mins in pattern_mins_map.items():
+            base_mins = np.where(df["vacuum_usage_pattern"] == pattern, mins, base_mins)
+
+        # Occupancy influence (larger households need more cleaning)
+        occupant_factor = 1 + (df["n_occupants"] - 4) * 0.08
+        df["vacuum_real_effective_hours"] = np.where(
+            df["has_vacuum"], ((base_mins * occupant_factor) / 60).clip(0.08, 1.2), 0
+        )
+        df["vacuum_real_efficiency_factor"] = 1.0
+
+        # Calc kWh
+        df["laptop_kwh"] = (60 * df["laptop_real_effective_hours"] * 30) / 1000
+        df["hair_dryer_kwh"] = (
+            1200 * df["hair_dryer_real_effective_hours"] * 30
+        ) / 1000
+        df["vacuum_kwh"] = (1400 * df["vacuum_real_effective_hours"] * 30) / 1000
+        return df
+
+    def generate_lights_data(self, df):
+        # AI Pattern Learning for all light types
+        # LED (100% penetration)
+        df["has_led_lights"] = 1
+        df["led_lights_usage_pattern"] = np.random.choice(
+            ["evening", "morning_evening", "most", "all"],
+            size=self.n,
+            p=[0.20, 0.45, 0.30, 0.05],
+        )
+
+        # Pattern-based hour ranges
+        pattern_hours_map = {
+            "evening": np.random.uniform(3, 5, self.n),  # Evening only
+            "morning_evening": np.random.uniform(5, 8, self.n),  # Morning + Evening
+            "most": np.random.uniform(8, 12, self.n),  # Most of day
+            "all": np.random.uniform(12, 18, self.n),  # Nearly 24/7
+        }
+        led_hours = np.zeros(self.n)
+        for pattern, hours_range in pattern_hours_map.items():
+            led_hours = np.where(
+                df["led_lights_usage_pattern"] == pattern, hours_range, led_hours
+            )
+
+        df["led_lights_real_effective_hours"] = led_hours
+        df["led_lights_real_efficiency_factor"] = 1.0
+
+        # CFL (50% penetration) - shares same pattern logic
+        df["has_cfl_lights"] = (np.random.random(self.n) < 0.50).astype(int)
+        df["cfl_lights_usage_pattern"] = np.where(
+            df["has_cfl_lights"],
+            df["led_lights_usage_pattern"],  # Same pattern as LED
+            "unknown",
+        )
+        df["cfl_lights_real_effective_hours"] = np.where(
+            df["has_cfl_lights"], led_hours, 0
+        )
+        df["cfl_lights_real_efficiency_factor"] = 1.0
+
+        # Tube (60% penetration) - shares same pattern logic
+        df["has_tube_lights"] = (np.random.random(self.n) < 0.60).astype(int)
+        df["tube_lights_usage_pattern"] = np.where(
+            df["has_tube_lights"],
+            df["led_lights_usage_pattern"],  # Same pattern as LED
+            "unknown",
+        )
+        df["tube_lights_real_effective_hours"] = np.where(
+            df["has_tube_lights"], led_hours, 0
+        )
+        df["tube_lights_real_efficiency_factor"] = 1.0
+
+        df["led_lights_kwh"] = (
+            9 * df["led_lights_real_effective_hours"] * 5 * 30
+        ) / 1000  # 5 LEDs avg
+        df["cfl_lights_kwh"] = (
+            18 * df["cfl_lights_real_effective_hours"] * 2 * 30
+        ) / 1000
+        df["tube_lights_kwh"] = (
+            40 * df["tube_lights_real_effective_hours"] * 2 * 30
+        ) / 1000
+        return df
+
+    def generate(self):
+        df = self.generate_demographics()
+        df = self.generate_ac_data(df)
+        df = self.generate_fridge_data(df)
+        df = self.generate_fan_data(df)
+        df = self.generate_tv_data(df)
+        df = self.generate_wm_data(df)
+        df = self.generate_pump_data(df)
+        df = self.generate_geyser_data(df)
+        df = self.generate_misc_data(df)
+        df = self.generate_kitchen_others(df)
+        df = self.generate_personal_others(df)
+        df = self.generate_lights_data(df)
+
+        # Sum Total Predictor
+        items = [
+            "ac_kwh",
+            "fridge_kwh",
+            "ceiling_fan_kwh",
+            "television_kwh",
+            "washing_machine_kwh",
+            "water_pump_kwh",
+            "water_heater_kwh",
+            "iron_kwh",
+            "kettle_kwh",
+            "induction_kwh",
+            "desktop_kwh",
+            "microwave_kwh",
+            "mixer_kwh",
+            "rice_cooker_kwh",
+            "toaster_kwh",
+            "food_processor_kwh",
+            "laptop_kwh",
+            "hair_dryer_kwh",
+            "vacuum_kwh",
+            "led_lights_kwh",
+            "cfl_lights_kwh",
+            "tube_lights_kwh",
+        ]
+        df["total_kwh_monthly"] = df[items].sum(axis=1) + np.random.normal(5, 2, self.n)
+
+        return df
+
+
+if __name__ == "__main__":
+    sim = KeralaRealWorldSimulator()
+    df = sim.generate()
+    df.to_csv("kerala_smartwatt_ai.csv", index=False)
+    print("✅  Dataset Generated: kerala_smartwatt_ai.csv")

Training_Scripts/train(latest).py

@@ -0,0 +1,644 @@
+"""
+Training Demo Script with Visualization
+This is the "Teacher" with built-in graph generation.
+It trains the AI and automatically generates training accuracy/loss graphs.
+"""
+
+import os
+
+import joblib
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+from sklearn.compose import ColumnTransformer
+from sklearn.model_selection import train_test_split
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+from tensorflow import keras
+from tensorflow.keras import layers
+from tensorflow.keras.callbacks import EarlyStopping
+
+# Ensure Model Directory Exists
+if not os.path.exists("models"):
+    os.makedirs("models")
+if not os.path.exists("training_graphs"):
+    os.makedirs("training_graphs")
+
+
+def load_data():
+    if not os.path.exists("kerala_smartwatt_ai.csv"):
+        print("❌ Dataset not found! Run newdataset.py first.")
+        return None
+    return pd.read_csv("kerala_smartwatt_ai.csv")
+
+
+def build_multi_output_model(input_dim):
+    """
+    This is the Brain Architecture.
+    Shared layers → Split heads for Efficiency and Hours
+    """
+    inputs = keras.Input(shape=(input_dim,))
+
+    # Shared Representation
+    x = layers.Dense(128, activation="relu")(inputs)
+    x = layers.Dropout(0.2)(x)
+    x = layers.Dense(64, activation="relu")(x)
+
+    # --- HEAD 1: EFFICIENCY FACTOR ---
+    eff_branch = layers.Dense(32, activation="relu")(x)
+    eff_output = layers.Dense(1, name="efficiency")(eff_branch)
+
+    # --- HEAD 2: EFFECTIVE HOURS ---
+    hours_branch = layers.Dense(32, activation="relu")(x)
+    hours_output = layers.Dense(1, name="hours")(hours_branch)
+
+    model = keras.Model(inputs=inputs, outputs=[eff_output, hours_output])
+
+    model.compile(
+        optimizer="adam",
+        loss={"efficiency": "mse", "hours": "mse"},
+        loss_weights={"efficiency": 10.0, "hours": 1.0},
+        metrics={"efficiency": "mae", "hours": "mae"},
+    )
+    return model
+
+
+# Store all training results and histories for final graphs
+all_results = []
+all_histories = []
+
+
+def plot_averaged_training_curves():
+    """
+    Generate Figure 2.1.2: Averaged Training Curves Across All 22 Models
+
+    Shows training/validation loss and MAE over epochs (averaged across all models).
+    This demonstrates overall model convergence - exactly what Figure 2.1.2 needs.
+    """
+    if not all_histories:
+        print("⚠️ No training histories to plot")
+        return
+
+    # Find minimum epoch count (models stopped at different epochs due to EarlyStopping)
+    min_epochs = min(len(h.history["loss"]) for h in all_histories)
+    print(
+        f"\n   ℹ️ Averaging across {len(all_histories)} models up to {min_epochs} epochs (shortest training)"
+    )
+
+    # Average training metrics across all models (truncate to min_epochs)
+    avg_loss = np.mean([h.history["loss"][:min_epochs] for h in all_histories], axis=0)
+    avg_val_loss = np.mean(
+        [h.history["val_loss"][:min_epochs] for h in all_histories], axis=0
+    )
+    avg_mae = np.mean(
+        [h.history["efficiency_mae"][:min_epochs] for h in all_histories], axis=0
+    )
+    avg_val_mae = np.mean(
+        [h.history["val_efficiency_mae"][:min_epochs] for h in all_histories], axis=0
+    )
+
+    epochs = range(1, len(avg_loss) + 1)
+
+    # Calculate statistics
+    initial_loss = avg_loss[0]
+    final_loss = avg_loss[-1]
+    final_mae = avg_mae[-1]
+    loss_reduction = (initial_loss - final_loss) / initial_loss * 100
+
+    # Create Figure 2.1.2
+    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
+    fig.suptitle(
+        "Figure 2.1.2: Neural Network Training Performance (Averaged Across 22 Models)",
+        fontsize=14,
+        fontweight="bold",
+        y=0.98,
+    )
+
+    # LEFT: Loss Curves
+    axes[0].plot(
+        epochs,
+        avg_loss,
+        label="Training Loss",
+        linewidth=2.5,
+        color="#3b82f6",
+        marker="o",
+        markersize=3,
+    )
+    axes[0].plot(
+        epochs,
+        avg_val_loss,
+        label="Validation Loss",
+        linewidth=2.5,
+        color="#f59e0b",
+        marker="s",
+        markersize=3,
+    )
+    axes[0].set_title("Training & Validation Loss", fontsize=12, fontweight="bold")
+    axes[0].set_xlabel("Epoch", fontsize=11)
+    axes[0].set_ylabel("Loss (MSE)", fontsize=11)
+    axes[0].legend(fontsize=10)
+    axes[0].grid(True, alpha=0.3, linestyle="--")
+
+    # RIGHT: Accuracy Curves (MAE)
+    axes[1].plot(
+        epochs,
+        avg_mae,
+        label="Training MAE",
+        linewidth=2.5,
+        color="#10b981",
+        marker="o",
+        markersize=3,
+    )
+    axes[1].plot(
+        epochs,
+        avg_val_mae,
+        label="Validation MAE",
+        linewidth=2.5,
+        color="#ef4444",
+        marker="s",
+        markersize=3,
+    )
+    axes[1].set_title("Prediction Accuracy (MAE)", fontsize=12, fontweight="bold")
+    axes[1].set_xlabel("Epoch", fontsize=11)
+    axes[1].set_ylabel("Mean Absolute Error", fontsize=11)
+    axes[1].legend(fontsize=10)
+    axes[1].grid(True, alpha=0.3, linestyle="--")
+
+    plt.tight_layout()
+
+    # Save as Figure 2.1.2
+    graph_path = "training_graphs/figure_2.1.2_training_curves.png"
+    plt.savefig(graph_path, dpi=300, bbox_inches="tight", facecolor="white")
+    plt.close()
+
+    # Print comprehensive statistics
+    print("\n" + "=" * 70)
+    print("📊 FIGURE 2.1.2 - TRAINING STATISTICS (Averaged Across 22 Models)")
+    print("=" * 70)
+    print(f"\n🔄 LOSS (MSE):")
+    print(f"   • Initial Training Loss (Epoch 1):      {initial_loss:.4f}")
+    print(f"   • Final Training Loss (Epoch {len(epochs)}):       {final_loss:.4f}")
+    print(
+        f"   • Final Validation Loss (Epoch {len(epochs)}):     {avg_val_loss[-1]:.4f}"
+    )
+    print(f"   • Loss Reduction:                        {loss_reduction:.1f}%")
+
+    print(f"\n✅ ACCURACY (MAE - Lower is Better):")
+    print(f"   • Final Training MAE:                    {final_mae:.4f}")
+    print(f"   • Final Validation MAE:                  {avg_val_mae[-1]:.4f}")
+    print(
+        f"   • Train-Val Gap:                         {abs(final_mae - avg_val_mae[-1]):.4f}"
+    )
+
+    if abs(final_mae - avg_val_mae[-1]) < 0.02:
+        print(f"   • Overfitting Status:                    ✅ No overfitting detected")
+    else:
+        print(f"   • Overfitting Status:                    ⚠️ Minor gap present")
+
+    print(f"\n📈 CONVERGENCE:")
+    print(f"   • Average Epochs Trained:                {len(epochs)}")
+    print(f"   • Total Models:                          {len(all_histories)}")
+    print(f"   • Models Used EarlyStopping:             Yes (Patience=10)")
+    print("=" * 70)
+
+    print(f"\n✅ FIGURE 2.1.2 SAVED: {graph_path}")
+    print("   📊 Left Panel: Training & Validation Loss over Epochs")
+    print("   📊 Right Panel: MAE Accuracy over Epochs")
+    print("   📊 Graph shows model convergence and learning effectiveness\n")
+
+
+def plot_comprehensive_comparison_graphs():
+    """
+    Generate TWO professional graphs for academic report:
+    Graph 1: Bar Chart - MAE Efficiency across all models
+    Graph 2: Dual-Line Chart - Efficiency vs Hours MAE comparison
+    """
+    if not all_results:
+        print("⚠️ No training results to plot")
+        return
+
+    appliances = [r["appliance"] for r in all_results]
+    mae_eff = [r["mae_efficiency"] for r in all_results]
+    mae_hours = [r["mae_hours"] for r in all_results]
+
+    # Create figure with 2 subplots
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6), dpi=300)
+    fig.suptitle(
+        "SmartWatt AI: Model Performance Comparison Across All 22 Appliances",
+        fontsize=16,
+        fontweight="bold",
+        y=0.98,
+    )
+
+    # GRAPH 1: Bar Chart - MAE Efficiency
+    colors = plt.cm.viridis([i / len(appliances) for i in range(len(appliances))])
+    bars = ax1.bar(
+        range(len(appliances)), mae_eff, color=colors, edgecolor="black", linewidth=0.5
+    )
+    ax1.set_xticks(range(len(appliances)))
+    ax1.set_xticklabels(
+        [a.replace("_", " ").title() for a in appliances],
+        rotation=90,
+        ha="right",
+        fontsize=8,
+    )
+    ax1.set_ylabel("MAE (Efficiency Factor)", fontsize=11, fontweight="bold")
+    ax1.set_title(
+        "Efficiency Prediction Error by Appliance",
+        fontsize=13,
+        fontweight="bold",
+        pad=10,
+    )
+    ax1.grid(True, alpha=0.3, axis="y")
+    ax1.set_ylim(0, max(mae_eff) * 1.15)
+
+    # Add value labels on bars
+    for i, (bar, val) in enumerate(zip(bars, mae_eff)):
+        height = bar.get_height()
+        ax1.text(
+            bar.get_x() + bar.get_width() / 2.0,
+            height,
+            f"{val:.3f}",
+            ha="center",
+            va="bottom",
+            fontsize=6,
+            rotation=0,
+        )
+
+    # GRAPH 2: Dual-Line Chart - Efficiency vs Hours MAE
+    x_pos = range(len(appliances))
+    line1 = ax2.plot(
+        x_pos,
+        mae_eff,
+        marker="o",
+        markersize=6,
+        linewidth=2,
+        label="Efficiency MAE",
+        color="#2E7D32",
+    )
+    line2 = ax2.plot(
+        x_pos,
+        mae_hours,
+        marker="s",
+        markersize=6,
+        linewidth=2,
+        label="Hours MAE",
+        color="#F57C00",
+    )
+
+    ax2.set_xticks(x_pos)
+    ax2.set_xticklabels(
+        [a.replace("_", " ").title() for a in appliances],
+        rotation=90,
+        ha="right",
+        fontsize=8,
+    )
+    ax2.set_ylabel("MAE", fontsize=11, fontweight="bold")
+    ax2.set_title(
+        "Efficiency vs Hours Prediction Error Comparison",
+        fontsize=13,
+        fontweight="bold",
+        pad=10,
+    )
+    ax2.legend(loc="upper left", fontsize=10, framealpha=0.9)
+    ax2.grid(True, alpha=0.3)
+    ax2.set_ylim(0, max(max(mae_eff), max(mae_hours)) * 1.15)
+
+    # Add average performance line
+    avg_eff = sum(mae_eff) / len(mae_eff)
+    avg_hours = sum(mae_hours) / len(mae_hours)
+    ax2.axhline(
+        y=avg_eff,
+        color="#2E7D32",
+        linestyle="--",
+        alpha=0.5,
+        linewidth=1.5,
+        label=f"Avg Efficiency MAE: {avg_eff:.3f}",
+    )
+    ax2.axhline(
+        y=avg_hours,
+        color="#F57C00",
+        linestyle="--",
+        alpha=0.5,
+        linewidth=1.5,
+        label=f"Avg Hours MAE: {avg_hours:.2f}",
+    )
+    ax2.legend(loc="upper left", fontsize=9, framealpha=0.9)
+
+    plt.tight_layout()
+
+    # Save graph
+    graph_path = "training_graphs/model_performance_comparison.png"
+    plt.savefig(graph_path, dpi=300, bbox_inches="tight", facecolor="white")
+    print(f"\n✅ COMPREHENSIVE COMPARISON GRAPHS SAVED: {graph_path}")
+    print(f"   📊 Graph 1: MAE Efficiency Bar Chart (All 22 Models)")
+    print(f"   📊 Graph 2: Efficiency vs Hours Dual-Line Comparison")
+    print(f"   📈 Average Efficiency MAE: {avg_eff:.4f}")
+    print(f"   📈 Average Hours MAE: {avg_hours:.2f}")
+    plt.close()
+
+
+def train_appliance_model(df, app_name, target_cols, features):
+    print(f"\n🎓 Training Model for: {app_name.upper()}")
+
+    # Filter for owners
+    if f"has_{app_name}" in df.columns:
+        df_app = df[df[f"has_{app_name}"] == 1].copy()
+    elif app_name == "fridge":
+        df_app = df[df["has_refrigerator"] == 1].copy()
+    elif app_name == "desktop":
+        df_app = df[df["has_computer"] == 1].copy()
+    elif app_name == "kettle":
+        df_app = df[df["has_electric_kettle"] == 1].copy()
+    elif app_name in [
+        "microwave",
+        "mixer",
+        "rice_cooker",
+        "toaster",
+        "food_processor",
+        "laptop",
+        "hair_dryer",
+        "vacuum",
+    ]:
+        df_app = df[df[f"has_{app_name}"] == 1].copy()
+    elif app_name in ["led_lights", "cfl_lights", "tube_lights"]:
+        df_app = df[df[f"has_{app_name}"] == 1].copy()
+    else:
+        df_app = df.copy()
+
+    if len(df_app) < 100:
+        print(f"⚠️ Not enough data for {app_name} (n={len(df_app)})")
+        return
+
+    # Prepare targets
+    y_eff = df_app[f"{app_name}_real_efficiency_factor"]
+    y_hours = df_app[f"{app_name}_real_effective_hours"]
+
+    # Preprocessing
+    numeric_features = [f for f in features if df_app[f].dtype in ["int64", "float64"]]
+    categorical_features = [f for f in features if df_app[f].dtype == "object"]
+
+    preprocessor = ColumnTransformer(
+        transformers=[
+            ("num", StandardScaler(), numeric_features),
+            ("cat", OneHotEncoder(handle_unknown="ignore"), categorical_features),
+        ]
+    )
+
+    X = preprocessor.fit_transform(df_app[features])
+
+    # Split
+    X_train, X_test, y_eff_train, y_eff_test, y_hours_train, y_hours_test = (
+        train_test_split(X, y_eff, y_hours, test_size=0.2, random_state=42)
+    )
+
+    # Build & Train
+    model = build_multi_output_model(X.shape[1])
+
+    # Define Early Stopping
+    early_stopping = EarlyStopping(
+        monitor="val_loss", patience=10, restore_best_weights=True, verbose=1
+    )
+
+    print(f"   Training on {len(X_train)} samples with EarlyStopping (Patience=10)...")
+    history = model.fit(
+        X_train,
+        {"efficiency": y_eff_train, "hours": y_hours_train},
+        validation_data=(X_test, {"efficiency": y_eff_test, "hours": y_hours_test}),
+        epochs=120,  # Increased from 30 to allow full convergence
+        batch_size=32,
+        callbacks=[early_stopping],
+        verbose=1,  # Show progress
+    )
+
+    # Evaluate
+    results = model.evaluate(
+        X_test, {"efficiency": y_eff_test, "hours": y_hours_test}, verbose=0
+    )
+    print(
+        f"   ✅ Trained. MAE Efficiency: {results[3]:.4f}, MAE Hours: {results[4]:.2f}"
+    )
+
+    # Save Artifacts
+    model.save(f"models/{app_name}_model.keras")
+    joblib.dump(preprocessor, f"models/{app_name}_preprocessor.pkl")
+    print(f"   💾 Saved to models/{app_name}_model.keras")
+
+    # Store history for averaged training curves (Figure 2.1.2)
+    all_histories.append(history)
+
+    # Return results for comparison graph
+    return {
+        "appliance": app_name,
+        "mae_efficiency": results[3],
+        "mae_hours": results[4],
+    }
+
+
+def run_training():
+    df = load_data()
+    if df is None:
+        return
+
+    # Train just AC model as demo (you can add more appliances)
+    print("\n" + "=" * 60)
+    print(" SMARTWATT AI TRAINING DEMO WITH VISUALIZATION")
+    print("=" * 60)
+
+    # Train all 22 appliance models
+    tasks = [
+        (
+            "ac",
+            "ac",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "ac_tonnage",
+                "ac_star_rating",
+                "ac_type",
+                "ac_age_years",
+                "ac_usage_pattern",
+            ],
+        ),
+        (
+            "fridge",
+            "fridge",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "fridge_capacity",
+                "fridge_age",
+                "fridge_star_rating",
+                "fridge_type",
+                "refrigerator_usage_pattern",
+            ],
+        ),
+        (
+            "ceiling_fan",
+            "ceiling_fan",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "fan_type",
+                "num_fans",
+                "fan_usage_pattern",
+            ],
+        ),
+        (
+            "television",
+            "television",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "television_type",
+                "tv_size",
+                "television_usage_pattern",
+            ],
+        ),
+        (
+            "washing_machine",
+            "washing_machine",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "wm_type",
+                "wm_capacity",
+                "wm_star_rating",
+                "wm_cycles_per_week",
+            ],
+        ),
+        (
+            "water_pump",
+            "water_pump",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "water_pump_hp",
+                "pump_usage_pattern",
+            ],
+        ),
+        (
+            "water_heater",
+            "water_heater",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "water_heater_type",
+                "water_heater_capacity",
+                "geyser_usage_pattern",
+            ],
+        ),
+        (
+            "iron",
+            "iron",
+            ["n_occupants", "season", "location_type", "iron_usage_pattern"],
+        ),
+        (
+            "kettle",
+            "kettle",
+            ["n_occupants", "season", "location_type", "kettle_usage_pattern"],
+        ),
+        (
+            "induction",
+            "induction",
+            ["n_occupants", "season", "location_type", "induction_usage_pattern"],
+        ),
+        (
+            "desktop",
+            "desktop",
+            ["n_occupants", "season", "location_type", "desktop_usage_pattern"],
+        ),
+        (
+            "microwave",
+            "microwave",
+            ["n_occupants", "season", "location_type", "microwave_usage_pattern"],
+        ),
+        (
+            "mixer",
+            "mixer",
+            ["n_occupants", "season", "location_type", "mixer_usage_pattern"],
+        ),
+        (
+            "rice_cooker",
+            "rice_cooker",
+            ["n_occupants", "season", "location_type", "rice_cooker_usage_pattern"],
+        ),
+        (
+            "toaster",
+            "toaster",
+            ["n_occupants", "season", "location_type", "toaster_usage_pattern"],
+        ),
+        (
+            "food_processor",
+            "food_processor",
+            ["n_occupants", "season", "location_type", "food_processor_usage_pattern"],
+        ),
+        (
+            "laptop",
+            "laptop",
+            ["n_occupants", "season", "location_type", "laptop_usage_pattern"],
+        ),
+        (
+            "hair_dryer",
+            "hair_dryer",
+            ["n_occupants", "season", "location_type", "hair_dryer_usage_pattern"],
+        ),
+        (
+            "vacuum",
+            "vacuum",
+            ["n_occupants", "season", "location_type", "vacuum_usage_pattern"],
+        ),
+        (
+            "led_lights",
+            "led_lights",
+            ["n_occupants", "season", "location_type", "led_lights_usage_pattern"],
+        ),
+        (
+            "cfl_lights",
+            "cfl_lights",
+            ["n_occupants", "season", "location_type", "cfl_lights_usage_pattern"],
+        ),
+        (
+            "tube_lights",
+            "tube_lights",
+            ["n_occupants", "season", "location_type", "tube_lights_usage_pattern"],
+        ),
+    ]
+
+    for name, prefix, feats in tasks:
+        result = train_appliance_model(
+            df,
+            name,
+            target_cols=[
+                f"{prefix}_real_efficiency_factor",
+                f"{prefix}_real_effective_hours",
+            ],
+            features=feats,
+        )
+        if result:
+            all_results.append(result)
+
+    # Generate Figure 2.1.2: Averaged training curves over epochs
+    plot_averaged_training_curves()
+
+    # Generate comprehensive comparison graphs (bonus analysis)
+    plot_comprehensive_comparison_graphs()
+
+    print("\n" + "=" * 60)
+    print("✅ TRAINING COMPLETE!")
+    print(f"📊 Trained {len(all_results)} models successfully")
+    print("📊 Figure 2.1.2: training_graphs/figure_2.1.2_training_curves.png")
+    print("📊 Comparison: training_graphs/model_performance_comparison.png")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    run_training()

Training_Scripts/train(old).py

@@ -0,0 +1,348 @@
+"""
+This is the "Teacher".
+It takes our fake simulated student data (from newdataset.py) and teaches the AI.
+Instead of teaching it to just output one number (Bill), we teach it to understand TWO things:
+1. How efficient is the appliance? (Is it old/rusty?)
+2. How long is it really used? (Is the user fibbing about usage?)
+"""
+
+import os
+
+import joblib
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+from sklearn.compose import ColumnTransformer
+from sklearn.model_selection import train_test_split
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+from tensorflow import keras
+from tensorflow.keras import layers
+
+# Ensure  Model Directory Exists
+if not os.path.exists("models"):
+    os.makedirs("models")
+
+
+def load_data():
+    if not os.path.exists("kerala_smartwatt_ai.csv"):
+        print("❌ Dataset not found! Run newdataset.py first.")
+        return None
+    return pd.read_csv("kerala_smartwatt_ai.csv")
+
+
+def build_multi_output_model(input_dim):
+    """
+    This is the Brain Architecture.
+    Imagine a student sharing a brain (Shared Layers) but having two mouths (Split Heads).
+
+    - The Shared Brain learns general concepts (e.g., "Big families use more power").
+    - Head 1 (Efficiency) specializes in judging the health of the machine.
+    - Head 2 (Hours) specializes in judging the behavior of the humans.
+    """
+    inputs = keras.Input(shape=(input_dim,))
+
+    # Shared Representation
+    x = layers.Dense(128, activation="relu")(inputs)
+    x = layers.Dropout(0.2)(x)
+    x = layers.Dense(64, activation="relu")(x)
+
+    # --- HEAD 1: EFFICIENCY FACTOR ---
+    # Target: 0.6 to 1.1 (Ratio)
+    eff_branch = layers.Dense(32, activation="relu")(x)
+    eff_output = layers.Dense(1, name="efficiency")(eff_branch)
+
+    # --- HEAD 2: EFFECTIVE HOURS ---
+    # Target: 0 to 24 (Hours)
+    hours_branch = layers.Dense(32, activation="relu")(x)
+    hours_output = layers.Dense(1, name="hours")(hours_branch)
+
+    model = keras.Model(inputs=inputs, outputs=[eff_output, hours_output])
+
+    model.compile(
+        optimizer="adam",
+        loss={"efficiency": "mse", "hours": "mse"},
+        # Why weights?
+        # Efficiency is a small number (0.6 - 1.1). Hours is a big number (0 - 24).
+        # We shout louder about Efficiency (weight=10) so the AI pays attention to small changes.
+        loss_weights={"efficiency": 10.0, "hours": 1.0},
+        metrics={"efficiency": "mae", "hours": "mae"},
+    )
+    return model
+
+
+def train_appliance_model(df, app_name, target_cols, features):
+    print(f"\n Training  Model for: {app_name.upper()}")
+
+    # Filter for owners
+    if f"has_{app_name}" in df.columns:
+        df_app = df[df[f"has_{app_name}"] == 1].copy()
+    elif app_name == "fridge":
+        df_app = df[df["has_refrigerator"] == 1].copy()
+    elif app_name == "desktop":
+        df_app = df[df["has_computer"] == 1].copy()
+    elif app_name == "kettle":
+        df_app = df[df["has_electric_kettle"] == 1].copy()
+    elif app_name in [
+        "microwave",
+        "mixer",
+        "rice_cooker",
+        "toaster",
+        "food_processor",
+        "laptop",
+        "hair_dryer",
+        "vacuum",
+    ]:
+        df_app = df[df[f"has_{app_name}"] == 1].copy()
+    elif app_name in ["led_lights", "cfl_lights", "tube_lights"]:
+        df_app = df[df[f"has_{app_name}"] == 1].copy()
+    else:
+        df_app = df.copy()  # Fallback
+
+    if len(df_app) < 100:
+        print(f"⚠️ Not enough data for {app_name} (n={len(df_app)})")
+        return
+
+    # Prepare specific targets
+    # Expecting cols like 'ac_real_efficiency_factor', 'ac_real_effective_hours'
+    y_eff = df_app[f"{app_name}_real_efficiency_factor"]
+    y_hours = df_app[f"{app_name}_real_effective_hours"]
+
+    # Preprocessing
+    # Separate numeric and categorical
+    numeric_features = [f for f in features if df_app[f].dtype in ["int64", "float64"]]
+    categorical_features = [f for f in features if df_app[f].dtype == "object"]
+
+    preprocessor = ColumnTransformer(
+        transformers=[
+            ("num", StandardScaler(), numeric_features),
+            ("cat", OneHotEncoder(handle_unknown="ignore"), categorical_features),
+        ]
+    )
+
+    X = preprocessor.fit_transform(df_app[features])
+
+    # Split
+    X_train, X_test, y_eff_train, y_eff_test, y_hours_train, y_hours_test = (
+        train_test_split(X, y_eff, y_hours, test_size=0.2, random_state=42)
+    )
+
+    # Build & Train
+    model = build_multi_output_model(X.shape[1])
+
+    history = model.fit(
+        X_train,
+        {"efficiency": y_eff_train, "hours": y_hours_train},
+        validation_data=(X_test, {"efficiency": y_eff_test, "hours": y_hours_test}),
+        epochs=30,  # Quick train for demo
+        batch_size=32,
+        verbose=0,
+    )
+
+    # Evaluate
+    results = model.evaluate(
+        X_test, {"efficiency": y_eff_test, "hours": y_hours_test}, verbose=0
+    )
+    print(
+        f"   ✅ Trained. MAE Efficiency: {results[3]:.4f}, MAE Hours: {results[4]:.2f}"
+    )
+
+    # Save Artifacts
+    model.save(f"models/{app_name}_model.keras")
+    joblib.dump(preprocessor, f"models/{app_name}_preprocessor.pkl")
+    print(f"   💾 Saved to models/{app_name}_model.keras")
+
+
+def run_training():
+    df = load_data()
+    if df is None:
+        return
+
+    # List of models to train
+    # Format: (name, target_prefix, features)
+    # Updated to match UI fields exactly - ALL UI FIELDS USED (except hours/total_units)
+    # All appliances now include usage patterns for AI-driven personalization
+    tasks = [
+        # MAJOR APPLIANCES - Use all UI collected fields + patterns
+        (
+            "ac",
+            "ac",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "ac_tonnage",
+                "ac_star_rating",
+                "ac_type",
+                "ac_age_years",
+                "ac_usage_pattern",
+            ],
+        ),
+        (
+            "fridge",
+            "fridge",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "fridge_capacity",
+                "fridge_age",
+                "fridge_star_rating",
+                "fridge_type",
+                "refrigerator_usage_pattern",
+            ],
+        ),
+        (
+            "ceiling_fan",
+            "ceiling_fan",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "fan_type",
+                "num_fans",
+                "fan_usage_pattern",
+            ],
+        ),
+        (
+            "television",
+            "television",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "television_type",
+                "tv_size",
+                "television_usage_pattern",
+            ],
+        ),
+        (
+            "washing_machine",
+            "washing_machine",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "wm_type",
+                "wm_capacity",
+                "wm_star_rating",
+                "wm_cycles_per_week",
+            ],
+        ),
+        (
+            "water_pump",
+            "water_pump",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "water_pump_hp",
+                "pump_usage_pattern",
+            ],
+        ),
+        (
+            "water_heater",
+            "water_heater",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "water_heater_type",
+                "water_heater_capacity",
+                "geyser_usage_pattern",
+            ],
+        ),
+        # MISC APPLIANCES - Include base fields for context + patterns
+        (
+            "iron",
+            "iron",
+            ["n_occupants", "season", "location_type", "iron_usage_pattern"],
+        ),
+        (
+            "kettle",
+            "kettle",
+            ["n_occupants", "season", "location_type", "kettle_usage_pattern"],
+        ),
+        (
+            "induction",
+            "induction",
+            ["n_occupants", "season", "location_type", "induction_usage_pattern"],
+        ),
+        (
+            "desktop",
+            "desktop",
+            ["n_occupants", "season", "location_type", "desktop_usage_pattern"],
+        ),
+        (
+            "microwave",
+            "microwave",
+            ["n_occupants", "season", "location_type", "microwave_usage_pattern"],
+        ),
+        (
+            "mixer",
+            "mixer",
+            ["n_occupants", "season", "location_type", "mixer_usage_pattern"],
+        ),
+        (
+            "rice_cooker",
+            "rice_cooker",
+            ["n_occupants", "season", "location_type", "rice_cooker_usage_pattern"],
+        ),
+        (
+            "toaster",
+            "toaster",
+            ["n_occupants", "season", "location_type", "toaster_usage_pattern"],
+        ),
+        (
+            "food_processor",
+            "food_processor",
+            ["n_occupants", "season", "location_type", "food_processor_usage_pattern"],
+        ),
+        (
+            "laptop",
+            "laptop",
+            ["n_occupants", "season", "location_type", "laptop_usage_pattern"],
+        ),
+        (
+            "hair_dryer",
+            "hair_dryer",
+            ["n_occupants", "season", "location_type", "hair_dryer_usage_pattern"],
+        ),
+        (
+            "vacuum",
+            "vacuum",
+            ["n_occupants", "season", "location_type", "vacuum_usage_pattern"],
+        ),
+        (
+            "led_lights",
+            "led_lights",
+            ["n_occupants", "season", "location_type", "led_lights_usage_pattern"],
+        ),
+        (
+            "cfl_lights",
+            "cfl_lights",
+            ["n_occupants", "season", "location_type", "cfl_lights_usage_pattern"],
+        ),
+        (
+            "tube_lights",
+            "tube_lights",
+            ["n_occupants", "season", "location_type", "tube_lights_usage_pattern"],
+        ),
+    ]
+
+    for name, prefix, feats in tasks:
+        train_appliance_model(
+            df,
+            name,
+            target_cols=[
+                f"{prefix}_real_efficiency_factor",
+                f"{prefix}_real_effective_hours",
+            ],
+            features=feats,
+        )
+
+    print("\n✅  Training Complete (7 Models)!")
+
+
+if __name__ == "__main__":
+    run_training()

Training_Scripts/train_demo.py

@@ -0,0 +1,470 @@
+"""
+This is the "Teacher" with Training Visualization.
+It takes our fake simulated student data (from newdataset.py) and teaches the AI.
+Instead of teaching it to just output one number (Bill), we teach it to understand TWO things:
+1. How efficient is the appliance? (Is it old/rusty?)
+2. How long is it really used? (Is the user fibbing about usage?)
+
+NEW: Generates training accuracy and loss graphs (Figure 2.1.2)
+"""
+
+import os
+
+import joblib
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+from sklearn.compose import ColumnTransformer
+from sklearn.model_selection import train_test_split
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+from tensorflow import keras
+from tensorflow.keras import layers
+
+# Ensure Model and Training Logs Directories Exist
+if not os.path.exists("models"):
+    os.makedirs("models")
+if not os.path.exists("training_logs"):
+    os.makedirs("training_logs")
+
+
+def load_data():
+    if not os.path.exists("kerala_smartwatt_ai.csv"):
+        print("❌ Dataset not found! Run newdataset.py first.")
+        return None
+    return pd.read_csv("kerala_smartwatt_ai.csv")
+
+
+def build_multi_output_model(input_dim):
+    """
+    This is the Brain Architecture.
+    Imagine a student sharing a brain (Shared Layers) but having two mouths (Split Heads).
+
+    - The Shared Brain learns general concepts (e.g., "Big families use more power").
+    - Head 1 (Efficiency) specializes in judging the health of the machine.
+    - Head 2 (Hours) specializes in judging the behavior of the humans.
+    """
+    inputs = keras.Input(shape=(input_dim,))
+
+    # Shared Representation
+    x = layers.Dense(128, activation="relu")(inputs)
+    x = layers.Dropout(0.2)(x)
+    x = layers.Dense(64, activation="relu")(x)
+
+    # --- HEAD 1: EFFICIENCY FACTOR ---
+    # Target: 0.6 to 1.1 (Ratio)
+    eff_branch = layers.Dense(32, activation="relu")(x)
+    eff_output = layers.Dense(1, name="efficiency")(eff_branch)
+
+    # --- HEAD 2: EFFECTIVE HOURS ---
+    # Target: 0 to 24 (Hours)
+    hours_branch = layers.Dense(32, activation="relu")(x)
+    hours_output = layers.Dense(1, name="hours")(hours_branch)
+
+    model = keras.Model(inputs=inputs, outputs=[eff_output, hours_output])
+
+    model.compile(
+        optimizer="adam",
+        loss={"efficiency": "mse", "hours": "mse"},
+        # Why weights?
+        # Efficiency is a small number (0.6 - 1.1). Hours is a big number (0 - 24).
+        # We shout louder about Efficiency (weight=10) so the AI pays attention to small changes.
+        loss_weights={"efficiency": 10.0, "hours": 1.0},
+        metrics={"efficiency": "mae", "hours": "mae"},
+    )
+    return model
+
+
+def plot_training_history(history, app_name):
+    """
+    Collect training history for final combined graph
+    """
+    # Store history for later aggregation
+    if not hasattr(plot_training_history, "all_histories"):
+        plot_training_history.all_histories = []
+    plot_training_history.all_histories.append((app_name, history))
+
+
+def save_combined_training_graph():
+    """
+    Generate Figure 2.1.2: Single Training Accuracy and Loss Graph
+
+    Creates two side-by-side plots showing average training performance:
+    - Left: Training & Validation Loss over epochs
+    - Right: Training & Validation MAE (accuracy) over epochs
+
+    This demonstrates overall model convergence across all appliances.
+    """
+    if not hasattr(plot_training_history, "all_histories"):
+        return
+
+    histories = plot_training_history.all_histories
+
+    # Average across all models
+    avg_loss = np.mean([h.history["loss"] for _, h in histories], axis=0)
+    avg_val_loss = np.mean([h.history["val_loss"] for _, h in histories], axis=0)
+    avg_mae = np.mean([h.history["efficiency_mae"] for _, h in histories], axis=0)
+    avg_val_mae = np.mean(
+        [h.history["val_efficiency_mae"] for _, h in histories], axis=0
+    )
+
+    # Calculate final epoch statistics
+    final_train_loss = avg_loss[-1]
+    final_val_loss = avg_val_loss[-1]
+    final_train_mae = avg_mae[-1]
+    final_val_mae = avg_val_mae[-1]
+    initial_loss = avg_loss[0]
+
+    # Print comprehensive statistics
+    print("\n" + "=" * 60)
+    print("📊 TRAINING STATISTICS (Averaged across 22 models)")
+    print("=" * 60)
+    print(f"\n🔄 LOSS (MSE):")
+    print(f"   • Initial Training Loss (Epoch 1):    {initial_loss:.4f}")
+    print(f"   • Final Training Loss (Epoch 30):     {final_train_loss:.4f}")
+    print(f"   • Final Validation Loss (Epoch 30):   {final_val_loss:.4f}")
+    print(
+        f"   • Loss Reduction:                      {((initial_loss - final_train_loss) / initial_loss * 100):.1f}%"
+    )
+
+    print(f"\n✅ ACCURACY (MAE - Lower is Better):")
+    print(f"   • Final Training MAE:                  {final_train_mae:.4f}")
+    print(f"   • Final Validation MAE:                {final_val_mae:.4f}")
+    print(
+        f"   • Train-Val Gap:                       {abs(final_train_mae - final_val_mae):.4f}"
+    )
+
+    if abs(final_train_mae - final_val_mae) < 0.02:
+        print(f"   • Overfitting Status:                  ✅ No overfitting detected")
+    else:
+        print(f"   • Overfitting Status:                  ⚠️ Minor gap present")
+
+    print(f"\n📈 CONVERGENCE:")
+    print(f"   • Epochs Trained:                      30")
+    print(f"   • Total Models:                        {len(histories)}")
+    print(f"   • Average Final Loss:                  {final_train_loss:.4f}")
+    print("=" * 60 + "\n")
+
+    # Generate graph
+    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
+
+    # Plot 1: Loss Curves
+    axes[0].plot(avg_loss, label="Training Loss", linewidth=2.5, color="#3b82f6")
+    axes[0].plot(avg_val_loss, label="Validation Loss", linewidth=2.5, color="#f59e0b")
+    axes[0].set_title("Neural Network Training Loss", fontsize=14, fontweight="bold")
+    axes[0].set_xlabel("Epoch", fontsize=12)
+    axes[0].set_ylabel("Loss (MSE)", fontsize=12)
+    axes[0].legend(fontsize=11)
+    axes[0].grid(True, alpha=0.3, linestyle="--")
+
+    # Plot 2: Accuracy Curves (MAE)
+    axes[1].plot(avg_mae, label="Training MAE", linewidth=2.5, color="#10b981")
+    axes[1].plot(avg_val_mae, label="Validation MAE", linewidth=2.5, color="#ef4444")
+    axes[1].set_title("Prediction Accuracy (MAE)", fontsize=14, fontweight="bold")
+    axes[1].set_xlabel("Epoch", fontsize=12)
+    axes[1].set_ylabel("Mean Absolute Error", fontsize=12)
+    axes[1].legend(fontsize=11)
+    axes[1].grid(True, alpha=0.3, linestyle="--")
+
+    plt.tight_layout()
+    plt.savefig(
+        "training_logs/training_graph_figure_2.1.2.png", dpi=300, bbox_inches="tight"
+    )
+    plt.close()
+
+    print(
+        f"📊 Combined training graph saved: training_logs/training_graph_figure_2.1.2.png"
+    )
+
+
+def train_appliance_model(df, app_name, target_cols, features):
+    print(f"\n🎓 Training Model for: {app_name.upper()}")
+
+    # Filter for owners
+    if f"has_{app_name}" in df.columns:
+        df_app = df[df[f"has_{app_name}"] == 1].copy()
+    elif app_name == "fridge":
+        df_app = df[df["has_refrigerator"] == 1].copy()
+    elif app_name == "desktop":
+        df_app = df[df["has_computer"] == 1].copy()
+    elif app_name == "kettle":
+        df_app = df[df["has_electric_kettle"] == 1].copy()
+    elif app_name in [
+        "microwave",
+        "mixer",
+        "rice_cooker",
+        "toaster",
+        "food_processor",
+        "laptop",
+        "hair_dryer",
+        "vacuum",
+    ]:
+        df_app = df[df[f"has_{app_name}"] == 1].copy()
+    elif app_name in ["led_lights", "cfl_lights", "tube_lights"]:
+        df_app = df[df[f"has_{app_name}"] == 1].copy()
+    else:
+        df_app = df.copy()  # Fallback
+
+    if len(df_app) < 100:
+        print(f"⚠️ Not enough data for {app_name} (n={len(df_app)})")
+        return
+
+    # Prepare specific targets
+    # Expecting cols like 'ac_real_efficiency_factor', 'ac_real_effective_hours'
+    y_eff = df_app[f"{app_name}_real_efficiency_factor"]
+    y_hours = df_app[f"{app_name}_real_effective_hours"]
+
+    # Preprocessing
+    # Separate numeric and categorical
+    numeric_features = [f for f in features if df_app[f].dtype in ["int64", "float64"]]
+    categorical_features = [f for f in features if df_app[f].dtype == "object"]
+
+    preprocessor = ColumnTransformer(
+        transformers=[
+            ("num", StandardScaler(), numeric_features),
+            ("cat", OneHotEncoder(handle_unknown="ignore"), categorical_features),
+        ]
+    )
+
+    X = preprocessor.fit_transform(df_app[features])
+
+    # Split
+    X_train, X_test, y_eff_train, y_eff_test, y_hours_train, y_hours_test = (
+        train_test_split(X, y_eff, y_hours, test_size=0.2, random_state=42)
+    )
+
+    # Build & Train
+    model = build_multi_output_model(X.shape[1])
+
+    print(f"   🔄 Training for 30 epochs...")
+    history = model.fit(
+        X_train,
+        {"efficiency": y_eff_train, "hours": y_hours_train},
+        validation_data=(X_test, {"efficiency": y_eff_test, "hours": y_hours_test}),
+        epochs=30,
+        batch_size=32,
+        verbose=0,  # Silent training
+    )
+
+    # Collect training history for combined graph
+    plot_training_history(history, app_name)
+
+    # Evaluate
+    results = model.evaluate(
+        X_test, {"efficiency": y_eff_test, "hours": y_hours_test}, verbose=0
+    )
+    print(
+        f"   ✅ Trained. MAE Efficiency: {results[3]:.4f}, MAE Hours: {results[4]:.2f}"
+    )
+
+    # Save Artifacts
+    model.save(f"models/{app_name}_model.keras")
+    joblib.dump(preprocessor, f"models/{app_name}_preprocessor.pkl")
+    print(f"   💾 Saved to models/{app_name}_model.keras")
+
+
+def run_training():
+    df = load_data()
+    if df is None:
+        return
+
+    print("\n" + "=" * 60)
+    print("🚀 SMARTWATT AI - TRAINING WITH VISUALIZATION")
+    print("=" * 60)
+
+    # List of models to train
+    # Format: (name, target_prefix, features)
+    tasks = [
+        # MAJOR APPLIANCES
+        (
+            "ac",
+            "ac",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "ac_tonnage",
+                "ac_star_rating",
+                "ac_type",
+                "ac_age_years",
+                "ac_usage_pattern",
+            ],
+        ),
+        (
+            "fridge",
+            "fridge",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "fridge_capacity",
+                "fridge_age",
+                "fridge_star_rating",
+                "fridge_type",
+                "refrigerator_usage_pattern",
+            ],
+        ),
+        (
+            "ceiling_fan",
+            "ceiling_fan",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "fan_type",
+                "num_fans",
+                "fan_usage_pattern",
+            ],
+        ),
+        (
+            "television",
+            "television",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "television_type",
+                "tv_size",
+                "television_usage_pattern",
+            ],
+        ),
+        (
+            "washing_machine",
+            "washing_machine",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "wm_type",
+                "wm_capacity",
+                "wm_star_rating",
+                "wm_cycles_per_week",
+            ],
+        ),
+        (
+            "water_pump",
+            "water_pump",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "water_pump_hp",
+                "pump_usage_pattern",
+            ],
+        ),
+        (
+            "water_heater",
+            "water_heater",
+            [
+                "n_occupants",
+                "season",
+                "location_type",
+                "water_heater_type",
+                "water_heater_capacity",
+                "geyser_usage_pattern",
+            ],
+        ),
+        # MISC APPLIANCES
+        (
+            "iron",
+            "iron",
+            ["n_occupants", "season", "location_type", "iron_usage_pattern"],
+        ),
+        (
+            "kettle",
+            "kettle",
+            ["n_occupants", "season", "location_type", "kettle_usage_pattern"],
+        ),
+        (
+            "induction",
+            "induction",
+            ["n_occupants", "season", "location_type", "induction_usage_pattern"],
+        ),
+        (
+            "desktop",
+            "desktop",
+            ["n_occupants", "season", "location_type", "desktop_usage_pattern"],
+        ),
+        (
+            "microwave",
+            "microwave",
+            ["n_occupants", "season", "location_type", "microwave_usage_pattern"],
+        ),
+        (
+            "mixer",
+            "mixer",
+            ["n_occupants", "season", "location_type", "mixer_usage_pattern"],
+        ),
+        (
+            "rice_cooker",
+            "rice_cooker",
+            ["n_occupants", "season", "location_type", "rice_cooker_usage_pattern"],
+        ),
+        (
+            "toaster",
+            "toaster",
+            ["n_occupants", "season", "location_type", "toaster_usage_pattern"],
+        ),
+        (
+            "food_processor",
+            "food_processor",
+            ["n_occupants", "season", "location_type", "food_processor_usage_pattern"],
+        ),
+        (
+            "laptop",
+            "laptop",
+            ["n_occupants", "season", "location_type", "laptop_usage_pattern"],
+        ),
+        (
+            "hair_dryer",
+            "hair_dryer",
+            ["n_occupants", "season", "location_type", "hair_dryer_usage_pattern"],
+        ),
+        (
+            "vacuum",
+            "vacuum",
+            ["n_occupants", "season", "location_type", "vacuum_usage_pattern"],
+        ),
+        (
+            "led_lights",
+            "led_lights",
+            ["n_occupants", "season", "location_type", "led_lights_usage_pattern"],
+        ),
+        (
+            "cfl_lights",
+            "cfl_lights",
+            ["n_occupants", "season", "location_type", "cfl_lights_usage_pattern"],
+        ),
+        (
+            "tube_lights",
+            "tube_lights",
+            ["n_occupants", "season", "location_type", "tube_lights_usage_pattern"],
+        ),
+    ]
+
+    for name, prefix, feats in tasks:
+        train_appliance_model(
+            df,
+            name,
+            target_cols=[
+                f"{prefix}_real_efficiency_factor",
+                f"{prefix}_real_effective_hours",
+            ],
+            features=feats,
+        )
+
+    # Generate single combined training graph (Figure 2.1.2)
+    save_combined_training_graph()
+
+    print("\n" + "=" * 60)
+    print("✅ Training Complete! All models saved.")
+    print(
+        f"📊 Training graph (Figure 2.1.2): training_logs/training_graph_figure_2.1.2.png"
+    )
+    print(f"🤖 Model files available in: models/")
+    print("=" * 60 + "\n")
+
+
+if __name__ == "__main__":
+    run_training()

Training_Scripts/train_with_logging.py

@@ -0,0 +1,164 @@
+"""
+Enhanced Training Script with History Logging
+Runs actual training and saves history for visualization
+"""
+
+import json
+import os
+
+import joblib
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+from sklearn.compose import ColumnTransformer
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+from tensorflow import keras
+from tensorflow.keras import layers
+
+# Ensure directories exist
+os.makedirs("models", exist_ok=True)
+os.makedirs("training_logs", exist_ok=True)
+
+
+def load_data():
+    if not os.path.exists("kerala_smartwatt_ai.csv"):
+        print("❌ Dataset not found! Run newdataset.py first.")
+        return None
+    return pd.read_csv("kerala_smartwatt_ai.csv")
+
+
+def build_multi_output_model(input_dim):
+    inputs = keras.Input(shape=(input_dim,))
+
+    # Shared layers
+    x = layers.Dense(128, activation="relu")(inputs)
+    x = layers.Dropout(0.2)(x)
+    x = layers.Dense(64, activation="relu")(x)
+
+    # Efficiency head
+    eff_branch = layers.Dense(32, activation="relu")(x)
+    eff_output = layers.Dense(1, name="efficiency")(eff_branch)
+
+    # Hours head
+    hours_branch = layers.Dense(32, activation="relu")(x)
+    hours_output = layers.Dense(1, name="hours")(hours_branch)
+
+    model = keras.Model(inputs=inputs, outputs=[eff_output, hours_output])
+
+    model.compile(
+        optimizer="adam",
+        loss={"efficiency": "mse", "hours": "mse"},
+        loss_weights={"efficiency": 10.0, "hours": 1.0},
+        metrics={"efficiency": "mae", "hours": "mae"},
+    )
+    return model
+
+
+def train_single_appliance_with_logging(df, app_name="ac"):
+    """Train a single appliance model and log the history"""
+    print(f"\n🚀 Training {app_name.upper()} model with full logging...")
+
+    # Filter data
+    if app_name == "ac":
+        df_app = df[df["has_ac"] == 1].copy()
+        features = [
+            "n_occupants",
+            "season",
+            "location_type",
+            "ac_tonnage",
+            "ac_star_rating",
+            "ac_type",
+            "ac_age_years",
+            "ac_usage_pattern",
+        ]
+    elif app_name == "fridge":
+        df_app = df[df["has_refrigerator"] == 1].copy()
+        features = [
+            "n_occupants",
+            "season",
+            "location_type",
+            "fridge_capacity",
+            "fridge_age",
+            "fridge_star_rating",
+            "fridge_type",
+            "refrigerator_usage_pattern",
+        ]
+    else:
+        print(f"❌ Appliance {app_name} not configured")
+        return None
+
+    print(f"   Dataset size: {len(df_app)} households")
+
+    # Prepare targets
+    y_eff = df_app[f"{app_name}_real_efficiency_factor"]
+    y_hours = df_app[f"{app_name}_real_effective_hours"]
+
+    # Preprocessing
+    numeric_features = [f for f in features if df_app[f].dtype in ["int64", "float64"]]
+    categorical_features = [f for f in features if df_app[f].dtype == "object"]
+
+    preprocessor = ColumnTransformer(
+        transformers=[
+            ("num", StandardScaler(), numeric_features),
+            ("cat", OneHotEncoder(handle_unknown="ignore"), categorical_features),
+        ]
+    )
+
+    X = preprocessor.fit_transform(df_app[features])
+
+    # Train/test split
+    X_train, X_test, y_eff_train, y_eff_test, y_hours_train, y_hours_test = (
+        train_test_split(X, y_eff, y_hours, test_size=0.2, random_state=42)
+    )
+
+    # Build model
+    model = build_multi_output_model(X.shape[1])
+
+    # Train with verbose output
+    print(f"   Training for 30 epochs...")
+    history = model.fit(
+        X_train,
+        {"efficiency": y_eff_train, "hours": y_hours_train},
+        validation_data=(X_test, {"efficiency": y_eff_test, "hours": y_hours_test}),
+        epochs=30,
+        batch_size=32,
+        verbose=1,
+    )
+
+    # Save history
+    history_dict = {
+        "loss": [float(x) for x in history.history["loss"]],
+        "efficiency_loss": [float(x) for x in history.history["efficiency_loss"]],
+        "hours_loss": [float(x) for x in history.history["hours_loss"]],
+        "val_loss": [float(x) for x in history.history["val_loss"]],
+        "val_efficiency_loss": [
+            float(x) for x in history.history["val_efficiency_loss"]
+        ],
+        "val_hours_loss": [float(x) for x in history.history["val_hours_loss"]],
+        "efficiency_mae": [float(x) for x in history.history["efficiency_mae"]],
+        "hours_mae": [float(x) for x in history.history["hours_mae"]],
+        "val_efficiency_mae": [float(x) for x in history.history["val_efficiency_mae"]],
+        "val_hours_mae": [float(x) for x in history.history["val_hours_mae"]],
+    }
+
+    # Save to file
+    with open(f"training_logs/{app_name}_training_history.json", "w") as f:
+        json.dump(history_dict, f, indent=2)
+
+    print(f"\n   ✅ Training complete!")
+    print(f"   📊 Final metrics:")
+    print(f"      Training Loss: {history_dict['loss'][-1]:.4f}")
+    print(f"      Validation Loss: {history_dict['val_loss'][-1]:.4f}")
+    print(f"      Efficiency MAE: {history_dict['val_efficiency_mae'][-1]:.4f}")
+    print(f"      Hours MAE: {history_dict['val_hours_mae'][-1]:.2f}")
+    print(f"   💾 History saved to training_logs/{app_name}_training_history.json")
+
+    return history_dict
+
+
+if __name__ == "__main__":
+    df = load_data()
+    if df is not None:
+        # Train AC model as representative example
+        history = train_single_appliance_with_logging(df, "ac")

anomaly_engine.py

@@ -0,0 +1,39 @@
+class AnomalyEngine:
+    """
+    Diagnoses Health (Efficiency) and Behavior (Usage) Anomalies.
+    """
+
+    @staticmethod
+    def check_anomalies(name, eff, hours):
+        status = "Normal"
+        msg = ""
+        type = "None"
+
+        # 1. USAGE ANOMALIES (Behavior)
+        usage_thresholds = {
+            "water_heater": (3.0, "Critical: Geyser running > 3h/day!"),
+            "water_pump": (2.0, "Warning: Pump running > 2h/day"),
+            "ac": (16.0, "Notice: High AC Usage (>16h)"),
+            "led_lights": (14.0, "Notice: Lights on > 14h"),
+            "iron": (1.0, "Warning: Iron Box usage high"),
+        }
+
+        if name in usage_thresholds:
+            thresh, warn_msg = usage_thresholds[name]
+            if hours > thresh:
+                status = "Usage_Anomaly"
+                msg = warn_msg
+                type = "Behavior"
+
+        # 2. EFFICIENCY ANOMALIES (Health Check)
+        # If a machine is consuming 25% more power than it should, it's sick.
+        if eff > 1.25:
+            status = "efficiency_critical"
+            msg = f"CRITICAL: {name} is consuming 25% more power than rated! Check for service."
+            type = "Health"
+        elif eff > 1.15 and status != "efficiency_critical":
+            status = "efficiency_warning"
+            msg = f"Warning: {name} efficiency is degrading (15% loss)."
+            type = "Health"
+
+        return {"status": status, "message": msg, "type": type}

kseb_tariff.py

@@ -0,0 +1,191 @@
+"""
+KSEB (Kerala State Electricity Board) Tariff Calculator
+========================================================
+This is the "Accountant" of the system.
+It strictly follows the 2024-2025 KSEB Rulebook.
+
+The Logic is "Telescopic":
+- Use a little? Pay a little per unit.
+- Use a lot? Pay A LOT per unit.
+- Crossing 250 units is dangerous—you lose the subsidy on EVERYTHING!
+"""
+
+
+def calculate_kseb_tariff(monthly_units: float) -> dict:
+    """
+    Calculate Kerala State Electricity Board (KSEB) charges for bi-monthly billing.
+
+    KSEB uses telescopic tariff structure where:
+    1. Bill is calculated bi-monthly (2 months at a time)
+    2. Units are divided by 2 to get monthly average
+    3. Telescopic rates apply up to 250 units/month
+    4. Flat rates apply above 250 units/month
+    5. Fuel Surcharge Mechanism (FSM) is added
+
+    Args:
+        monthly_units (float): Monthly electricity consumption in kWh (units)
+
+    Returns:
+        dict: {
+            'energy_charge': float,      # Base energy cost (bi-monthly)
+            'fuel_surcharge': float,     # FSM charges
+            'total': float,              # Total bi-monthly bill (actual KSEB charge)
+            'monthly_estimate': float,   # Approximate monthly cost (total/2)
+            'effective_rate': float,     # Per-unit cost
+            'slab': str,                 # Tariff category
+            'monthly_units': float,      # Input monthly units
+            'bi_monthly_units': float    # 2-month consumption
+        }
+
+    Example:
+        >>> result = calculate_kseb_tariff(150)
+        >>> print(f"Bi-monthly bill: ₹{result['total']:.2f}")
+        Bi-monthly bill: ₹1279.00
+        >>> print(f"Monthly estimate: ₹{result['monthly_estimate']:.2f}")
+        Monthly estimate: ₹639.50
+    """
+    import math
+
+    # Import Centralized Tariff Configuration
+    try:
+        from tariff_config import FLAT_RATE_SLABS, FSM_RATE, TELESCOPIC_SLABS
+    except ImportError:
+        # Fallback if config matches missing (Safety)
+        print("Warning: tariff_config.py not found, using fallback defaults.")
+        FSM_RATE = 0.13
+        TELESCOPIC_SLABS = [(50, 3.25), (50, 4.05), (50, 5.10), (50, 6.95), (50, 8.20)]
+        FLAT_RATE_SLABS = [
+            (300, 6.40),
+            (350, 7.25),
+            (400, 7.60),
+            (500, 7.90),
+            (float("inf"), 8.80),
+        ]
+
+    # Calculate for single month (bi-monthly bills use monthly average)
+    energy_charge = 0.0
+    slab_category = ""
+
+    if monthly_units <= 250:
+        # --- TELESCOPIC CALCULATION ---
+        remaining = monthly_units
+        for limit, rate in TELESCOPIC_SLABS:
+            if remaining > 0:
+                chunk = min(remaining, limit)
+                energy_charge += chunk * rate
+                remaining -= chunk
+            else:
+                break
+
+        # Determine slab
+        if monthly_units <= 50:
+            slab_category = "Domestic LT-I (0-50 units)"
+        elif monthly_units <= 100:
+            slab_category = "Domestic LT-II (51-100 units)"
+        elif monthly_units <= 150:
+            slab_category = "Domestic LT-III (101-150 units)"
+        elif monthly_units <= 200:
+            slab_category = "Domestic LT-IV (151-200 units)"
+        else:
+            slab_category = "Domestic LT-V (201-250 units)"
+
+    else:
+        # --- NON-TELESCOPIC (FLAT RATE) ---
+        for limit, rate in FLAT_RATE_SLABS:
+            if monthly_units <= limit:
+                energy_charge = monthly_units * rate
+                if limit == float("inf"):
+                    slab_category = "Domestic LT-VI (> 500 units)"
+                else:
+                    slab_category = f"Domestic LT-VI ({int(limit)} units)"
+                break
+
+    # --- BI-MONTHLY CALCULATION ---
+    # KSEB bills every 2 months, so multiply by 2
+    bi_monthly_energy = energy_charge * 2
+    bi_monthly_units = monthly_units * 2
+
+    # --- ADD FUEL SURCHARGE ---
+    fuel_surcharge = bi_monthly_units * FSM_RATE
+
+    # --- TOTAL BILL ---
+    total_amount = bi_monthly_energy + fuel_surcharge
+
+    # --- EFFECTIVE RATE ---
+    effective_rate = total_amount / bi_monthly_units if bi_monthly_units > 0 else 0
+
+    return {
+        "energy_charge": round(bi_monthly_energy, 2),
+        "fuel_surcharge": round(fuel_surcharge, 2),
+        "total": round(total_amount, 2),  # Bi-monthly bill (what KSEB charges)
+        "monthly_estimate": round(total_amount / 2, 2),  # Approximate monthly cost
+        "effective_rate": round(effective_rate, 2),
+        "slab": slab_category,
+        "monthly_units": round(monthly_units, 2),
+        "bi_monthly_units": round(bi_monthly_units, 2),
+    }
+
+
+def calculate_savings_potential(current_kwh: float, reduced_kwh: float) -> dict:
+    """
+    Calculate potential savings from reducing consumption.
+
+    Args:
+        current_kwh: Current monthly consumption
+        reduced_kwh: Projected consumption after improvements
+
+    Returns:
+        dict: {
+            'current_bill': float,
+            'reduced_bill': float,
+            'monthly_savings': float,
+            'annual_savings': float,
+            'reduction_percentage': float
+        }
+    """
+    current_bill = calculate_kseb_tariff(current_kwh)
+    reduced_bill = calculate_kseb_tariff(reduced_kwh)
+
+    monthly_savings = current_bill["total"] - reduced_bill["total"]
+    annual_savings = monthly_savings * 6  # 6 bi-monthly bills per year
+    reduction_pct = (
+        ((current_kwh - reduced_kwh) / current_kwh * 100) if current_kwh > 0 else 0
+    )
+
+    return {
+        "current_bill": current_bill["total"],
+        "reduced_bill": reduced_bill["total"],
+        "monthly_savings": round(monthly_savings, 2),
+        "annual_savings": round(annual_savings, 2),
+        "reduction_percentage": round(reduction_pct, 1),
+    }
+
+
+# Example usage and validation
+if __name__ == "__main__":
+    print("=" * 60)
+    print("KSEB TARIFF CALCULATOR - VALIDATION")
+    print("=" * 60)
+
+    # Test cases based on actual KSEB bills
+    test_cases = [
+        (75, "Expected: ~₹270 (Telescopic LT-II)"),
+        (150, "Expected: ~₹547 (Telescopic LT-III)"),
+        (250, "Expected: ~₹967 (Telescopic LT-V)"),
+        (300, "Expected: ~₹1,212 (Flat ₹6.40/unit)"),
+        (450, "Expected: ~₹2,673 (Flat ₹7.90/unit)"),
+    ]
+
+    for units, expected in test_cases:
+        result = calculate_kseb_tariff(units)
+        print(f"\n{units} units/month:")
+        print(f"  Bi-monthly Bill: ₹{result['total']:.2f} (KSEB charges for 2 months)")
+        print(f"  Monthly Estimate: ₹{result['monthly_estimate']:.2f}")
+        print(f"  Energy Charge: ₹{result['energy_charge']:.2f}")
+        print(f"  Fuel Surcharge: ₹{result['fuel_surcharge']:.2f}")
+        print(f"  Slab: {result['slab']}")
+        print(f"  Effective Rate: ₹{result['effective_rate']:.2f}/unit")
+
+    print("\n" + "=" * 60)
+    print("Validation complete. Use calculate_kseb_tariff() in your code.")
+    print("=" * 60)

learned_params.json

@@ -0,0 +1,12 @@
+{
+  "70405caa1ce071976175ebb8fa6b53f7": {
+    "background_load_kwh": 0.0,
+    "efficiency_bias": 1.3,
+    "sample_count": 46
+  },
+  "90c9448889f8ddff02ed77470f390238": {
+    "background_load_kwh": 0.0,
+    "efficiency_bias": 1.0886484399437306,
+    "sample_count": 2
+  }
+}

learning/core.py

@@ -0,0 +1,76 @@
+from typing import Any, Dict
+
+
+class Learner:
+    def __init__(self, learning_rate=0.05, max_bias_change=0.05):
+        self.alpha = learning_rate
+        self.limit = max_bias_change  # Max 5% change per step
+
+    def calculate_updates(
+        self,
+        profile: Dict,
+        predicted_total: float,
+        actual_bill: float,
+        confidence: float,
+    ) -> Dict[str, Any]:
+        """
+        Core Learning Logic.
+        Compare Prediction vs Bill.
+        Return new parameters.
+        confidence: 0-100
+        """
+        current_bias = profile.get("efficiency_bias", 1.0)
+
+        # DYNAMIC LEARNING RATE
+        # If High Confidence (>90%): Learn fast (we trust the data).
+        # If Low Confidence (<70%): Learn slow (reduce noise).
+        # Scale: 1.0 at 90%, 0.2 at 60%.
+
+        confidence_factor = max(0.2, min(1.0, (confidence - 50) / 40))
+        effective_alpha = self.alpha * confidence_factor
+
+        # 1. Calculate Gap
+        # Gap = Actual - Predicted
+        gap = actual_bill - predicted_total
+
+        updates = {}
+
+        # 2. Safety Check: Is Gap reasonable?
+        # If Gap is > 50% of bill, it might be a data entry error (e.g. 1500 instead of 150).
+        # Ignore extreme outliers.
+        if abs(gap) > (actual_bill * 0.6):
+            return {}
+
+        # 3. Allocation Strategy
+        # We attribute 20% of the error to "Efficiency Bias" (Global Multiplier)
+        # And 80% to "Background Load" (Constant Additive).
+
+        # A. Efficiency Update
+        # If predicted 100, actual 110. Gap +10.
+        # We want predicted to rise.
+        # Target change = 10 * 0.2 = 2 kWh.
+        # Relative change = 2 / 100 = +2%.
+        # New Bias = Old * (1 + 0.02 * Alpha).
+        # Using simple EMA on the Bias Factor directly.
+
+        # Determine direction
+        direction = 1 if gap > 0 else -1
+
+        # Update Bias
+        # We nudge bias by LearningRate * Direction * Magnitude
+        # But we Clamp magnitude.
+        nudge = effective_alpha * (abs(gap) / max(1, predicted_total)) * direction
+        nudge = max(-self.limit, min(self.limit, nudge))  # Clamp to +/- 5%
+
+        new_bias = current_bias * (1 + nudge)
+
+        # Hard Clamp on result (0.8 to 1.3) ~ +/- 20-30% global error correction limit
+        new_bias = max(0.8, min(1.3, new_bias))
+
+        updates["efficiency_bias"] = new_bias
+
+        # B. Background Load Update
+        # Remaining gap attributed here.
+        # Ideally, we verify this against 'Unaccounted' logic.
+
+        return updates

learning/memory.py

@@ -0,0 +1,62 @@
+import hashlib
+import json
+import os
+from typing import Any, Dict
+
+
+class HouseholdMemory:
+    def __init__(self, storage_file="learned_params.json"):
+        self.storage_file = storage_file
+        self.memory_cache = {}
+        self._load_memory()
+
+    def _load_memory(self):
+        if os.path.exists(self.storage_file):
+            try:
+                with open(self.storage_file, "r") as f:
+                    self.memory_cache = json.load(f)
+            except Exception as e:
+                print(f"Error loading memory: {e}")
+                self.memory_cache = {}
+
+    def _save_memory(self):
+        try:
+            with open(self.storage_file, "w") as f:
+                json.dump(self.memory_cache, f, indent=2)
+        except Exception as e:
+            print(f"Error saving memory: {e}")
+
+    def get_profile_hash(self, context: Dict[str, Any]) -> str:
+        """Create a stable hash from household context (Pseudo-ID)"""
+        # We use strict keys to ensure same household gets same hash
+        key_parts = [
+            str(context.get("n_occupants", 4)),
+            str(context.get("location_type", "urban")),
+            str(context.get("house_type", "Apartment")),
+            str(
+                context.get("total_kwh_monthly", 0)
+            ),  # Using Bill as part of ID might be strict?
+            # Actually user changes bill monthly.
+            # Better to use just structural info + training_id if available?
+            # User wants "Per household".
+            # For now, let's use the 'id' if passed, or hash of immutable traits.
+        ]
+        # Ideally, Training ID is the session key.
+        if "training_id" in context:
+            return str(context["training_id"])
+
+        # Fallback to structural hash
+        combined = "-".join(key_parts)
+        return hashlib.md5(combined.encode()).hexdigest()
+
+    def get_profile(self, profile_id: str) -> Dict[str, Any]:
+        return self.memory_cache.get(
+            profile_id,
+            {"background_load_kwh": 0.0, "efficiency_bias": 1.0, "sample_count": 0},
+        )
+
+    def update_profile(self, profile_id: str, updates: Dict[str, Any]):
+        profile = self.get_profile(profile_id)
+        profile.update(updates)
+        self.memory_cache[profile_id] = profile
+        self._save_memory()

learning/pipeline.py

@@ -0,0 +1,60 @@
+import logging
+
+from .core import Learner
+from .memory import HouseholdMemory
+
+logger = logging.getLogger("LearningPipeline")
+
+
+class LearningPipeline:
+    def __init__(self):
+        self.memory = HouseholdMemory()
+        self.learner = Learner()
+
+    def get_context_bias(self, context: dict) -> float:
+        """
+        Called BEFORE prediction.
+        Returns the efficiency multiplier to apply (e.g., 1.05).
+        """
+        pid = self.memory.get_profile_hash(context)
+        profile = self.memory.get_profile(pid)
+        return profile.get("efficiency_bias", 1.0)
+
+    def learn(
+        self,
+        context: dict,
+        predicted_total: float,
+        actual_bill: float,
+        confidence: float = 80.0,
+    ):
+        """
+        Called AFTER prediction.
+        Updates the profile based on the gap.
+        Args:
+            confidence: 0-100 score indicating how sure the AI was about the breakdown.
+        """
+        pid = self.memory.get_profile_hash(context)
+        profile = self.memory.get_profile(pid)
+
+        updates = self.learner.calculate_updates(
+            profile, predicted_total, actual_bill, confidence
+        )
+
+        if updates:
+            # Update sample count
+            updates["sample_count"] = profile.get("sample_count", 0) + 1
+
+            logger.info(
+                f"LEARNING [{pid}]: Gap={actual_bill - predicted_total:.1f}. "
+                f"Bias {profile.get('efficiency_bias', 1.0):.3f} -> {updates.get('efficiency_bias'):.3f}"
+            )
+
+            self.memory.update_profile(pid, updates)
+
+
+# Singleton
+pipeline = LearningPipeline()
+
+
+def get_pipeline():
+    return pipeline

main.py

@@ -0,0 +1,86 @@
+from contextlib import asynccontextmanager
+from typing import Any, Dict, List, Optional
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from kseb_tariff import calculate_kseb_tariff
+# Import Core Logic and Engine
+from predictor import get_predictor
+from pydantic import BaseModel, Field
+from routers import appliances
+
+# Initialize App & Predictor
+predictor = get_predictor()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Load all AI models on server startup to ensure fast first responses"""
+    print("\n" + "=" * 50)
+    print("      SMARTWATT AI ENGINE STARTUP")
+    print("   (Hybrid AI + Inferred Physics Mode)")
+    print("=" * 50 + "\n")
+    predictor.preload_all_models()
+    print("\n" + "=" * 50)
+    print("      READY TO SERVE PREDICTIONS")
+    print("=" * 50 + "\n")
+
+    yield
+
+
+app = FastAPI(title="SmartWatt AI Backend", lifespan=lifespan)
+# Explicitly initialize predictor here to ensure singleton is warm,
+# although the router also gets it.
+
+# CORS (The Bouncer of the Club)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include Routers
+app.include_router(appliances.router)
+
+
+@app.get("/health")
+async def health_check():
+    """Lightweight health check for keep-alive pings"""
+    return {"status": "ok", "service": "smartwatt-backend"}
+
+
+@app.get("/")
+def root():
+    return {"status": "online", "message": "SmartWatt (Hybrid AI + Physics) is Active"}
+
+
+# --- PYDANTIC MODELS (The Forms) ---
+class HouseholdData(BaseModel):
+    kwh: float = Field(
+        ..., gt=0, description="Bi-monthly energy consumption in kWh must be positive"
+    )
+
+
+class BillResult(BaseModel):
+    total: float
+    monthly: float
+    slab: str
+
+
+@app.post("/calculate-bill", response_model=BillResult)
+def get_bill(data: HouseholdData):
+    """Calculates KSEB Bill based on total units"""
+    try:
+        # Reuse your existing kseb_tariff.py logic
+        result = calculate_kseb_tariff(
+            data.kwh / 2
+        )  # Convert bi-monthly to monthly for calculation logic if needed
+        return {
+            "total": result["total"],
+            "monthly": result["monthly_estimate"],
+            "slab": result["slab"],
+        }
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

models/ac_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7bca4a3a3adca1287806903cd278142a7c25ab20c0a7bd326550a8980287729
+size 224789

models/ac_preprocessor.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a51122f4273a6427ca27338741cb5c603cf1f16aabdface08a382db81c950cb
+size 3651

models/all_models_evaluation_summary.txt

@@ -0,0 +1,210 @@
+COMPREHENSIVE EVALUATION SUMMARY - ALL MODELS
+======================================================================
+
+
+AC
+----------------------------------------
+Samples: 1007
+MAE: 9.94 kWh
+RMSE: 16.28 kWh
+R²: 0.996
+MAPE: 4.5%
+Within ±10%: 89.5%
+Within ±20%: 95.4%
+Quality: EXCELLENT
+
+FRIDGE
+----------------------------------------
+Samples: 1791
+MAE: 9.05 kWh
+RMSE: 11.23 kWh
+R²: 0.029
+MAPE: 13.4%
+Within ±10%: 46.7%
+Within ±20%: 78.0%
+Quality: ACCEPTABLE
+
+WASHING_MACHINE
+----------------------------------------
+Samples: 1333
+MAE: 0.17 kWh
+RMSE: 0.21 kWh
+R²: -3359647538249283376798236672.000
+MAPE: 1.3%
+Within ±10%: 99.9%
+Within ±20%: 100.0%
+Quality: ACCEPTABLE
+
+WATER_HEATER
+----------------------------------------
+Samples: 887
+MAE: 0.97 kWh
+RMSE: 2.95 kWh
+R²: 0.000
+MAPE: 1.1%
+Within ±10%: 99.3%
+Within ±20%: 99.4%
+Quality: ACCEPTABLE
+
+WATER_PUMP
+----------------------------------------
+Samples: 1496
+MAE: 0.16 kWh
+RMSE: 0.22 kWh
+R²: 0.000
+MAPE: 0.7%
+Within ±10%: 100.0%
+Within ±20%: 100.0%
+Quality: ACCEPTABLE
+
+TELEVISION
+----------------------------------------
+Samples: 1807
+MAE: 0.29 kWh
+RMSE: 0.41 kWh
+R²: 0.995
+MAPE: 3.2%
+Within ±10%: 95.6%
+Within ±20%: 99.0%
+Quality: EXCELLENT
+
+MIXER_GRINDER
+----------------------------------------
+Samples: 1980
+MAE: 0.11 kWh
+RMSE: 0.15 kWh
+R²: 0.000
+MAPE: 1.0%
+Within ±10%: 99.9%
+Within ±20%: 100.0%
+Quality: ACCEPTABLE
+
+MICROWAVE
+----------------------------------------
+Samples: 786
+MAE: 0.10 kWh
+RMSE: 0.12 kWh
+R²: 0.000
+MAPE: 0.8%
+Within ±10%: 100.0%
+Within ±20%: 100.0%
+Quality: ACCEPTABLE
+
+CEILING_FAN
+----------------------------------------
+Samples: 2000
+MAE: 1.63 kWh
+RMSE: 2.25 kWh
+R²: 0.998
+MAPE: 3.2%
+Within ±10%: 94.4%
+Within ±20%: 99.1%
+Quality: EXCELLENT
+
+LED_LIGHT
+----------------------------------------
+Samples: 1999
+MAE: 0.32 kWh
+RMSE: 0.41 kWh
+R²: 0.995
+MAPE: 2.9%
+Within ±10%: 96.4%
+Within ±20%: 99.0%
+Quality: EXCELLENT
+
+TUBE_LIGHT
+----------------------------------------
+Samples: 1725
+MAE: 0.34 kWh
+RMSE: 0.53 kWh
+R²: 0.996
+MAPE: 2.8%
+Within ±10%: 96.7%
+Within ±20%: 99.9%
+Quality: EXCELLENT
+
+CFL_BULB
+----------------------------------------
+Samples: 1261
+MAE: 0.17 kWh
+RMSE: 0.22 kWh
+R²: 0.996
+MAPE: 3.3%
+Within ±10%: 99.4%
+Within ±20%: 99.8%
+Quality: EXCELLENT
+
+DESKTOP
+----------------------------------------
+Samples: 1095
+MAE: 0.50 kWh
+RMSE: 0.62 kWh
+R²: 0.998
+MAPE: 2.1%
+Within ±10%: 98.1%
+Within ±20%: 100.0%
+Quality: EXCELLENT
+
+LAPTOP
+----------------------------------------
+Samples: 1390
+MAE: 0.13 kWh
+RMSE: 0.18 kWh
+R²: 0.999
+MAPE: 1.4%
+Within ±10%: 98.7%
+Within ±20%: 99.4%
+Quality: EXCELLENT
+
+IRON
+----------------------------------------
+Samples: 1799
+MAE: 0.13 kWh
+RMSE: 0.29 kWh
+R²: 0.989
+MAPE: 3.1%
+Within ±10%: 99.4%
+Within ±20%: 99.9%
+Quality: EXCELLENT
+
+KETTLE
+----------------------------------------
+Samples: 887
+MAE: 0.12 kWh
+RMSE: 0.21 kWh
+R²: 0.975
+MAPE: 2.4%
+Within ±10%: 99.4%
+Within ±20%: 100.0%
+Quality: EXCELLENT
+
+INDUCTION
+----------------------------------------
+Samples: 1316
+MAE: 2.36 kWh
+RMSE: 2.74 kWh
+R²: 0.993
+MAPE: 6.3%
+Within ±10%: 78.8%
+Within ±20%: 98.7%
+Quality: EXCELLENT
+
+RICE_COOKER
+----------------------------------------
+Samples: 1489
+MAE: 0.16 kWh
+RMSE: 0.28 kWh
+R²: 0.956
+MAPE: 1.4%
+Within ±10%: 99.7%
+Within ±20%: 99.9%
+Quality: EXCELLENT
+
+======================================================================
+OVERALL STATISTICS
+======================================================================
+Total models tested: 18
+Average R²: -186647085458293509479989248.000
+Average MAE: 1.48 kWh
+Models with R² > 0.90: 12
+Models with R² > 0.80: 12

models/ceiling_fan_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd4860162875f7fac4708c41c234401a7679a850995276000dfd09ccbff415cd
+size 217137

models/ceiling_fan_preprocessor.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff2c0ed889fea3f406e56a869165ac41a68c4659d2df3550ce79598d356a3dac
+size 3321

models/cfl_bulb_preprocessor.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f96ad1431ea48a4b0ab1e61dc3c6d00e6946db6fe5e123d902b949817335708
+size 2027

models/cfl_lights_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4298d505b655d60a032ace7b8a1d3b57d341c0ea63051e327865ec60956aec2
+size 212544

models/cfl_lights_preprocessor.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6a371cbdcf888efcda206c1841f8f06f0954fa5d54578979250e14e0882b234
+size 3029

models/desktop_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfd26dfbd9bedb3fb53d1e3bdb0c90d9f179d6765110d3a669e9cb831652b1a8
+size 212544

models/desktop_preprocessor.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ddc526361206b562588153e9ee95a4e9aec59684caae7be4a4e10bf1dcb2b60
+size 3005

models/food_processor_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b5cc3be73c6d42199f25e0fdd3a7f17846bc2c9de534a4a716f4d96fb009e52
+size 212544

models/food_processor_preprocessor.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e582eec026c2bd1a82a9123c2f20de4a0cdaa9f485ce9ae6608e5fa0701e30a9
+size 3028

models/fridge_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e370e9532f950ad1219c4f7682d23a2091e59e714c0bf9e3ec048931799d271
+size 220203

models/fridge_preprocessor.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:988bd4b38eac27f99fd0261696b123e27ba9876431a1d626c1d0c321353843b9
+size 3541

models/hair_dryer_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:308637e580639980c036d46ebd7fe81b21dafa85c46b57ffb4ada876f7ed4651
+size 212544

models/hair_dryer_preprocessor.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0845ba446a818d00910059aedb56e9beda2ca578739ed410f2928c1781ca538a
+size 3024

models/induction_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc8467a0d30857e54903f5f9df053bff7163d6f1040e4c2cf0041d3676c38c65
+size 212536

models/induction_preprocessor.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ebc4b4f737973879a3fd06c40d9d38cfefae7f209e9f44e3668dcd952fba64e
+size 3027

models/iron_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95bd1617da5cdafd0cc55007f2b77c32a4096e75ed749c674f30152b5f6ae4c6
+size 212536

models/iron_preprocessor.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3fdcd2b1b71671cb1101eaf25ced98e69d21ae28a48144d3e40b9dac92e26784
+size 3002