+ 
+ 
+ 
+ 
+
+
| 
|
+
+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`.
diff --git a/Training_Scripts/future_train.py b/Training_Scripts/future_train.py
new file mode 100644
index 0000000000000000000000000000000000000000..58237535a98662731bd8c40308c0ec9714ff6186
--- /dev/null
+++ b/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()
diff --git a/Training_Scripts/newdataset.py b/Training_Scripts/newdataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..9607498075fb5145f6e6bf80566125bf03a6f07f
--- /dev/null
+++ b/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")
diff --git a/Training_Scripts/train(latest).py b/Training_Scripts/train(latest).py
new file mode 100644
index 0000000000000000000000000000000000000000..3c6a3d046f599d65c5d6011588264642edaa397c
--- /dev/null
+++ b/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()
diff --git a/Training_Scripts/train(old).py b/Training_Scripts/train(old).py
new file mode 100644
index 0000000000000000000000000000000000000000..14b383f9c3b20669528b5d49646312baf6e147ce
--- /dev/null
+++ b/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()
diff --git a/Training_Scripts/train_demo.py b/Training_Scripts/train_demo.py
new file mode 100644
index 0000000000000000000000000000000000000000..011c2349479abe47cc2f34a8a1fe4afa646aff75
--- /dev/null
+++ b/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()
diff --git a/Training_Scripts/train_with_logging.py b/Training_Scripts/train_with_logging.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ca15757f13b7f523019768a122e325e834c20fd
--- /dev/null
+++ b/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")
diff --git a/anomaly_engine.py b/anomaly_engine.py
new file mode 100644
index 0000000000000000000000000000000000000000..d0a4ba585abd6338c4c6c77572db3fc3c1700771
--- /dev/null
+++ b/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}
diff --git a/kseb_tariff.py b/kseb_tariff.py
new file mode 100644
index 0000000000000000000000000000000000000000..160f8c98edc46e39b9bd421c2c91517aaf8add53
--- /dev/null
+++ b/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)
diff --git a/learned_params.json b/learned_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..1db9912e016cf1787baf6c233d1f6080f9388cc5
--- /dev/null
+++ b/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
+ }
+}
\ No newline at end of file
diff --git a/learning/__init__.py b/learning/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/learning/core.py b/learning/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1a1859b8e86fe99e516e9fb25db7781fd07491b
--- /dev/null
+++ b/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
diff --git a/learning/memory.py b/learning/memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..8cfcc49f50f094f38de4d9ab90d2abe26a817f39
--- /dev/null
+++ b/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()
diff --git a/learning/pipeline.py b/learning/pipeline.py
new file mode 100644
index 0000000000000000000000000000000000000000..42c88f8deee236efef6d69dace1c63f4650a4f1f
--- /dev/null
+++ b/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
diff --git a/main.py b/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..42dbf7883bb5f80ed6de7b13e461b3933bc30875
--- /dev/null
+++ b/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))
diff --git a/models/ac_model.keras b/models/ac_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..509670171e5a64c7b00df9351ff4e99d55e68a8c
--- /dev/null
+++ b/models/ac_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7bca4a3a3adca1287806903cd278142a7c25ab20c0a7bd326550a8980287729
+size 224789
diff --git a/models/ac_preprocessor.pkl b/models/ac_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..6f781c200b92fef958405a2a285c6a27eec29af9
--- /dev/null
+++ b/models/ac_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a51122f4273a6427ca27338741cb5c603cf1f16aabdface08a382db81c950cb
+size 3651
diff --git a/models/all_models_evaluation_summary.txt b/models/all_models_evaluation_summary.txt
new file mode 100644
index 0000000000000000000000000000000000000000..064fb330e3978085ef3e0735596581a321ddcebb
--- /dev/null
+++ b/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
diff --git a/models/ceiling_fan_model.keras b/models/ceiling_fan_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..88dd9eba76f7ca00db205a6ada316f96d7d979aa
--- /dev/null
+++ b/models/ceiling_fan_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd4860162875f7fac4708c41c234401a7679a850995276000dfd09ccbff415cd
+size 217137
diff --git a/models/ceiling_fan_preprocessor.pkl b/models/ceiling_fan_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..e170bca8e5b6a49576a664fe58dccfa8daf50365
--- /dev/null
+++ b/models/ceiling_fan_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff2c0ed889fea3f406e56a869165ac41a68c4659d2df3550ce79598d356a3dac
+size 3321
diff --git a/models/cfl_bulb_preprocessor.pkl b/models/cfl_bulb_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..1261d37dccf460ea455490a7828b56ceb7dc0ef7
--- /dev/null
+++ b/models/cfl_bulb_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f96ad1431ea48a4b0ab1e61dc3c6d00e6946db6fe5e123d902b949817335708
+size 2027
diff --git a/models/cfl_lights_model.keras b/models/cfl_lights_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..431094777cdead5e1735968ea755468463dbd981
--- /dev/null
+++ b/models/cfl_lights_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4298d505b655d60a032ace7b8a1d3b57d341c0ea63051e327865ec60956aec2
+size 212544
diff --git a/models/cfl_lights_preprocessor.pkl b/models/cfl_lights_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..c2d0524d683d187bb333dba28ab92f2a14999e60
--- /dev/null
+++ b/models/cfl_lights_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6a371cbdcf888efcda206c1841f8f06f0954fa5d54578979250e14e0882b234
+size 3029
diff --git a/models/desktop_model.keras b/models/desktop_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..8c2e0c2de7c079948e42b4d1573431dfb9563611
--- /dev/null
+++ b/models/desktop_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfd26dfbd9bedb3fb53d1e3bdb0c90d9f179d6765110d3a669e9cb831652b1a8
+size 212544
diff --git a/models/desktop_preprocessor.pkl b/models/desktop_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..9ba4a9d3100fc73c7aa9b14c686f337d11c2e9b4
--- /dev/null
+++ b/models/desktop_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ddc526361206b562588153e9ee95a4e9aec59684caae7be4a4e10bf1dcb2b60
+size 3005
diff --git a/models/food_processor_model.keras b/models/food_processor_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..a1358ee78dd28e96aeb185b654ddbe403df5e3b3
--- /dev/null
+++ b/models/food_processor_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b5cc3be73c6d42199f25e0fdd3a7f17846bc2c9de534a4a716f4d96fb009e52
+size 212544
diff --git a/models/food_processor_preprocessor.pkl b/models/food_processor_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..32dab4bca7a168c06faa156335d84e0eaa7c431c
--- /dev/null
+++ b/models/food_processor_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e582eec026c2bd1a82a9123c2f20de4a0cdaa9f485ce9ae6608e5fa0701e30a9
+size 3028
diff --git a/models/fridge_model.keras b/models/fridge_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..401ba4c9fc0ace0ccc89d53f2b2a47ab5ca2e86b
--- /dev/null
+++ b/models/fridge_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e370e9532f950ad1219c4f7682d23a2091e59e714c0bf9e3ec048931799d271
+size 220203
diff --git a/models/fridge_preprocessor.pkl b/models/fridge_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..dd7b4fbd75b361c3dc62c4727a0a70ce547a847b
--- /dev/null
+++ b/models/fridge_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:988bd4b38eac27f99fd0261696b123e27ba9876431a1d626c1d0c321353843b9
+size 3541
diff --git a/models/hair_dryer_model.keras b/models/hair_dryer_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..f9558ce8d09a5a3f3c8f8e1d2b701141c6ccad3c
--- /dev/null
+++ b/models/hair_dryer_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:308637e580639980c036d46ebd7fe81b21dafa85c46b57ffb4ada876f7ed4651
+size 212544
diff --git a/models/hair_dryer_preprocessor.pkl b/models/hair_dryer_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..622593706f93a5d7dfe4eb47657c6f8ee2912a34
--- /dev/null
+++ b/models/hair_dryer_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0845ba446a818d00910059aedb56e9beda2ca578739ed410f2928c1781ca538a
+size 3024
diff --git a/models/induction_model.keras b/models/induction_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..18ca48961f84073f6331aab4b0762661f45493fb
--- /dev/null
+++ b/models/induction_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc8467a0d30857e54903f5f9df053bff7163d6f1040e4c2cf0041d3676c38c65
+size 212536
diff --git a/models/induction_preprocessor.pkl b/models/induction_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..e0fdf9dd95053fafe71a3b3dd8faf741736df125
--- /dev/null
+++ b/models/induction_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ebc4b4f737973879a3fd06c40d9d38cfefae7f209e9f44e3668dcd952fba64e
+size 3027
diff --git a/models/iron_model.keras b/models/iron_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..cc1afdd649ca16f2e89f7024a27f258776ef721e
--- /dev/null
+++ b/models/iron_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95bd1617da5cdafd0cc55007f2b77c32a4096e75ed749c674f30152b5f6ae4c6
+size 212536
diff --git a/models/iron_preprocessor.pkl b/models/iron_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..a47d57c8c115430d04f12cd404646d4e40a5bbcf
--- /dev/null
+++ b/models/iron_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3fdcd2b1b71671cb1101eaf25ced98e69d21ae28a48144d3e40b9dac92e26784
+size 3002
diff --git a/models/kettle_model.keras b/models/kettle_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..5e6244d84ca269c69ecef7a21817b0ff3e745f34
--- /dev/null
+++ b/models/kettle_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87092a6518e0b3dc8b84805a78ce53f1a91a881cbc10e12ee8e4474a032706b5
+size 212536
diff --git a/models/kettle_preprocessor.pkl b/models/kettle_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..1c95f377772ddb6510cd96084b6f37cac58c8fad
--- /dev/null
+++ b/models/kettle_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9dd5b17620cf161a8d8e540809ca8db6ffa8efb1e51a444f583845e7d654cf89
+size 3004
diff --git a/models/laptop_model.keras b/models/laptop_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..6c0afc3d7723f69f297d7dcf3885884b05f9e10d
--- /dev/null
+++ b/models/laptop_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7e4045cd5a3fd308aaa5101534142bdeb448b0e299fadba2a5fcb8326824fa6
+size 212544
diff --git a/models/laptop_preprocessor.pkl b/models/laptop_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..07077a999064e969be45c6c096c1cdcd48827a95
--- /dev/null
+++ b/models/laptop_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c912c81a40e3ecd501b82dcb656a39eaa4e53cb492ab255ffd3bda6f7b51ba2
+size 3004
diff --git a/models/led_light_preprocessor.pkl b/models/led_light_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..1c789395ad3fcc29c84c7a909739035bdbf68568
--- /dev/null
+++ b/models/led_light_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d35c55279e049435cb5fde38a854cdffc9ba8885efc13fb36101b19bc4e410d4
+size 2043
diff --git a/models/led_lights_model.keras b/models/led_lights_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..0850aa8b4059f5faaee918828e81eb282ad1c537
--- /dev/null
+++ b/models/led_lights_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:179761d9eecc6cfff92bf512bdeb80731ba78c49804a636e624791efe6d02e40
+size 212544
diff --git a/models/led_lights_preprocessor.pkl b/models/led_lights_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..0340fb49ed8b46d0e7056e5aaaedf55230711c11
--- /dev/null
+++ b/models/led_lights_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bfc0b84f45c72933079dd7a33f62ac10c1bd0c1202dff0de0a189c0ce5e8b24
+size 3029
diff --git a/models/microwave_model.keras b/models/microwave_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..dd9dde8313335e324a971241ed00b19be247e118
--- /dev/null
+++ b/models/microwave_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7a3dda506a68c928685b71ad2355c91de909c4fbead3319f284f80924fb5ab8
+size 212544
diff --git a/models/microwave_preprocessor.pkl b/models/microwave_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..34a828e20c1df0fd51360ad0bed1d4c9e432e0a6
--- /dev/null
+++ b/models/microwave_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8fa31a5cd06be68eaa1bcca708fe6ea1f8d944a60a7b196e2389689278c667d
+size 3023
diff --git a/models/mixer_grinder_preprocessor.pkl b/models/mixer_grinder_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..5e296264eb65c56f0a7be87247c585912d9a111b
--- /dev/null
+++ b/models/mixer_grinder_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:443865a83c7ab72e6532d097d9522d06fb7615b1334ebf96ce33a2f86b1ca684
+size 2107
diff --git a/models/mixer_model.keras b/models/mixer_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..9cc173a25c662ada8ab6cdedec174fec0486e66b
--- /dev/null
+++ b/models/mixer_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40cc42739d52349547434ab6dd3f4a6ac6f9445f57e47126ad82434429d3df1b
+size 212544
diff --git a/models/mixer_preprocessor.pkl b/models/mixer_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..1b732b12a23d85dc7c6d2dbc672e3a50e7ac9086
--- /dev/null
+++ b/models/mixer_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f49ba049aa2e4230665b6f0ed08aaf9a305daf4bc46ca23fa5568c77d8bc41e
+size 3003
diff --git a/models/rice_cooker_model.keras b/models/rice_cooker_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..883fa73bea5a44f01c0b29f067e0e3bc54302303
--- /dev/null
+++ b/models/rice_cooker_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1341001a35e326269b503c7be41a601561308bb700849a4320e7aa75c59ce2d8
+size 212544
diff --git a/models/rice_cooker_preprocessor.pkl b/models/rice_cooker_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..8a776bca6e4133371f0ea22f022cb22f8adb9d28
--- /dev/null
+++ b/models/rice_cooker_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16caa6f5841d2fc64e729b7b218fe40b2668ee7da5f15205021bc8fee6c33aae
+size 3025
diff --git a/models/television_model.keras b/models/television_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..91f3a13b6e972ff7f45e1ac7564aa404342b8428
--- /dev/null
+++ b/models/television_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a326b903986e2c77ae6a2e932b4871fc825700e449c8baa79c9d333d2b677031
+size 218680
diff --git a/models/television_preprocessor.pkl b/models/television_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..c50d78f5ec20734aaabfd8ade67a28bce28567b9
--- /dev/null
+++ b/models/television_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aedc0481fbff0692baeb3fb9bf780c6db3378c49438c42e260b5cc4dc3c7958e
+size 3359
diff --git a/models/toaster_model.keras b/models/toaster_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..f145c38eea749fe627034ef676849e3f36df1acc
--- /dev/null
+++ b/models/toaster_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:655ec1fcf5a9fd66684c4549e83905432f8b34898d482c58a9885d64c844e3f8
+size 212544
diff --git a/models/toaster_preprocessor.pkl b/models/toaster_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..9f67f023fffba65386ff831cf48bf99c40d8bed7
--- /dev/null
+++ b/models/toaster_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fdab75fc37b7af54c1a62793a10fb1a103daa68e21d7dc7c50f0ff504594ee64
+size 3005
diff --git a/models/tube_light_preprocessor.pkl b/models/tube_light_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..3e28b46f1d98fc5994a1abe374d231847346878e
--- /dev/null
+++ b/models/tube_light_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5272835a77941e210f6a6a72221be544594d96e38dbeb97a2deb72fbd65b3906
+size 2043
diff --git a/models/tube_lights_model.keras b/models/tube_lights_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..eed8811bdfc4ce89ee7d1d4c622649918f38ad29
--- /dev/null
+++ b/models/tube_lights_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bbb920d2a6ff68f08f3b3238bdc01fddffd1c718889bae066725344fb424670f
+size 212544
diff --git a/models/tube_lights_preprocessor.pkl b/models/tube_lights_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..ad5441599c73d1c5aa0ce7bf8044314a570e3f30
--- /dev/null
+++ b/models/tube_lights_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:440ae1f3cab3f2a9dd0976aebdf0b8de46cf713789d607927fa7c44b81ff16fe
+size 3030
diff --git a/models/vacuum_model.keras b/models/vacuum_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..80170a2d7ff6c560213a1407c84295887e99806e
--- /dev/null
+++ b/models/vacuum_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d6a31cd9f21812c68052ac7eabcb4d72ce137e2977f8568f65df29ddd41c9b08
+size 212544
diff --git a/models/vacuum_preprocessor.pkl b/models/vacuum_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..f89f2361b5823a85ffb9be903cb387abfa327b2d
--- /dev/null
+++ b/models/vacuum_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d6c83d647b52cb3e8fc34550114cef9a8a49055aa2b1b783d254b225140e5149
+size 3004
diff --git a/models/washing_machine_model.keras b/models/washing_machine_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..c2769a9b9ac2ba43cff236858cfa073a56edc422
--- /dev/null
+++ b/models/washing_machine_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5569adc67dda2e1b0eaa63c40bc0b667cc85e574db4677bd530ffde0e00ce634
+size 215608
diff --git a/models/washing_machine_preprocessor.pkl b/models/washing_machine_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..4c14ae97e3dbfd2dec8df76d126978f26d3b2a54
--- /dev/null
+++ b/models/washing_machine_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8bcacee916b78bec661390dcfa70a57ecaafddbd505202ae0394ec043b5f350
+size 3228
diff --git a/models/water_heater_model.keras b/models/water_heater_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..8ceb39b6066a021b1dbd23ac0645c6a196934758
--- /dev/null
+++ b/models/water_heater_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48cdd5e77cdf3a1bcac646dced3c980ba75952218a46a32958d7ac5b95644986
+size 220216
diff --git a/models/water_heater_preprocessor.pkl b/models/water_heater_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..9254179953fba78fb70b68d7b5eec96e26df740d
--- /dev/null
+++ b/models/water_heater_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:897c835a6a4b12c70bb7bec5142d38c321550520f2c1b3d396e0016f710fc9fb
+size 3422
diff --git a/models/water_pump_model.keras b/models/water_pump_model.keras
new file mode 100644
index 0000000000000000000000000000000000000000..6b39819db47d93a2b841ccc296719d69d2f3bce9
--- /dev/null
+++ b/models/water_pump_model.keras
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:de5299869e85fb54a54b289abe091aec602c8a9d4edb03b1d1172c316ae27bab
+size 214072
diff --git a/models/water_pump_preprocessor.pkl b/models/water_pump_preprocessor.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..7eae605cecf43c7aea14f1be2086f070fd80b2f0
--- /dev/null
+++ b/models/water_pump_preprocessor.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17a1b8ceda5f37960e285198b97332c6afff165e6053d5b21ce63ee2a0a2e9a1
+size 3091
diff --git a/newdataset.py b/newdataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..9607498075fb5145f6e6bf80566125bf03a6f07f
--- /dev/null
+++ b/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")
diff --git a/physics_constants.py b/physics_constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..2594ef55f2643fd14a09613aa17c1741ed3bd75c
--- /dev/null
+++ b/physics_constants.py
@@ -0,0 +1,43 @@
+"""
+Shared Physics Constants for SmartWatt Hybrid 0
+This file is the "Ground Truth".
+When the AI feels unsure (or for simple devices like Irons),
+it checks this file to know the correct Wattage.
+"""
+
+PHYSICS_DEFAULTS = {
+ # MAJOR APPLIANCES
+ "ac": {
+ "reference_watts": 1000, # Per Ton (e.g. 1.5 Ton = 1500W base)
+ "default_hours": 8,
+ },
+ "fridge": {
+ "reference_watts": 40, # Baseline active draw (approx for 250L) - scaling handled by logic
+ "default_hours": 24,
+ },
+ "washing_machine": {
+ "reference_watts": 500, # Average cycle power
+ "default_hours": 1.0, # Per day approx (derived from cycles)
+ },
+ "water_heater": {"reference_watts": 2000, "default_hours": 1.5},
+ "water_pump": {"reference_watts": 746, "default_hours": 0.5}, # 1 HP
+ "television": {
+ "reference_watts": 100, # Approx for 43-50 inch LED
+ "default_hours": 4,
+ },
+ # LIGHTING & FANS
+ "ceiling_fan": {"reference_watts": 75, "default_hours": 12},
+ "led_light": {"reference_watts": 10, "default_hours": 6},
+ "tube_light": {"reference_watts": 40, "default_hours": 6},
+ "cfl_bulb": {"reference_watts": 20, "default_hours": 6},
+ # KITCHEN
+ "microwave": {"reference_watts": 1200, "default_hours": 0.3},
+ "mixer_grinder": {"reference_watts": 750, "default_hours": 0.5},
+ "kettle": {"reference_watts": 1500, "default_hours": 0.2},
+ "induction": {"reference_watts": 1500, "default_hours": 1.0}, # Variable 1200-2000
+ "rice_cooker": {"reference_watts": 700, "default_hours": 0.5},
+ # OTHER
+ "desktop": {"reference_watts": 200, "default_hours": 4},
+ "laptop": {"reference_watts": 50, "default_hours": 4},
+ "iron": {"reference_watts": 1000, "default_hours": 0.2},
+}
diff --git a/physics_engine.py b/physics_engine.py
new file mode 100644
index 0000000000000000000000000000000000000000..a221ce99c53a42721c2c8bef4e79d1e907b40209
--- /dev/null
+++ b/physics_engine.py
@@ -0,0 +1,99 @@
+class PhysicsEngine:
+ """
+ Handles definitive Watt-Hour calculations based on appliance specifications.
+ This is the "Truth" layer that adheres to physics laws.
+ """
+
+ @staticmethod
+ def _get_float(d, key, default):
+ val = d.get(key, default)
+ if val == "unknown" or val is None:
+ return default
+ try:
+ return float(val)
+ except:
+ return default
+
+ @classmethod
+ def calculate_watts(cls, name, d):
+ """Standard Physics Wattage Calculation"""
+ watts = 100 # Fallback
+
+ if name == "ac":
+ tons = cls._get_float(d, "ac_tonnage", 1.5)
+ star = cls._get_float(d, "ac_star_rating", 3)
+ # Prevent star rating > 5 or < 1 causing weird math? No, formula handles it.
+ watts = tons * 1200 * (1 + (5 - star) * 0.1)
+
+ elif name == "fridge":
+ cap = cls._get_float(d, "fridge_capacity", 250)
+ age = cls._get_float(d, "fridge_age", 5)
+ star = cls._get_float(d, "fridge_star_rating", 3)
+ # DEBUG: Print to confirm logic usage
+ # print(f"DEBUG: Fridge Physics - Star: {star}, Capacity: {cap}, Age: {age}")
+
+ # Base watts + 2% degradation per year + Star Rating Impact (5 star = 20% less base)
+ # Base 150W for 3-star. 5-star ~120W. 1-star ~180W.
+ base_watts = (cap / 250) * 150
+ efficiency_factor = (
+ 1 + (3 - star) * 0.15
+ ) # 5-star -> 0.7 (30% less), 1-star -> 1.3 (30% more)
+ watts = base_watts * efficiency_factor * (1 + (age * 0.02))
+
+ elif name == "ceiling_fan":
+ fan_type = d.get("fan_type", "standard")
+ if fan_type == "bldc":
+ watts = 30 # BLDC Energy Saver
+ else:
+ watts = 75 # Standard Fan
+
+ elif name == "television":
+ size = cls._get_float(d, "tv_size_inches", 43)
+ watts = size * 2.5 # Approx 100W for 43 inch, 140W for 55 inch
+
+ elif name == "washing_machine":
+ watts = 500 # Watts per cycle equivalent
+
+ elif name == "water_pump":
+ hp = cls._get_float(d, "water_pump_hp", 1.0)
+ watts = hp * 746
+
+ elif name == "water_heater":
+ watts = 2000 # 2kW Geyser
+
+ elif name == "iron":
+ watts = 1000 # Standard Iron
+
+ elif name == "kettle":
+ watts = 1500
+
+ elif name == "induction":
+ watts = 2000
+
+ elif name == "desktop":
+ watts = 250
+
+ elif name == "microwave":
+ watts = 1200
+ elif name == "mixer":
+ watts = 750
+ elif name == "rice_cooker":
+ watts = 600
+ elif name == "toaster":
+ watts = 800
+ elif name == "food_processor":
+ watts = 600
+ elif name == "laptop":
+ watts = 60
+ elif name == "hair_dryer":
+ watts = 1200
+ elif name == "vacuum":
+ watts = 1400
+ elif name == "led_lights":
+ watts = 9
+ elif name == "cfl_lights":
+ watts = 18
+ elif name == "tube_lights":
+ watts = 40
+
+ return watts
diff --git a/predictor.py b/predictor.py
new file mode 100644
index 0000000000000000000000000000000000000000..efa495fb0ac3b53f7d2d581d1d1a5b008fe3b08f
--- /dev/null
+++ b/predictor.py
@@ -0,0 +1,432 @@
+import logging
+import os
+
+# Configure Logging
+logging.basicConfig(
+ level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# Silence TensorFlow oneDNN messages
+os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"
+
+import joblib
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+from anomaly_engine import AnomalyEngine
+from physics_engine import PhysicsEngine
+from range_resolver import resolve_range_values
+
+
+class AppliancePredictor:
+ def __init__(self, models_dir="models"):
+ self.models_dir = models_dir
+ self.models = {}
+ self.preprocessors = {}
+
+ def _get_val(self, d, key, default):
+ val = d.get(key, default)
+ return val if val != "unknown" else default
+
+ def _get_float(self, d, key, default):
+ val = d.get(key, default)
+ if val == "unknown" or val is None:
+ return default
+ try:
+ return float(val)
+ except:
+ return default
+
+ def _load_model(self, app_name):
+ if app_name not in self.models:
+ path = f"{self.models_dir}/{app_name}_model.keras"
+ try:
+ self.models[app_name] = tf.keras.models.load_model(path)
+ self.preprocessors[app_name] = joblib.load(
+ f"{self.models_dir}/{app_name}_preprocessor.pkl"
+ )
+ except:
+ # If model doesn't exist (e.g. Iron), we fallback to Pure Physics
+ self.models[app_name] = None
+
+ def preload_all_models(self):
+ """Loads all 22 models into memory for fast inference"""
+ apps = [
+ "ac",
+ "fridge",
+ "ceiling_fan",
+ "television",
+ "washing_machine",
+ "water_pump",
+ "water_heater",
+ "iron",
+ "kettle",
+ "induction",
+ "desktop",
+ "microwave",
+ "mixer",
+ "rice_cooker",
+ "toaster",
+ "food_processor",
+ "laptop",
+ "hair_dryer",
+ "vacuum",
+ "led_lights",
+ "cfl_lights",
+ "tube_lights",
+ ]
+ logger.info("Loading AI Models...")
+ for app in apps:
+ self._load_model(app)
+ logger.info("Models Loaded Successfully.")
+
+ def predict(self, name, data):
+ d = data[0]
+
+ # Note: Range resolution now happens in routers/appliances.py AFTER field mapping
+ # This ensures resolved values use correct training column names
+
+ model_name = name
+ # Map frontend names to model names
+ if name == "fan":
+ model_name = "ceiling_fan"
+ if name == "tv":
+ model_name = "television"
+ if name == "geyser":
+ model_name = "water_heater"
+ if name == "pump":
+ model_name = "water_pump"
+ if name == "washing_machine":
+ model_name = "washing_machine"
+ if name == "mixer_grinder":
+ model_name = "mixer"
+ if name == "led_light":
+ model_name = "led_lights" # Main.py uses led_light
+ if name == "tube_light":
+ model_name = "tube_lights"
+
+ # Lights need special handling if frontend sends generic 'light'
+ if name == "led_bulb":
+ model_name = "led_lights"
+ if name == "cfl_bulb":
+ model_name = "cfl_lights"
+
+ self._load_model(model_name)
+
+ # Default Physics Values
+ base_watts = PhysicsEngine.calculate_watts(model_name, d)
+
+ # --- SMART FEATURE INFERENCE (AI-Driven) ---
+ # Resolve missing "n_occupants" using room/appliance heuristics
+ if "n_occupants" not in d or d["n_occupants"] is None:
+ # Logic: More fans/ACs usually imply more rooms/people
+ n_fans = self._get_float(
+ d, "num_ceiling_fans", self._get_float(d, "num_fans", 0)
+ )
+ n_ac = self._get_float(d, "num_ac_units", self._get_float(d, "num_ac", 0))
+
+ if n_fans > 0:
+ d["n_occupants"] = max(2, int(n_fans + 1)) # 3 fans -> ~4 people
+ elif n_ac > 0:
+ d["n_occupants"] = max(2, int(n_ac * 1.5))
+ else:
+ d["n_occupants"] = 4 # Kerala average
+
+ # Resolve missing "fan_usage_pattern" based on Hours (Physics-rule)
+ if model_name == "ceiling_fan" and (
+ "fan_usage_pattern" not in d or not d["fan_usage_pattern"]
+ ):
+ hours = self._get_float(
+ d, "ceiling_fan_hours", self._get_float(d, "fan_hours", 8)
+ )
+ if hours >= 15:
+ d["fan_usage_pattern"] = "heavy" # Almost all day
+ elif hours >= 8:
+ d["fan_usage_pattern"] = "moderate" # Night + Evening
+ elif hours >= 4:
+ d["fan_usage_pattern"] = "light" # Evening only
+ else:
+ d["fan_usage_pattern"] = "rarely" # Occasional
+
+ # Resolve fan_type if missing
+ if model_name == "ceiling_fan" and "fan_type" not in d:
+ d["fan_type"] = "standard"
+
+ # 1. AI INFERENCE (The Detective Step) 🕵️♂️
+ if model_name in self.models and self.models[model_name]:
+ # The AI takes a look at the household clues to find the hidden truth.
+ df = pd.DataFrame(data)
+
+ # Define all categorical columns that should NOT be converted to numeric
+ # These are used by the preprocessor's OneHotEncoder
+ categorical_columns = {
+ "ac_type",
+ "ac_usage_pattern",
+ "ac_age_years",
+ "fridge_type",
+ "refrigerator_usage_pattern",
+ "wm_type",
+ "wm_usage_pattern",
+ "location_type",
+ "season",
+ "television_type",
+ "fan_type",
+ "fan_usage_pattern",
+ "led_lights_usage_pattern", # Added fan_type
+ "water_heater_type", # Added water_heater_type
+ "cfl_lights_usage_pattern",
+ "tube_lights_usage_pattern",
+ "television_usage_pattern",
+ "geyser_usage_pattern",
+ "pump_usage_pattern",
+ "mixer_usage_pattern",
+ "microwave_usage_pattern",
+ "kettle_usage_pattern",
+ "induction_usage_pattern",
+ "rice_cooker_usage_pattern",
+ "toaster_usage_pattern",
+ "food_processor_usage_pattern",
+ "hair_dryer_usage_pattern",
+ "vacuum_usage_pattern",
+ "iron_usage_pattern",
+ "desktop_usage_pattern",
+ "laptop_usage_pattern",
+ }
+
+ # Fill safe defaults for transformation - convert only numeric columns
+ for col in df.columns:
+ if col not in categorical_columns:
+ df[col] = pd.to_numeric(df[col], errors="coerce").fillna(0)
+
+ # Add dummy season if missing (for geyser)
+ if "season" not in df.columns:
+ df["season"] = "monsoon"
+
+ # Add default location_type if missing (Model expects it)
+ if "location_type" not in df.columns:
+ df["location_type"] = "urban"
+
+ # Ensure num_fans is present if num_ceiling_fans is
+ if "num_fans" not in df.columns and "num_ceiling_fans" in df.columns:
+ df["num_fans"] = df["num_ceiling_fans"]
+
+ try:
+ X = self.preprocessors[model_name].transform(df)
+
+ # OPTIMIZATION: Use direct call instead of .predict() for single samples
+ # This avoids retracing warnings and is faster for single inputs
+ outputs = self.models[model_name](X, training=False)
+
+ # Unpack Outputs from List of Tensors: [Efficiency, Hours]
+ # Note: outputs[0] is efficiency tensor, outputs[1] is hours tensor
+ ai_efficiency_factor = float(outputs[0].numpy()[0][0])
+ ai_effective_hours = float(outputs[1].numpy()[0][0])
+
+ # --- APPLY LEARNED BIAS ---
+ # Self-Learning Hook: Multiplier from historical learning
+ efficiency_bias = self._get_float(d, "efficiency_bias", 1.0)
+ ai_efficiency_factor *= efficiency_bias
+
+ # Post-Process Inference (Bounds Checking)
+ ai_efficiency_factor = max(0.5, min(ai_efficiency_factor, 1.5))
+ ai_effective_hours = max(0, min(ai_effective_hours, 24.0))
+
+ # --- HYBRID LOGIC (The Safety Net) ---
+ # Sometimes, AI gets over-excited. We rein it in with Physics rules.
+ # For simple things like a Kettle or Iron, "Efficiency" doesn't change much.
+ # So we verify: If it's a simple resistor, force Efficiency to 1.0 (Standard).
+ # We only trust AI for "Usage Hours" in these cases.
+ simple_apps = [
+ "ceiling_fan",
+ "led_lights",
+ "cfl_lights",
+ "tube_lights",
+ "iron",
+ "kettle",
+ "toaster",
+ "microwave",
+ "induction",
+ "rice_cooker",
+ "mixer",
+ "food_processor",
+ "hair_dryer",
+ "vacuum",
+ "fridge",
+ ]
+
+ if model_name in simple_apps:
+ ai_efficiency_factor = 1.0 # Force Base Watts
+
+ if model_name == "fridge":
+ ai_effective_hours = 12.0 # Standardize Duty Cycle to ~50% (Hot Climate / Realistic)
+
+ source = "AI_Inferred_Physics"
+ except Exception as e:
+ # Fallback if transform fails
+ logger.warning(f"Features missing for {name}: {e}")
+ ai_efficiency_factor = 1.0
+ ai_effective_hours = self._get_float(
+ d, f"{name}_hours", self._get_float(d, f"{name}_hours_per_day", 1.0)
+ )
+ source = "Pure_Physics_Fallback"
+ else:
+ # Fallback for appliances without models
+ ai_efficiency_factor = 1.0
+ # Apply bias even to fallback (Global household adjustment)
+ efficiency_bias = self._get_float(d, "efficiency_bias", 1.0)
+ ai_efficiency_factor *= efficiency_bias
+
+ ai_effective_hours = self._get_float(
+ d, f"{name}_hours", self._get_float(d, f"{name}_hours_per_day", 1.0)
+ )
+ source = "Pure_Physics"
+
+ # --- USER OVERRIDE ---
+ # If manual hours are provided in the request, bypass AI inference for hours.
+ keys_to_check = [
+ f"{name}_hours",
+ f"{name}_hours_per_day",
+ f"{name}_usage_hours",
+ f"{name}_usage_hours_per_day",
+ ]
+ user_hours = -1.0
+
+ for k in keys_to_check:
+ val = self._get_float(d, k, -1.0)
+ if val >= 0:
+ user_hours = val
+ break
+
+ # Also check mapped model name keys (e.g. 'ceiling_fan_hours' if name was 'fan')
+ if user_hours < 0 and model_name != name:
+ user_hours = self._get_float(d, f"{model_name}_hours", -1.0)
+
+ # Handle Minutes Inputs (Mixer, Microwave)
+ if user_hours < 0:
+ user_mins = -1
+ if model_name == "mixer":
+ user_mins = self._get_float(
+ d, "mixer_grinder_usage_minutes_per_day", -1
+ )
+ if model_name == "microwave":
+ user_mins = self._get_float(d, "microwave_usage_minutes_per_day", -1)
+
+ if user_mins >= 0:
+ user_hours = user_mins / 60.0
+
+ # Handle WM Cycles
+ if user_hours < 0 and model_name == "washing_machine":
+ cycles = self._get_float(d, "wm_cycles_per_week", -1)
+ if cycles >= 0:
+ user_hours = cycles # We treat cycles as 'hours' for flow variable
+
+ if user_hours > 0:
+ # Hard cap: a day only has 24 hours — clamp any value the frontend or schema missed
+ user_hours = min(24.0, user_hours)
+
+ # SMART DUTY CYCLE: Fridge
+ # User likely inputs "24 hours" (connected time), but compressor runs ~30-50%
+ if model_name == "fridge" and user_hours > 10:
+ ai_effective_hours = (
+ user_hours * 0.5
+ ) # 50% Duty Cycle (Updated for Hot Climate)
+ else:
+ ai_effective_hours = user_hours
+
+ if source == "AI_Inferred_Physics":
+ source = "AI_Efficiency_User_Hours"
+
+ # 2. PHYSICS CALCULATION (The Truth)
+ # Now we do the simple math.
+ # Real Watts = Rated Watts * (How bad is the machine?)
+ # If Efficiency Factor is 1.2, it means the machine is wasting 20% extra power.
+ real_watts = base_watts * ai_efficiency_factor
+
+ # Quantity Multiplier
+ count = 1
+ if model_name == "ceiling_fan":
+ count = self._get_float(
+ d, "num_ceiling_fans", self._get_float(d, "num_fans", 1)
+ )
+ if model_name == "television":
+ count = self._get_float(
+ d, "num_televisions", self._get_float(d, "num_tv", 1)
+ )
+ if model_name == "led_lights":
+ count = self._get_float(
+ d, "num_led_lights", self._get_float(d, "num_led", 1)
+ )
+ if model_name == "cfl_lights":
+ count = self._get_float(
+ d, "num_cfl_bulbs", self._get_float(d, "num_cfl", 1)
+ )
+ if model_name == "tube_lights":
+ count = self._get_float(
+ d, "num_tube_lights", self._get_float(d, "num_tube", 1)
+ )
+
+ kwh = (real_watts * ai_effective_hours * count * 30) / 1000
+
+ # Special Logic for WM (Cycles based)
+ if name == "washing_machine":
+ # For WM, 'real_effective_hours' is actually 'cycles_per_week' approx
+ # Formula: (500W * 1.5h * cycles * 4.3) / 1000
+ kwh = (500 * 1.5 * ai_effective_hours * 4.3) / 1000
+
+ # 3. ANOMALY DETECTION 🚨
+ anomaly = AnomalyEngine.check_anomalies(
+ model_name, ai_efficiency_factor, ai_effective_hours
+ )
+
+ result = {
+ "prediction": float(max(0, kwh)),
+ "insights": {
+ "efficiency_score": round(ai_efficiency_factor, 2),
+ "predicted_hours": round(ai_effective_hours, 1),
+ "base_watts": round(base_watts, 0),
+ "real_watts": round(real_watts, 0),
+ "source": source,
+ "anomaly": anomaly,
+ },
+ }
+
+ # --- DYNAMIC CONFIDENCE SCORING ---
+ # Calculate how confident we are in this specific prediction.
+ # Baseline: 98.2% (The "Golden Standard" for valid Hybrid models)
+ confidence = 98.2
+ model_tag = "Hybrid AI-Physics"
+ acc_tag = "High Accuracy"
+
+ # Penalties based on Source (Where did the math come from?)
+ if source == "Pure_Physics":
+ confidence -= 5.0 # We trust physics, but AI context is missing
+ model_tag = "Pure Physics"
+ acc_tag = "Standard Accuracy"
+ elif source == "Pure_Physics_Fallback":
+ confidence -= 8.0 # We tried AI but failed (missing features), so we fell back. Lower trust.
+ model_tag = "Fallback Physics"
+ acc_tag = "Est. Accuracy"
+
+ # Penalties based on Anomalies (Something weird is happening)
+ if anomaly["status"] == "efficiency_critical":
+ confidence -= (
+ 10.0 # Machine is acting very strange. Prediction might be volatile.
+ )
+ acc_tag = "Low Confidence"
+ elif anomaly["status"] in ["efficiency_warning", "Usage_Anomaly"]:
+ confidence -= 4.0
+
+ # Cap Confidence
+ confidence = max(60.0, min(99.9, confidence))
+
+ # Update Result with Calculated Metrics
+ result["insights"]["confidence_score"] = round(confidence, 1)
+ result["insights"]["model_type"] = model_tag
+ result["insights"]["accuracy_tag"] = acc_tag
+
+ return result
+
+
+def get_predictor():
+ return AppliancePredictor()
diff --git a/range_resolver.py b/range_resolver.py
new file mode 100644
index 0000000000000000000000000000000000000000..19d1a39debf9a4c3eafd7c441471efd734377760
--- /dev/null
+++ b/range_resolver.py
@@ -0,0 +1,469 @@
+"""
+AI-Based Dynamic Range Resolver
+Intelligently selects specific values within ranges based on user context
+Instead of fixed averages, uses predictive logic to choose optimal values
+"""
+
+from typing import Dict, Optional, Tuple
+
+import numpy as np
+
+
+class RangeResolver:
+ """
+ Resolves range-based values (e.g., "3-5" years) to specific values
+ based on contextual factors like usage patterns, location, season, etc.
+ """
+
+ @staticmethod
+ def parse_range(value: str) -> Tuple[Optional[float], Optional[float]]:
+ """
+ Parse range strings into (min, max) tuples
+ Examples:
+ "3-5" → (3.0, 5.0)
+ "10+" → (10.0, None)
+ "<1" → (None, 1.0)
+ "5" → (5.0, 5.0)
+ """
+ value = str(value).strip()
+
+ # Handle ranges: "3-5"
+ if "-" in value and not value.startswith("<"):
+ parts = value.split("-")
+ try:
+ min_val = float(parts[0].strip())
+ max_val = float(parts[1].strip())
+ return (min_val, max_val)
+ except:
+ return (None, None)
+
+ # Handle "10+" format
+ elif "+" in value:
+ try:
+ base = float(value.replace("+", "").strip())
+ return (base, None) # Open-ended range
+ except:
+ return (None, None)
+
+ # Handle "<1" format
+ elif "<" in value:
+ try:
+ max_val = float(value.replace("<", "").strip())
+ return (None, max_val)
+ except:
+ return (None, None)
+
+ # Single value
+ else:
+ try:
+ val = float(value)
+ return (val, val)
+ except:
+ return (None, None)
+
+ @staticmethod
+ def resolve_geyser_age(age_str: str, context: Dict) -> float:
+ """Dynamically resolve water heater/geyser age"""
+ min_age, max_age = RangeResolver.parse_range(age_str)
+
+ if min_age is None and max_age is None:
+ return 3.0
+ if min_age is not None and max_age is not None and min_age == max_age:
+ return min_age
+ if max_age is None:
+ return min_age + 2.0
+ if min_age is None:
+ return max_age * 0.5
+
+ bias_score = 0.5
+
+ # Usage pattern (40% weight)
+ usage_pattern = context.get("geyser_usage_pattern", "light")
+ usage_weight = {"minimal": 0.2, "light": 0.4, "moderate": 0.6, "heavy": 0.8}
+ bias_score += (usage_weight.get(usage_pattern, 0.5) - 0.5) * 0.4
+
+ # Season (25% weight)
+ season = context.get("season", "monsoon")
+ if season == "winter":
+ bias_score += 0.15 # More usage in winter
+ elif season == "summer":
+ bias_score -= 0.1 # Less usage in summer
+
+ # Occupants (20% weight)
+ occupants = context.get("n_occupants", 4)
+ if occupants >= 6:
+ bias_score += 0.1
+ elif occupants <= 2:
+ bias_score -= 0.05
+
+ # Type (15% weight)
+ geyser_type = context.get("water_heater_type", "storage")
+ if geyser_type == "instant":
+ bias_score += 0.05 # More complex, more wear
+
+ bias_score = max(0.0, min(1.0, bias_score))
+ resolved_age = min_age + (max_age - min_age) * bias_score
+
+ logger.info(
+ f"🧠 AI Range Resolver (geyser_age): '{age_str}' → {resolved_age:.2f} years (bias: {bias_score:.2f})"
+ )
+ return round(resolved_age, 2)
+
+ @staticmethod
+ def resolve_fridge_age(age_str: str, context: Dict) -> float:
+ """
+ Dynamically resolve fridge age based on usage context
+
+ Logic:
+ - Heavy usage + urban + summer → closer to max (more wear)
+ - Light usage + rural + winter → closer to min (less wear)
+ - Consider occupants (more people = more wear)
+ """
+ min_age, max_age = RangeResolver.parse_range(age_str)
+
+ # Handle edge cases
+ if min_age is None and max_age is None:
+ return 3.0 # Default fallback
+
+ if min_age is not None and max_age is not None and min_age == max_age:
+ return min_age # Single value, no range
+
+ # Handle open-ended ranges
+ if max_age is None: # "10+"
+ return min_age + 2.0 # Default: 10+ → 12
+
+ if min_age is None: # "<1"
+ return max_age * 0.5 # Default: <1 → 0.5
+
+ # Calculate bias factors (0.0 to 1.0, where 1.0 = max wear)
+ bias_score = 0.5 # Start neutral
+
+ # Factor 1: Usage pattern (30% weight)
+ usage_pattern = context.get("refrigerator_usage_pattern", "normal")
+ usage_weight = {
+ "manual": 0.2, # Low wear (not always on)
+ "light": 0.35, # Below average
+ "normal": 0.5, # Average
+ "always": 0.8, # High wear (always running)
+ }
+ bias_score += (usage_weight.get(usage_pattern, 0.5) - 0.5) * 0.3
+
+ # Factor 2: Location (20% weight)
+ location = context.get("location_type", "urban")
+ if location == "urban":
+ bias_score += 0.1 # Urban = more power fluctuations, more wear
+ else:
+ bias_score -= 0.05 # Rural = more stable, less wear
+
+ # Factor 3: Season (20% weight)
+ season = context.get("season", "monsoon")
+ season_weight = {
+ "summer": 0.15, # High wear (compressor works harder)
+ "monsoon": 0.0, # Neutral
+ "winter": -0.1, # Low wear (easier cooling)
+ }
+ bias_score += season_weight.get(season, 0.0)
+
+ # Factor 4: Occupants (15% weight)
+ occupants = context.get("n_occupants", 4)
+ if occupants >= 6:
+ bias_score += 0.1 # More people = more door openings
+ elif occupants <= 2:
+ bias_score -= 0.05 # Fewer people = less usage
+
+ # Factor 5: Fridge type (15% weight)
+ fridge_type = context.get("fridge_type", "frost_free")
+ if fridge_type == "frost_free":
+ bias_score += 0.05 # More complex, more wear
+ elif fridge_type == "direct_cool":
+ bias_score -= 0.05 # Simpler, less wear
+
+ # Clamp bias score to [0.0, 1.0]
+ bias_score = max(0.0, min(1.0, bias_score))
+
+ # Calculate final age using bias
+ # bias=0.0 → min_age, bias=1.0 → max_age, bias=0.5 → average
+ resolved_age = min_age + (max_age - min_age) * bias_score
+
+ # Log for debugging
+ logger.info(
+ f"🧠 AI Range Resolver: '{age_str}' → {resolved_age:.2f} years (bias: {bias_score:.2f})"
+ )
+
+ return round(resolved_age, 2)
+
+ @staticmethod
+ def resolve_generic_range(value_str: str, field_name: str, context: Dict) -> float:
+ """
+ Generic range resolver for any numeric field
+ Uses simpler heuristics when specific logic not available
+ """
+ min_val, max_val = RangeResolver.parse_range(value_str)
+
+ # Handle edge cases
+ if min_val is None and max_val is None:
+ return 0.0 # Default fallback
+
+ if min_val is not None and max_val is not None and min_val == max_val:
+ return min_val
+
+ # Handle open-ended ranges
+ if max_val is None: # "10+"
+ return min_val + 2.0
+
+ if min_val is None: # "<1"
+ return max_val * 0.5
+
+ # Use simple bias based on general factors
+ bias_score = 0.5
+
+ # Higher usage → closer to max
+ usage_keys = [k for k in context.keys() if "usage" in k or "pattern" in k]
+ for key in usage_keys:
+ val = str(context.get(key, "")).lower()
+ if "heavy" in val or "always" in val or "high" in val:
+ bias_score += 0.1
+ elif "light" in val or "minimal" in val or "low" in val:
+ bias_score -= 0.1
+
+ # More occupants → closer to max (more usage)
+ occupants = context.get("n_occupants", 4)
+ if occupants >= 6:
+ bias_score += 0.05
+ elif occupants <= 2:
+ bias_score -= 0.05
+
+ # Clamp and calculate
+ bias_score = max(0.0, min(1.0, bias_score))
+ resolved_val = min_val + (max_val - min_val) * bias_score
+
+ logger.info(
+ f"🧠 AI Range Resolver ({field_name}): '{value_str}' → {resolved_val:.2f} (bias: {bias_score:.2f})"
+ )
+
+ return round(resolved_val, 2)
+
+
+# Import logger after class definition
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def resolve_range_values(data: Dict) -> Dict:
+ """
+ Main entry point: Automatically resolves all range-based values in input data
+ """
+ resolved_data = data.copy()
+ resolver = RangeResolver()
+
+ # AC age (uses training column name: ac_age_years)
+ if "ac_age_years" in resolved_data:
+ age_val = resolved_data["ac_age_years"]
+ if isinstance(age_val, str) and (
+ "-" in age_val or "+" in age_val or "<" in age_val
+ ):
+ # Resolve AC age based on usage context
+ min_age, max_age = resolver.parse_range(age_val)
+ if min_age is not None or max_age is not None:
+ bias = 0.5
+ usage = data.get("ac_usage_pattern", "moderate")
+ if usage in ["heavy", "long"]:
+ bias += 0.3
+ elif usage in ["rare", "short"]:
+ bias -= 0.2
+ if data.get("season") == "summer":
+ bias += 0.1
+ if data.get("n_occupants", 4) >= 6:
+ bias += 0.1
+ bias = max(0.0, min(1.0, bias))
+
+ if max_age is None:
+ resolved_age = min_age + 2.0
+ elif min_age is None:
+ resolved_age = max_age * 0.5
+ else:
+ resolved_age = min_age + (max_age - min_age) * bias
+
+ resolved_data["ac_age_years"] = round(resolved_age, 2)
+ logger.info(
+ f"🧠 AI Range Resolver (ac_age_years): '{age_val}' → {resolved_age:.2f} years (bias: {bias:.2f})"
+ )
+
+ # Fridge age (uses training column name: fridge_age)
+ if "fridge_age" in resolved_data:
+ age_val = resolved_data["fridge_age"]
+ if isinstance(age_val, str) and (
+ "-" in age_val or "+" in age_val or "<" in age_val
+ ):
+ resolved_data["fridge_age"] = resolver.resolve_fridge_age(age_val, data)
+
+ # Geyser/Water heater age
+ if "water_heater_age" in resolved_data:
+ age_val = resolved_data["water_heater_age"]
+ if isinstance(age_val, str) and (
+ "-" in age_val or "+" in age_val or "<" in age_val
+ ):
+ resolved_data["water_heater_age"] = resolver.resolve_geyser_age(
+ age_val, data
+ )
+
+ # Fridge capacity (300L+)
+ if "fridge_capacity" in resolved_data:
+ val = resolved_data["fridge_capacity"]
+ if isinstance(val, str):
+ # Extract numeric value first
+ import re
+
+ match = re.match(r"(\d+)", val)
+ if match and "+" in val:
+ # Has + symbol, apply AI resolution
+ min_val = float(match.group(1))
+ occupants = data.get("n_occupants", 4)
+ usage = data.get("refrigerator_usage_pattern", "normal")
+ bias = 0.5
+ if occupants >= 6:
+ bias += 0.2
+ elif occupants <= 2:
+ bias -= 0.1
+ if usage == "always":
+ bias += 0.1
+ bias = max(0.0, min(1.0, bias))
+ resolved_data["fridge_capacity"] = min_val + (100 * bias)
+ logger.info(
+ f"🧠 AI Range Resolver (fridge_capacity): '{val}' → {resolved_data['fridge_capacity']:.0f}L (bias: {bias:.2f})"
+ )
+ elif match:
+ # Just a number with unit, extract it
+ resolved_data["fridge_capacity"] = float(match.group(1))
+
+ # WM capacity (8.0 kg+)
+ if "wm_capacity" in resolved_data:
+ val = resolved_data["wm_capacity"]
+ if isinstance(val, str):
+ import re
+
+ match = re.match(r"(\d+\.?\d*)", val)
+ if match and "+" in val:
+ min_val = float(match.group(1))
+ occupants = data.get("n_occupants", 4)
+ cycles = data.get("wm_cycles_per_week", 5)
+ bias = 0.5
+ if occupants >= 6:
+ bias += 0.2
+ if cycles >= 7:
+ bias += 0.15
+ bias = max(0.0, min(1.0, bias))
+ resolved_data["wm_capacity"] = min_val + (2.0 * bias)
+ logger.info(
+ f"🧠 AI Range Resolver (wm_capacity): '{val}' → {resolved_data['wm_capacity']:.1f}kg (bias: {bias:.2f})"
+ )
+ elif match:
+ resolved_data["wm_capacity"] = float(match.group(1))
+
+ # Geyser capacity (25L+)
+ if "water_heater_capacity" in resolved_data:
+ val = resolved_data["water_heater_capacity"]
+ if isinstance(val, str):
+ import re
+
+ match = re.match(r"(\d+)", val)
+ if match and "+" in val:
+ min_val = float(match.group(1))
+ occupants = data.get("n_occupants", 4)
+ usage = data.get("geyser_usage_pattern", "light")
+ bias = 0.5
+ if occupants >= 6:
+ bias += 0.2
+ if usage == "heavy":
+ bias += 0.15
+ bias = max(0.0, min(1.0, bias))
+ resolved_data["water_heater_capacity"] = min_val + (10 * bias)
+ logger.info(
+ f"🧠 AI Range Resolver (water_heater_capacity): '{val}' → {resolved_data['water_heater_capacity']:.0f}L (bias: {bias:.2f})"
+ )
+ elif match:
+ resolved_data["water_heater_capacity"] = float(match.group(1))
+
+ return resolved_data
+
+
+if __name__ == "__main__":
+ # Test the resolver
+ print("\n" + "=" * 80)
+ print("🧪 TESTING AI-BASED RANGE RESOLVER")
+ print("=" * 80)
+
+ # Test Case 1: Heavy usage scenario
+ print("\n1️⃣ Heavy Usage Scenario (should bias toward MAX)")
+ print("-" * 80)
+ heavy_context = {
+ "fridge_age": "3-5", # Using training column name
+ "n_occupants": 7,
+ "location_type": "urban",
+ "season": "summer",
+ "refrigerator_usage_pattern": "always",
+ "fridge_type": "frost_free",
+ }
+ resolved = resolve_range_values(heavy_context)
+ print(f"Input: {heavy_context['fridge_age']}")
+ print(f"Output: {resolved['fridge_age']} years")
+ print(f"Expected: Closer to 5.0 (heavy usage)")
+
+ # Test Case 2: Light usage scenario
+ print("\n2️⃣ Light Usage Scenario (should bias toward MIN)")
+ print("-" * 80)
+ light_context = {
+ "fridge_age": "3-5",
+ "n_occupants": 2,
+ "location_type": "rural",
+ "season": "winter",
+ "refrigerator_usage_pattern": "light",
+ "fridge_type": "direct_cool",
+ }
+ resolved = resolve_range_values(light_context)
+ print(f"Input: {light_context['fridge_age']}")
+ print(f"Output: {resolved['fridge_age']} years")
+ print(f"Expected: Closer to 3.0 (light usage)")
+
+ # Test Case 3: Neutral scenario
+ print("\n3️⃣ Neutral Scenario (should be near AVERAGE)")
+ print("-" * 80)
+ neutral_context = {
+ "fridge_age": "3-5",
+ "n_occupants": 4,
+ "location_type": "urban",
+ "season": "monsoon",
+ "refrigerator_usage_pattern": "normal",
+ "fridge_type": "frost_free",
+ }
+ resolved = resolve_range_values(neutral_context)
+ print(f"Input: {neutral_context['fridge_age']}")
+ print(f"Output: {resolved['fridge_age']} years")
+ print(f"Expected: Close to 4.0 (average)")
+
+ # Test Case 4: Edge cases
+ print("\n4️⃣ Edge Cases")
+ print("-" * 80)
+ edge_cases = [
+ ("10+", "Open-ended range"),
+ ("<1", "Less than range"),
+ ("1-3", "Different range"),
+ ("5", "Single value"),
+ ]
+
+ for age_str, description in edge_cases:
+ test_context = {
+ "fridge_age": age_str,
+ "n_occupants": 4,
+ "refrigerator_usage_pattern": "normal",
+ }
+ resolved = resolve_range_values(test_context)
+ resolved_val = resolved["fridge_age"]
+ if isinstance(resolved_val, str):
+ resolved_val = float(resolved_val)
+ print(f"{age_str:6s} ({description:20s}) → {resolved_val:.2f} years")
+
+ print("\n" + "=" * 80)
+ print("✅ RANGE RESOLVER TEST COMPLETE")
+ print("=" * 80)
diff --git a/render.yaml b/render.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..450f78fa3e27897b675e922bc360e42a15622671
--- /dev/null
+++ b/render.yaml
@@ -0,0 +1,14 @@
+services:
+ - type: web
+ name: smartwatt-backend
+ env: python
+ runtime: python
+ buildCommand: pip install --upgrade pip && pip install -r requirements.txt
+ startCommand: uvicorn main:app --host 0.0.0.0 --port $PORT
+ envVars:
+ - key: PYTHON_VERSION
+ value: 3.11.11
+ - key: SUPABASE_URL
+ sync: false
+ - key: SUPABASE_KEY
+ sync: false
diff --git a/requirements-test.txt b/requirements-test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e82c7679a43db037289027823da445577f7daeea
--- /dev/null
+++ b/requirements-test.txt
@@ -0,0 +1,4 @@
+pytest
+httpx
+requests
+matplotlib
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f520d4411131dd750baca11aab5cdb53a23f52c6
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,11 @@
+fastapi==0.110.0
+uvicorn==0.27.1
+pydantic==2.6.4
+pandas==2.2.3
+numpy==1.26.4
+scikit-learn==1.7.2
+tensorflow==2.16.1
+joblib==1.3.2
+supabase==2.4.0
+python-dotenv==1.0.1
+schedule==1.2.0
diff --git a/routers/appliances.py b/routers/appliances.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f7239db90711a6f280911cb2b64f837cd37a154
--- /dev/null
+++ b/routers/appliances.py
@@ -0,0 +1,444 @@
+import concurrent.futures
+import json
+from datetime import datetime
+from typing import Any, Dict, List, Union
+
+from fastapi import APIRouter, HTTPException
+# Import Core Logic and Schemas
+from predictor import get_predictor
+from pydantic import BaseModel, Field
+from schemas import (MODEL_MAPPING, ACInput, BaseApplianceInput,
+ CeilingFanInput, FridgeInput, KitchenApplianceInput,
+ LightingInput, TelevisionInput, WashingMachineInput,
+ WaterHeaterInput, WaterPumpInput)
+
+router = APIRouter()
+predictor = get_predictor()
+
+from simulation_service import SimulationService
+
+
+# --- DEBUG LOGGER ---
+def log_user_input(appliance_name: str, details: Dict, total_bill: float):
+ """Log all user inputs for debugging"""
+ timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+ log_entry = {
+ "timestamp": timestamp,
+ "appliance": appliance_name,
+ "total_bill": total_bill,
+ "inputs": details,
+ }
+
+ # Print to console with clear formatting
+ print("\n" + "=" * 80)
+ print(f"🔍 DEBUG: USER INPUT CAPTURED at {timestamp}")
+ print("=" * 80)
+ print(f"📱 Appliance: {appliance_name}")
+ print(f"💰 Total Bill: {total_bill} kWh")
+ print(f"📝 Input Details:")
+ for key, value in details.items():
+ print(f" • {key}: {value}")
+ print("=" * 80 + "\n")
+
+ # Also write to file for persistent logging
+ try:
+ with open("user_inputs_debug.log", "a", encoding="utf-8") as f:
+ f.write(json.dumps(log_entry, indent=2) + "\n")
+ except Exception as e:
+ print(f"Warning: Could not write to log file: {e}")
+
+
+# --- PYDANTIC MODELS FOR API REQUEST ---
+
+
+class ApplianceRequest(BaseModel):
+ appliance_name: str
+ # We accept a Dict first, then validate it dynamically based on name
+ details: Dict[str, Any]
+ total_bill: float = Field(
+ ..., ge=0, description="Total bill amount cannot be negative"
+ )
+
+ def validate_details(self):
+ """Dynamic validation based on appliance name"""
+ key = self.appliance_name.lower().replace(" ", "_")
+ if key == "air_conditioner":
+ key = "ac"
+ if key == "refrigerator":
+ key = "fridge"
+
+ ModelClass = MODEL_MAPPING.get(key, BaseApplianceInput)
+
+ # We try to strict validate. If it fails, Pydantic raises error.
+ # This ensures we don't pass garbage to the AI.
+ return ModelClass(**self.details)
+
+
+class BatchApplianceRequest(BaseModel):
+ requests: List[ApplianceRequest]
+
+
+class SimulationRequest(BaseModel):
+ details: Dict[str, Any]
+ total_bill: float
+
+
+# Field mapper: Schema field names → Training column names
+def map_schema_to_training_columns(details: Dict) -> Dict:
+ """Convert API schema field names to training dataset column names"""
+ field_mapping = {
+ # Fridge
+ "fridge_capacity_liters": "fridge_capacity",
+ "fridge_age_years": "fridge_age",
+ "fridge_hours_per_day": "fridge_hours",
+ # Washing Machine
+ "wm_capacity_kg": "wm_capacity",
+ # Water Heater
+ "water_heater_capacity_liters": "water_heater_capacity",
+ "water_heater_usage_hours": "water_heater_hours",
+ # AC
+ "ac_hours_per_day": "ac_hours",
+ # Fan
+ "num_ceiling_fans": "num_fans",
+ "fan_hours_per_day": "fan_hours",
+ # TV
+ "tv_size_inches": "tv_size",
+ "num_televisions": "num_tv",
+ "tv_hours_per_day": "tv_hours",
+ "television_hours": "tv_hours",
+ # Water Pump
+ "water_pump_usage_hours_per_day": "water_pump_hours",
+ # Usage Patterns (Frontend sends *_pattern, Model needs *_usage_pattern)
+ "fan_pattern": "fan_usage_pattern",
+ "ac_pattern": "ac_usage_pattern",
+ "fridge_pattern": "refrigerator_usage_pattern",
+ "tv_pattern": "television_usage_pattern",
+ "wm_pattern": "wm_usage_pattern",
+ "geyser_pattern": "geyser_usage_pattern",
+ "led_pattern": "led_lights_usage_pattern",
+ "cfl_pattern": "cfl_lights_usage_pattern",
+ "tube_pattern": "tube_lights_usage_pattern",
+ "pump_pattern": "pump_usage_pattern",
+ "mixer_pattern": "mixer_usage_pattern",
+ "microwave_pattern": "microwave_usage_pattern",
+ "kettle_pattern": "kettle_usage_pattern",
+ "induction_pattern": "induction_usage_pattern",
+ "rice_cooker_pattern": "rice_cooker_usage_pattern",
+ "toaster_pattern": "toaster_usage_pattern",
+ "food_processor_pattern": "food_processor_usage_pattern",
+ "iron_pattern": "iron_usage_pattern",
+ "desktop_pattern": "desktop_usage_pattern",
+ "laptop_pattern": "laptop_usage_pattern",
+ }
+
+ mapped_data = {}
+ for key, value in details.items():
+ # Use mapped name if exists, otherwise keep original
+ mapped_key = field_mapping.get(key, key)
+ mapped_data[mapped_key] = value
+
+ return mapped_data
+
+
+# Helper to bridge API requests to the AI Engine
+def call_model(name: str, details: Dict, bill_total: float):
+ # Map schema field names to training column names
+ mapped_details = map_schema_to_training_columns(details)
+ mapped_details["total_kwh_monthly"] = bill_total
+
+ # 🧠 Apply AI-based range resolution AFTER field mapping
+ # This ensures resolved values use correct column names
+ from range_resolver import resolve_range_values
+
+ mapped_details = resolve_range_values(mapped_details)
+
+ return predictor.predict(name, [mapped_details])
+
+
+@router.post("/predict-appliance")
+def predict_usage(req: ApplianceRequest):
+ """Runs the specific Neural Network for an appliance"""
+ try:
+ # 🔍 DEBUG: Log all user inputs
+ log_user_input(req.appliance_name, req.details, req.total_bill)
+
+ # 1. Enforce Strict Type Safety via Pydantic
+ # This will raise an Exception if fields are missing (e.g. ac_tonnage)
+ validated_model = req.validate_details()
+
+ # 2. Convert back to dict for the legacy AI predictor (or update predictor to accept models later)
+ # We trust the data now.
+ # CRITICAL FIX: exclude_none=True prevents optional fields (like ac_hours=None)
+ # from conflicting with mapped fields (like ac_hours_per_day -> ac_hours) during conversion.
+ validated_data = validated_model.model_dump(exclude_none=True)
+
+ # Standardize key (handle 'air_conditioner' vs 'ac')
+ key = req.appliance_name.lower().replace(" ", "_")
+ if key == "air_conditioner":
+ key = "ac"
+ if key == "refrigerator":
+ key = "fridge"
+
+ # Call Logic
+ result = call_model(key, validated_data, req.total_bill)
+
+ # Check source for debugging
+ source = result.get("insights", {}).get("source", "Unknown")
+ predicted_hours = result.get("insights", {}).get("predicted_hours", 0)
+ predicted_kwh = result.get("prediction", 0)
+
+ # Enhanced debug output
+ print(f"✅ Predicted {key}:")
+ print(f" Source: {source}")
+ print(f" Hours: {predicted_hours}h")
+ print(f" kWh: {predicted_kwh:.2f}")
+
+ return {
+ "status": "success",
+ "prediction": result["prediction"],
+ "insights": result["insights"],
+ }
+
+ except Exception as e:
+ print(f"Error predicting {req.appliance_name}: {e}")
+ # Return error details if validation failed, so frontend devs know what's wrong
+ if "validation error" in str(e).lower():
+ return {"status": "error", "message": str(e), "prediction": 0.0}
+
+ # Fallback to safe value only for non-validation errors
+ return {"status": "fallback", "prediction": 15.0}
+
+
+@router.post("/simulate-savings")
+def simulate_savings(req: SimulationRequest):
+ """
+ This is the "Time Machine".
+ It asks the AI: "What if I changed X?"
+ For example: "What if I threw away my 10-year old fridge and bought a new one?"
+ The AI re-runs the simulation and tells you how much money you'd save.
+ """
+
+ # Define a simple callback wrapper for call_model
+ def model_predictor(name, details, bill):
+ return call_model(name, details, bill)
+
+ try:
+ insights = SimulationService.run_simulation(
+ req.details, req.total_bill, model_predictor
+ )
+ return {"status": "success", "insights": insights}
+
+ except Exception as e:
+ print(f"Simulation Error: {e}")
+ return {"status": "error", "message": str(e), "insights": []}
+
+
+@router.post("/predict-all")
+def predict_all(batch: BatchApplianceRequest):
+ """
+ Clean single-batch prediction endpoint.
+
+ Golden Rule: One request → One batch → One prediction → One learning step
+ """
+ from services import (BatchPredictor, BiasAdjuster, InputNormalizer,
+ LearningPipeline)
+ from utils.prediction_logger import PredictionLogger
+
+ try:
+ # ========================================
+ # STEP 1: NORMALIZE INPUTS (ONCE)
+ # ========================================
+ # Extract user context and appliance inputs
+ batch_data = {
+ "total_kwh_monthly": batch.requests[0].total_bill if batch.requests else 0,
+ "n_occupants": (
+ batch.requests[0].details.get("num_people", 3) if batch.requests else 3
+ ),
+ "season": (
+ batch.requests[0].details.get("season", "monsoon")
+ if batch.requests
+ else "monsoon"
+ ),
+ "location_type": (
+ batch.requests[0].details.get("location_type", "urban")
+ if batch.requests
+ else "urban"
+ ),
+ "requests": [
+ {"appliance_name": r.appliance_name, "details": r.details}
+ for r in batch.requests
+ ],
+ }
+
+ normalized = InputNormalizer.normalize_batch_request(batch_data)
+ user_context = normalized["user_context"]
+ appliance_inputs = normalized["appliance_inputs"]
+
+ # Log header
+ PredictionLogger.log_header(user_context, len(appliance_inputs))
+
+ # ========================================
+ # STEP 2: BATCH PREDICTION (SINGLE LOOP)
+ # ========================================
+ batch_predictor = BatchPredictor(predictor)
+
+ # Validate inputs first
+ validated_inputs = {}
+ for appliance_name, inputs in appliance_inputs.items():
+ try:
+ # Find matching request for validation
+ matching_req = next(
+ (r for r in batch.requests if r.appliance_name == appliance_name),
+ None,
+ )
+ if matching_req:
+ validated_model = matching_req.validate_details()
+ validated_data = validated_model.model_dump(exclude_none=True)
+
+ # Apply field mapping
+ mapped_data = map_schema_to_training_columns(validated_data)
+
+ # Apply range resolution
+ from range_resolver import resolve_range_values
+
+ mapped_data = resolve_range_values(mapped_data)
+
+ validated_inputs[appliance_name] = mapped_data
+ except Exception as e:
+ print(f"Validation error for {appliance_name}: {e}")
+ validated_inputs[appliance_name] = inputs.copy()
+
+ # Run batch prediction
+ results_list = batch_predictor.predict_batch(user_context, validated_inputs)
+
+ # ========================================
+ # STEP 3: APPLY EFFICIENCY BIAS (ONCE)
+ # ========================================
+ user_id = "default" # Extract from auth if available
+ results_list, bias_applied = BiasAdjuster.apply_bias_to_results(
+ results_list, user_id
+ )
+
+ # ========================================
+ # STEP 3.5: LOG USER INPUTS (ONCE)
+ # ========================================
+ print("\n" + "=" * 60)
+ print("USER INPUTS CAPTURED")
+ print("=" * 60)
+ for req in batch.requests:
+ print(f"\n{req.appliance_name.upper()}:")
+ for key, value in req.details.items():
+ print(f" • {key}: {value}")
+ print("=" * 60 + "\n")
+
+ # ========================================
+ # STEP 4: CALCULATE TOTALS WITH SMART BALANCING
+ # ========================================
+ from services import SystemLoadBalancer
+
+ predicted_total_before_bias = batch_predictor.calculate_total_kwh(results_list)
+ actual_kwh = user_context["total_kwh_monthly"]
+
+ # Use smart system load balancer
+ # This caps system load at 15% and redistributes excess proportionally
+ system_load, results_list, balancing_info = (
+ SystemLoadBalancer.calculate_balanced_load(
+ actual_kwh=actual_kwh,
+ predicted_total=predicted_total_before_bias,
+ results_list=results_list,
+ )
+ )
+
+ # Recalculate total after redistribution
+ predicted_total = batch_predictor.calculate_total_kwh(results_list)
+
+ # Log balancing details if redistribution occurred
+ if balancing_info["redistribution_applied"]:
+ print(f"\n🔧 SYSTEM LOAD BALANCING APPLIED:")
+ print(
+ f" Raw System Load: {balancing_info['raw_system_load']:.2f} kWh ({balancing_info['raw_percentage']:.1f}%)"
+ )
+ print(
+ f" Capped At: {system_load:.2f} kWh ({balancing_info['capped_percentage']:.1f}%)"
+ )
+ print(
+ f" Excess Redistributed: {balancing_info['excess_redistributed']:.2f} kWh"
+ )
+ print(f" Redistribution:")
+ for app, amount in balancing_info.get("redistribution_details", {}).items():
+ print(f" • {app}: +{amount:.2f} kWh")
+ print()
+
+ # ========================================
+ # STEP 5: LEARNING PIPELINE (ONCE)
+ # ========================================
+ learning_result = None
+ if LearningPipeline.should_trigger_learning(actual_kwh):
+ learning_result = LearningPipeline.learn_from_gap(
+ user_id=user_id,
+ actual_kwh=actual_kwh,
+ predicted_total=predicted_total,
+ current_bias=bias_applied,
+ )
+
+ # ========================================
+ # STEP 6: CLEAN LOGGING
+ # ========================================
+ system_load_explanation = SystemLoadBalancer.get_system_load_explanation(
+ balancing_info["capped_percentage"],
+ user_context.get("location_type", "urban"),
+ )
+ PredictionLogger.log_results(results_list, system_load)
+ print(f"\n💡 System Load: {system_load_explanation}")
+ PredictionLogger.log_footer(
+ predicted_total + system_load, bias_applied, learning_result
+ )
+
+ # ========================================
+ # STEP 7: FORMAT RESPONSE (FREEZE SYSTEM LOAD)
+ # ========================================
+ # ⚠️ CRITICAL: System load is now FROZEN - never recalculate
+ final_system_load = system_load
+ final_total = predicted_total + final_system_load
+
+ # Convert results list to dict format for API response
+ results_dict = {}
+ for r in results_list:
+ results_dict[r["appliance"]] = {
+ "status": "success",
+ "prediction": r["kwh"],
+ "insights": r["insights"],
+ }
+
+ # Add system load as virtual appliance with FROZEN value
+ results_dict["system_load"] = {
+ "status": "success",
+ "prediction": final_system_load, # ⚠️ FROZEN VALUE - DO NOT RECALCULATE
+ "insights": {
+ "source": "System & Unaccounted Load",
+ "description": system_load_explanation,
+ "percentage": balancing_info["capped_percentage"],
+ "is_balanced": balancing_info["redistribution_applied"],
+ "frozen": True, # Flag to prevent downstream recalculation
+ },
+ }
+
+ # Add metadata for comprehensive response
+ results_dict["_metadata"] = {
+ "total_kwh": final_total,
+ "predicted_total": predicted_total,
+ "system_load_kwh": final_system_load, # ⚠️ OFFICIAL FROZEN VALUE
+ "system_load_percentage": balancing_info["capped_percentage"],
+ "bias_applied": bias_applied,
+ "location_type": user_context.get("location_type", "urban"),
+ "balancing_applied": balancing_info["redistribution_applied"],
+ }
+
+ return results_dict
+
+ except Exception as e:
+ print(f"❌ Batch Prediction Error: {e}")
+ import traceback
+
+ traceback.print_exc()
+ return {}
diff --git a/schemas.py b/schemas.py
new file mode 100644
index 0000000000000000000000000000000000000000..21b38393f80f634237f18097d90a4979d213d703
--- /dev/null
+++ b/schemas.py
@@ -0,0 +1,220 @@
+from typing import Literal, Optional, Union
+
+from pydantic import BaseModel, Field, validator
+
+
+# --- Base Models ---
+class BaseApplianceInput(BaseModel):
+ season: str = Field(
+ "monsoon",
+ description="Current season (summer, monsoon, winter)",
+ pattern="^(summer|monsoon|winter)$",
+ )
+ location_type: str = Field(
+ "urban", description="Location type (urban, rural)", pattern="^(urban|rural)$"
+ )
+ n_occupants: int = Field(
+ 4, ge=1, le=10, description="Number of people in the household"
+ )
+
+
+# --- Specific Appliance Models ---
+
+
+class ACInput(BaseApplianceInput):
+ ac_tonnage: float = Field(..., ge=0.5, le=5.0)
+ ac_star_rating: int = Field(..., ge=1, le=5)
+ num_ac_units: int = Field(1, ge=1)
+ ac_type: str = Field(..., pattern="^(split|window|inverter)$")
+ ac_age_years: str = Field("unknown", description="Age of AC unit")
+ ac_usage_pattern: str = Field(
+ "moderate", pattern="^(heavy|moderate|light|rare|short|long|night)$"
+ )
+ ac_hours_per_day: float = Field(..., ge=0, le=24)
+ ac_hours: Optional[float] = Field(None, ge=0, le=24) # Explicit override
+
+
+class FridgeInput(BaseApplianceInput):
+ fridge_capacity_liters: float = Field(..., ge=50, le=1000)
+ fridge_age_years: Union[float, str] = Field(
+ ..., description="Age in years (numeric) or range (e.g., '3-5', '10+', '<1')"
+ )
+ fridge_star_rating: int = Field(..., ge=1, le=5)
+ fridge_type: Literal["frost_free", "direct_cool", "side_by_side"]
+ refrigerator_usage_pattern: Literal["manual", "light", "normal", "always"] = (
+ "always"
+ )
+ fridge_hours: Optional[float] = Field(None, ge=0, le=24) # Explicit override
+
+
+class WashingMachineInput(BaseApplianceInput):
+ wm_capacity_kg: float = Field(..., ge=2, le=20)
+ wm_star_rating: int = Field(..., ge=1, le=5)
+ wm_type: Literal["top_load", "front_load", "semi_automatic"]
+ wm_cycles_per_week: float = Field(..., ge=0, le=50)
+ washing_machine_hours: Optional[float] = Field(
+ None, ge=0, le=24
+ ) # Explicit override
+
+
+class CeilingFanInput(BaseApplianceInput):
+ num_ceiling_fans: int = Field(..., ge=1)
+ fan_type: Optional[Literal["standard", "bldc", "high_speed"]] = "standard"
+ fan_usage_pattern: Literal["rarely", "few", "most", "all"] = "most"
+ ceiling_fan_hours: Optional[float] = Field(None, ge=0, le=24) # Explicit override
+
+
+class LightingInput(BaseApplianceInput):
+ count: Optional[int] = Field(None, ge=1, alias="num_units")
+
+ # Pattern fields
+ num_led_lights: Optional[int] = None
+ led_lights_usage_pattern: Optional[
+ Literal["evening", "morning_evening", "most", "all"]
+ ] = "evening"
+ led_lights_hours: Optional[float] = Field(None, ge=0, le=24) # Explicit override
+
+ num_cfl_bulbs: Optional[int] = None
+ cfl_lights_usage_pattern: Optional[
+ Literal["evening", "morning_evening", "most", "all"]
+ ] = "evening"
+ cfl_lights_hours: Optional[float] = Field(None, ge=0, le=24) # Explicit override
+
+ num_tube_lights: Optional[int] = None
+ tube_lights_usage_pattern: Optional[
+ Literal["evening", "morning_evening", "most", "all"]
+ ] = "evening"
+ tube_lights_hours: Optional[float] = Field(None, ge=0, le=24) # Explicit override
+
+
+class TelevisionInput(BaseApplianceInput):
+ tv_size_inches: float = Field(..., ge=10, le=100)
+ num_televisions: int = Field(1, ge=1)
+ television_type: Literal["LED", "LCD", "CRT", "OLED", "QLED"]
+ television_usage_pattern: Literal["light", "moderate", "heavy", "always"] = (
+ "moderate"
+ )
+ television_hours: Optional[float] = Field(None, ge=0, le=24) # Explicit override
+
+
+class WaterHeaterInput(BaseApplianceInput):
+ water_heater_capacity_liters: float = Field(..., ge=1, le=100)
+ water_heater_type: Literal["instant", "storage", "gas", "solar"]
+ geyser_usage_pattern: Literal["minimal", "light", "moderate", "heavy"] = "light"
+ water_heater_hours: Optional[float] = Field(None, ge=0, le=24) # Explicit override
+
+
+class WaterPumpInput(BaseApplianceInput):
+ water_pump_hp: float = Field(..., ge=0.5, le=5.0)
+ pump_usage_pattern: Literal[
+ "minimal", "light", "moderate", "heavy", "rare", "normal", "frequent"
+ ] = "moderate"
+ water_pump_hours: Optional[float] = Field(None, ge=0, le=24) # Explicit override
+
+
+class KitchenApplianceInput(BaseApplianceInput):
+ wattage: Optional[float] = None
+ usage_minutes_per_day: Optional[float] = None
+ usage_hours_per_day: Optional[float] = None
+ kitchen_appliance_hours: Optional[float] = None # Explicit override
+
+
+class MixerInput(BaseApplianceInput):
+ mixer_usage_pattern: Literal["rarely", "light", "moderate", "heavy"] = "moderate"
+ mixer_grinder_wattage: Optional[float] = 750
+ mixer_hours: Optional[float] = Field(None, ge=0, le=24)
+
+
+class MicrowaveInput(BaseApplianceInput):
+ microwave_usage_pattern: Literal["rarely", "light", "moderate", "heavy"] = "light"
+ microwave_capacity_liters: Optional[float] = 20
+ microwave_hours: Optional[float] = Field(None, ge=0, le=24)
+
+
+class KettleInput(BaseApplianceInput):
+ kettle_usage_pattern: Literal["rarely", "light", "moderate", "heavy"] = "light"
+ kettle_hours: Optional[float] = Field(None, ge=0, le=24)
+
+
+class InductionInput(BaseApplianceInput):
+ induction_usage_pattern: Literal["light", "moderate", "heavy", "very_heavy"] = (
+ "moderate"
+ )
+ induction_hours: Optional[float] = Field(None, ge=0, le=24)
+
+
+class RiceCookerInput(BaseApplianceInput):
+ rice_cooker_usage_pattern: Literal["rarely", "light", "moderate", "heavy"] = "light"
+ rice_cooker_hours: Optional[float] = Field(None, ge=0, le=24)
+
+
+class ToasterInput(BaseApplianceInput):
+ toaster_usage_pattern: Literal["rarely", "light", "moderate", "heavy"] = "light"
+ toaster_hours: Optional[float] = Field(None, ge=0, le=24)
+
+
+class FoodProcessorInput(BaseApplianceInput):
+ food_processor_usage_pattern: Literal["rarely", "light", "moderate", "heavy"] = (
+ "light"
+ )
+ food_processor_hours: Optional[float] = Field(None, ge=0, le=24)
+
+
+class HairDryerInput(BaseApplianceInput):
+ hair_dryer_usage_pattern: Literal["rarely", "light", "moderate", "heavy"] = "light"
+ hair_dryer_hours: Optional[float] = Field(None, ge=0, le=24)
+
+
+class VacuumInput(BaseApplianceInput):
+ vacuum_usage_pattern: Literal["rarely", "light", "moderate", "heavy"] = "light"
+ vacuum_hours: Optional[float] = Field(None, ge=0, le=24)
+
+
+class IronInput(BaseApplianceInput):
+ iron_usage_pattern: Literal["rarely", "light", "moderate", "heavy"] = "light"
+ iron_hours: Optional[float] = Field(None, ge=0, le=24)
+
+
+class DesktopInput(BaseApplianceInput):
+ desktop_usage_pattern: Literal["light", "moderate", "heavy", "always"] = "moderate"
+ desktop_hours: Optional[float] = Field(None, ge=0, le=24)
+
+
+class LaptopInput(BaseApplianceInput):
+ laptop_usage_pattern: Literal["light", "moderate", "heavy", "always"] = "moderate"
+ laptop_hours: Optional[float] = Field(None, ge=0, le=24)
+
+
+# --- Mapping Helper ---
+# Maps frontend string "ac" -> ACInput class
+MODEL_MAPPING = {
+ "ac": ACInput,
+ "fridge": FridgeInput,
+ "refrigerator": FridgeInput,
+ "washing_machine": WashingMachineInput,
+ "ceiling_fan": CeilingFanInput,
+ "fan": CeilingFanInput,
+ "led_light": LightingInput,
+ "cfl_bulb": LightingInput,
+ "tube_light": LightingInput,
+ "television": TelevisionInput,
+ "tv": TelevisionInput,
+ "water_heater": WaterHeaterInput,
+ "geyser": WaterHeaterInput,
+ "water_pump": WaterPumpInput,
+ "pump": WaterPumpInput,
+ "iron": IronInput,
+ "desktop": DesktopInput,
+ "laptop": LaptopInput,
+ "mixer_grinder": MixerInput,
+ "mixer": MixerInput,
+ "microwave": MicrowaveInput,
+ "kettle": KettleInput,
+ "induction": InductionInput,
+ "rice_cooker": RiceCookerInput,
+ "toaster": ToasterInput,
+ "food_processor": FoodProcessorInput,
+ "hair_dryer": HairDryerInput,
+ "vacuum": VacuumInput,
+ # Fallbacks use generic KitchenApplianceInput
+}
diff --git a/services/__init__.py b/services/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fd6e91d7efa8ed9307e834214e3194ba0bf60d7
--- /dev/null
+++ b/services/__init__.py
@@ -0,0 +1,15 @@
+"""Services package"""
+
+from .batch_predictor import BatchPredictor
+from .bias_adjuster import BiasAdjuster
+from .input_normalizer import InputNormalizer
+from .learning_pipeline import LearningPipeline
+from .system_load_balancer import SystemLoadBalancer
+
+__all__ = [
+ "InputNormalizer",
+ "BatchPredictor",
+ "BiasAdjuster",
+ "LearningPipeline",
+ "SystemLoadBalancer",
+]
diff --git a/services/batch_predictor.py b/services/batch_predictor.py
new file mode 100644
index 0000000000000000000000000000000000000000..3578aa7c815bc14bb16651eb3869ed6f8e85d143
--- /dev/null
+++ b/services/batch_predictor.py
@@ -0,0 +1,74 @@
+"""
+Batch Predictor Service
+Single prediction loop for all appliances - no spam, no redundancy.
+"""
+
+from typing import Any, Dict, List
+
+import pandas as pd
+
+
+class BatchPredictor:
+ """Handles batch prediction for multiple appliances in ONE loop"""
+
+ def __init__(self, predictor_instance):
+ """
+ Args:
+ predictor_instance: The AppliancePredictor from predictor.py
+ """
+ self.predictor = predictor_instance
+
+ def predict_batch(
+ self, user_context: Dict[str, Any], appliance_inputs: Dict[str, Any]
+ ) -> List[Dict[str, Any]]:
+ """
+ ONE loop, all predictions.
+
+ ⚠️ No API calls inside loop
+ ⚠️ No learning inside loop
+ ⚠️ No logging spam
+
+ Args:
+ user_context: Shared household context
+ appliance_inputs: Dict of {appliance_name: inputs}
+
+ Returns:
+ List of prediction results
+ """
+ results = []
+
+ for appliance_name, inputs in appliance_inputs.items():
+ # Merge context with appliance-specific inputs
+ combined_data = {**user_context, **inputs}
+
+ # Single prediction call
+ result = self.predictor.predict(name=appliance_name, data=[combined_data])
+
+ # Structure result
+ results.append(
+ {
+ "appliance": appliance_name,
+ "kwh": result.get("prediction", 0),
+ "insights": result.get("insights", {}),
+ "source": result.get("insights", {}).get("source", "unknown"),
+ }
+ )
+
+ return results
+
+ def calculate_total_kwh(self, results: List[Dict[str, Any]]) -> float:
+ """Calculate total predicted consumption"""
+ return sum(r["kwh"] for r in results)
+
+ def group_by_source(self, results: List[Dict[str, Any]]) -> Dict[str, List]:
+ """Group appliances by prediction source (User Hours vs Inferred Physics)"""
+ grouped = {"User Hours": [], "Inferred Physics": [], "Physics": []}
+
+ for r in results:
+ source = r.get("source", "Physics")
+ if source in grouped:
+ grouped[source].append(r)
+ else:
+ grouped["Physics"].append(r)
+
+ return grouped
diff --git a/services/bias_adjuster.py b/services/bias_adjuster.py
new file mode 100644
index 0000000000000000000000000000000000000000..a211f79bd51ec316cd38b14e453f0b742258ca23
--- /dev/null
+++ b/services/bias_adjuster.py
@@ -0,0 +1,72 @@
+"""
+Bias Adjuster Service
+Applies efficiency bias ONCE after all predictions complete.
+"""
+
+import json
+import os
+from typing import Any, Dict, List
+
+
+class BiasAdjuster:
+ """Applies user-specific efficiency bias to predictions"""
+
+ BIAS_FILE = "user_biases.json"
+
+ @classmethod
+ def load_user_bias(cls, user_id: str) -> float:
+ """Load user's efficiency bias (default 1.0)"""
+ if not os.path.exists(cls.BIAS_FILE):
+ return 1.0
+
+ try:
+ with open(cls.BIAS_FILE, "r") as f:
+ biases = json.load(f)
+ return biases.get(user_id, 1.0)
+ except:
+ return 1.0
+
+ @classmethod
+ def save_user_bias(cls, user_id: str, bias: float):
+ """Save updated bias to file"""
+ biases = {}
+
+ if os.path.exists(cls.BIAS_FILE):
+ try:
+ with open(cls.BIAS_FILE, "r") as f:
+ biases = json.load(f)
+ except:
+ pass
+
+ biases[user_id] = bias
+
+ with open(cls.BIAS_FILE, "w") as f:
+ json.dump(biases, f, indent=2)
+
+ @classmethod
+ def apply_bias_to_results(
+ cls, results: List[Dict[str, Any]], user_id: str
+ ) -> tuple[List[Dict[str, Any]], float]:
+ """
+ Apply efficiency bias ONCE to all results.
+
+ ✔ Predict first
+ ✔ Adjust once
+ ✔ Then move on
+
+ Args:
+ results: List of prediction results
+ user_id: User identifier
+
+ Returns:
+ (adjusted_results, bias_applied)
+ """
+ # Load bias ONCE
+ efficiency_bias = cls.load_user_bias(user_id)
+
+ # Apply to all results
+ for r in results:
+ r["kwh"] *= efficiency_bias
+ r["bias_applied"] = efficiency_bias
+
+ return results, efficiency_bias
diff --git a/services/input_normalizer.py b/services/input_normalizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c8da253d78fc815af6355376711956a95978dcf
--- /dev/null
+++ b/services/input_normalizer.py
@@ -0,0 +1,60 @@
+"""
+Input Normalizer Service
+Extracts and normalizes user context and appliance inputs ONCE per request.
+"""
+
+from typing import Any, Dict, List
+
+
+class InputNormalizer:
+ """Normalizes batch prediction inputs into clean structure"""
+
+ @staticmethod
+ def normalize_batch_request(batch_data: Dict[str, Any]) -> Dict[str, Any]:
+ """
+ Extracts user context once and builds appliance inputs dict.
+
+ Args:
+ batch_data: Raw request data from API
+
+ Returns:
+ {
+ "user_context": {...},
+ "appliance_inputs": {...}
+ }
+ """
+ # Extract common user context ONCE
+ user_context = {
+ "total_kwh_monthly": batch_data.get("total_kwh_monthly", 0),
+ "n_occupants": batch_data.get("n_occupants", 3),
+ "season": batch_data.get("season", "monsoon"),
+ "location_type": batch_data.get("location_type", "urban"),
+ "house_type": batch_data.get("house_type", "apartment"),
+ }
+
+ # Build appliance-specific inputs dict
+ appliance_inputs = {}
+ requests = batch_data.get("requests", [])
+
+ for req in requests:
+ appliance_name = req.get("appliance_name")
+ details = req.get("details", {})
+
+ # Store appliance-specific params
+ appliance_inputs[appliance_name] = {
+ **details, # All appliance-specific fields
+ "_user_context": user_context, # Reference to shared context
+ }
+
+ return {"user_context": user_context, "appliance_inputs": appliance_inputs}
+
+ @staticmethod
+ def extract_household_features(user_context: Dict[str, Any]) -> Dict[str, Any]:
+ """Extract household-level features for AI models"""
+ return {
+ "num_people": user_context.get("n_occupants", 3),
+ "season": user_context.get("season", "monsoon"),
+ "location_type": user_context.get("location_type", "urban"),
+ "house_type": user_context.get("house_type", "apartment"),
+ "total_monthly_kwh": user_context.get("total_kwh_monthly", 0),
+ }
diff --git a/services/learning_pipeline.py b/services/learning_pipeline.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5e1ea0cae3ad02973a61512e48062b855ca5372
--- /dev/null
+++ b/services/learning_pipeline.py
@@ -0,0 +1,82 @@
+"""
+Learning Pipeline Service
+Fires ONCE after totals are computed - real AI-inferred physics learning.
+"""
+
+from typing import Any, Dict
+
+from services.bias_adjuster import BiasAdjuster
+
+
+class LearningPipeline:
+ """Handles self-learning from prediction gaps"""
+
+ # Learning configuration
+ LEARNING_RATE = 0.1 # 10% adjustment per iteration
+ MIN_BIAS = 0.5 # Don't go below 50% efficiency
+ MAX_BIAS = 1.5 # Don't go above 150% efficiency
+ GAP_THRESHOLD = 5.0 # Only learn if gap > 5 kWh
+
+ @classmethod
+ def learn_from_gap(
+ cls,
+ user_id: str,
+ actual_kwh: float,
+ predicted_total: float,
+ current_bias: float,
+ ) -> Dict[str, Any]:
+ """
+ Learning fires ONCE after full batch prediction.
+
+ This is real AI-inferred physics learning.
+
+ Args:
+ user_id: User identifier
+ actual_kwh: Actual monthly consumption
+ predicted_total: Sum of all predicted kWh
+ current_bias: Current efficiency bias
+
+ Returns:
+ Learning result dict with new bias and metadata
+ """
+ # Calculate prediction gap
+ gap = actual_kwh - predicted_total
+ gap_percentage = (gap / actual_kwh * 100) if actual_kwh > 0 else 0
+
+ # Check if learning needed
+ if abs(gap) < cls.GAP_THRESHOLD:
+ return {
+ "learning_applied": False,
+ "reason": f"Gap too small ({gap:.2f} kWh < {cls.GAP_THRESHOLD} threshold)",
+ "current_bias": current_bias,
+ "new_bias": current_bias,
+ "gap_kwh": gap,
+ "gap_percentage": gap_percentage,
+ }
+
+ # Calculate new bias using gradient descent approach
+ # If gap > 0: under-predicting, increase bias
+ # If gap < 0: over-predicting, decrease bias
+ adjustment = (gap / actual_kwh) * cls.LEARNING_RATE
+ new_bias = current_bias + adjustment
+
+ # Apply safety bounds
+ new_bias = max(cls.MIN_BIAS, min(new_bias, cls.MAX_BIAS))
+
+ # Save updated bias
+ BiasAdjuster.save_user_bias(user_id, new_bias)
+
+ return {
+ "learning_applied": True,
+ "reason": f"Gap {gap:.2f} kWh ({gap_percentage:.1f}%) exceeds threshold",
+ "current_bias": current_bias,
+ "new_bias": new_bias,
+ "gap_kwh": gap,
+ "gap_percentage": gap_percentage,
+ "adjustment": adjustment,
+ }
+
+ @classmethod
+ def should_trigger_learning(cls, actual_kwh: float) -> bool:
+ """Check if we have enough data to trigger learning"""
+ return actual_kwh > 0
diff --git a/services/system_load_balancer.py b/services/system_load_balancer.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae9d0c6e727b19570f846deed992ba88e619f539
--- /dev/null
+++ b/services/system_load_balancer.py
@@ -0,0 +1,121 @@
+"""
+System Load Balancer Service
+Caps system load at realistic levels and redistributes excess proportionally.
+"""
+
+from typing import Any, Dict, List
+
+
+class SystemLoadBalancer:
+ """Handles realistic system load calculation and excess redistribution"""
+
+ # Configuration
+ MAX_SYSTEM_LOAD_PERCENTAGE = 0.15 # 15% maximum for believability
+ MIN_SYSTEM_LOAD_PERCENTAGE = 0.05 # 5% minimum (standby devices exist)
+
+ # Redistribution weights (which appliances get excess)
+ REDISTRIBUTION_WEIGHTS = {
+ "fridge": 0.35, # Fridge runs 24/7, gets most excess
+ "ceiling_fan": 0.30, # Fans often underestimated
+ "led_light": 0.20, # Lights usage varies
+ "ac": 0.10, # AC gets some
+ "television": 0.05, # TV gets minimal
+ }
+
+ @classmethod
+ def calculate_balanced_load(
+ cls,
+ actual_kwh: float,
+ predicted_total: float,
+ results_list: List[Dict[str, Any]],
+ ) -> tuple[float, List[Dict[str, Any]], Dict[str, Any]]:
+ """
+ Calculate system load with realistic cap and redistribute excess.
+
+ Args:
+ actual_kwh: Actual monthly consumption
+ predicted_total: Sum of all predicted appliances
+ results_list: List of prediction results
+
+ Returns:
+ (system_load, adjusted_results, balancing_info)
+ """
+ # Calculate raw system load
+ raw_system_load = max(0, actual_kwh - predicted_total)
+ raw_percentage = (raw_system_load / actual_kwh * 100) if actual_kwh > 0 else 0
+
+ # Cap system load at maximum realistic level
+ max_allowed_load = actual_kwh * cls.MAX_SYSTEM_LOAD_PERCENTAGE
+ system_load = min(raw_system_load, max_allowed_load)
+
+ # Calculate excess that needs redistribution
+ excess_kwh = raw_system_load - system_load
+
+ balancing_info = {
+ "raw_system_load": raw_system_load,
+ "raw_percentage": raw_percentage,
+ "capped_system_load": system_load,
+ "capped_percentage": (
+ (system_load / actual_kwh * 100) if actual_kwh > 0 else 0
+ ),
+ "excess_redistributed": excess_kwh,
+ "redistribution_applied": excess_kwh > 0,
+ }
+
+ # If no excess, return as-is
+ if excess_kwh <= 0:
+ return system_load, results_list, balancing_info
+
+ # Redistribute excess proportionally to key appliances
+ redistributed_results = []
+ redistribution_details = {}
+
+ for r in results_list:
+ appliance = r["appliance"]
+ original_kwh = r["kwh"]
+
+ # Calculate redistribution amount based on weights
+ weight = cls.REDISTRIBUTION_WEIGHTS.get(appliance, 0)
+ redistribution_amount = excess_kwh * weight
+
+ # Add to appliance consumption
+ new_kwh = original_kwh + redistribution_amount
+
+ redistributed_results.append(
+ {
+ **r,
+ "kwh": new_kwh,
+ "original_kwh": original_kwh,
+ "redistributed_kwh": redistribution_amount,
+ }
+ )
+
+ if redistribution_amount > 0:
+ redistribution_details[appliance] = redistribution_amount
+
+ balancing_info["redistribution_details"] = redistribution_details
+
+ return system_load, redistributed_results, balancing_info
+
+ @classmethod
+ def get_system_load_explanation(
+ cls, percentage: float, location_type: str = "urban"
+ ) -> str:
+ """Get human-readable explanation for system load"""
+ if percentage < 5:
+ return "Very low system load - excellent appliance coverage"
+ elif percentage <= 10:
+ if location_type == "rural":
+ return "Normal background consumption (standby devices, voltage fluctuations)"
+ else:
+ return (
+ "Normal background consumption (chargers, routers, standby devices)"
+ )
+ elif percentage <= 15:
+ if location_type == "rural":
+ return "Typical rural system load (pump losses, voltage fluctuation, standby devices)"
+ else:
+ return "Typical urban system load (inverter, CCTV, unmodeled devices)"
+ else:
+ # Shouldn't happen after capping, but just in case
+ return f"High system load ({percentage:.1f}%) - indicates unmodeled devices or measurement variance"
diff --git a/simulation_service.py b/simulation_service.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ae3388541229bcbdf6a39cc4b500b6ec33f1e5f
--- /dev/null
+++ b/simulation_service.py
@@ -0,0 +1,211 @@
+from typing import Any, Dict, List
+
+
+class SimulationService:
+ """
+ Handles 'What-If' scenarios for energy optimization.
+ Each check is independently wrapped to prevent one failure from silencing others.
+ """
+
+ @staticmethod
+ def safe_int(val, default=0):
+ try:
+ if not val:
+ return default
+ s = str(val).split(" ")[0].split("-")[0]
+ return int(float(s))
+ except:
+ return default
+
+ @staticmethod
+ def safe_float(val, default=0.0):
+ try:
+ if not val:
+ return default
+ s = str(val).split(" ")[0]
+ return float(s)
+ except:
+ return default
+
+ @classmethod
+ def run_simulation(
+ cls, details: Dict[str, Any], bill_total: float, model_callback
+ ) -> List[Dict[str, Any]]:
+ """
+ Runs all what-if simulations independently.
+ Each check has its own try/except so a broken model call never blocks others.
+ Returns a list of insight dicts with title, saved_kwh, description.
+ """
+ insights = []
+ d = details
+ bill = bill_total
+
+ # --- 1. AC STAR RATING UPGRADE ---
+ try:
+ ac_star = cls.safe_int(d.get("ac_star"), 0)
+ if ac_star > 0 and ac_star < 5:
+ curr = model_callback("air_conditioner", d, bill).get("prediction", 0)
+ sim_d = {**d, "ac_star": 5}
+ sim_pred = model_callback("air_conditioner", sim_d, bill).get(
+ "prediction", 0
+ )
+ saved = curr - sim_pred
+ if saved > 2:
+ insights.append(
+ {
+ "title": f"Upgrade to 5-Star AC",
+ "saved_kwh": round(saved, 1),
+ "description": f"Switching your {ac_star}-star AC to a 5-star model could save ~{round(saved)} kWh per month.",
+ }
+ )
+ except Exception as e:
+ print(f"[Simulation] AC insight error: {e}")
+
+ # --- 2. REDUCE AC DAILY HOURS ---
+ try:
+ ac_hours = cls.safe_float(d.get("ac_hours"), 0)
+ if ac_hours > 4:
+ curr = model_callback("air_conditioner", d, bill).get("prediction", 0)
+ sim_d = {**d, "ac_hours": max(2, ac_hours - 2)}
+ sim_pred = model_callback("air_conditioner", sim_d, bill).get(
+ "prediction", 0
+ )
+ saved = curr - sim_pred
+ if saved > 2:
+ insights.append(
+ {
+ "title": "Reduce AC Usage by 2 Hours",
+ "saved_kwh": round(saved, 1),
+ "description": f"Cutting AC from {round(ac_hours)}h to {round(max(2, ac_hours-2))}h/day could save ~{round(saved)} kWh monthly.",
+ }
+ )
+ except Exception as e:
+ print(f"[Simulation] AC hours insight error: {e}")
+
+ # --- 3. OLD FRIDGE REPLACEMENT ---
+ try:
+ fridge_age = d.get("fridge_age", "")
+ fridge_age_int = cls.safe_int(fridge_age, 0)
+ # Check string keys like '10+' as well
+ is_old_fridge = fridge_age_int >= 10 or str(fridge_age).startswith("10")
+ if is_old_fridge:
+ curr = model_callback("refrigerator", d, bill).get("prediction", 0)
+ sim_d = {**d, "fridge_age": 2}
+ sim_pred = model_callback("refrigerator", sim_d, bill).get(
+ "prediction", 0
+ )
+ saved = curr - sim_pred
+ if saved > 2:
+ insights.append(
+ {
+ "title": "Replace Old Refrigerator",
+ "saved_kwh": round(saved, 1),
+ "description": f"Your old fridge is inefficient. A new energy-efficient model could save ~{round(saved)} kWh monthly.",
+ }
+ )
+ except Exception as e:
+ print(f"[Simulation] Fridge insight error: {e}")
+
+ # --- 4. BLDC FAN UPGRADE ---
+ try:
+ fan_type = str(d.get("fan_type", "")).lower()
+ num_fans = cls.safe_int(d.get("num_fans"), 0)
+ if fan_type not in ("bldc",) and num_fans > 0:
+ curr = model_callback("ceiling_fan", d, bill).get("prediction", 0)
+ sim_d = {**d, "fan_type": "bldc"}
+ sim_pred = model_callback("ceiling_fan", sim_d, bill).get(
+ "prediction", 0
+ )
+ saved = curr - sim_pred
+ if saved > 2:
+ insights.append(
+ {
+ "title": "Switch to BLDC Fans",
+ "saved_kwh": round(saved, 1),
+ "description": f"Replacing your {num_fans} standard fan(s) with BLDC models saves ~{round(saved)} kWh monthly (60% less power).",
+ }
+ )
+ except Exception as e:
+ print(f"[Simulation] Fan insight error: {e}")
+
+ # --- 5. GEYSER USAGE REDUCTION ---
+ try:
+ geyser_hours = cls.safe_float(d.get("geyser_hours"), 0)
+ if geyser_hours > 0.5:
+ curr = model_callback("water_heater", d, bill).get("prediction", 0)
+ sim_d = {**d, "geyser_hours": 0.5}
+ sim_pred = model_callback("water_heater", sim_d, bill).get(
+ "prediction", 0
+ )
+ saved = curr - sim_pred
+ if saved > 1:
+ insights.append(
+ {
+ "title": "Limit Geyser to 30 min/day",
+ "saved_kwh": round(saved, 1),
+ "description": "Reducing geyser usage to 30 mins/day saves energy without sacrificing comfort.",
+ }
+ )
+ except Exception as e:
+ print(f"[Simulation] Geyser insight error: {e}")
+
+ # --- 6. TV HOURS REDUCTION ---
+ try:
+ tv_hours = cls.safe_float(d.get("tv_hours"), 0)
+ if tv_hours > 5:
+ curr = model_callback("television", d, bill).get("prediction", 0)
+ sim_d = {**d, "tv_hours": 3}
+ sim_pred = model_callback("television", sim_d, bill).get(
+ "prediction", 0
+ )
+ saved = curr - sim_pred
+ if saved > 1:
+ insights.append(
+ {
+ "title": "Reduce TV Watching by 2 Hours",
+ "saved_kwh": round(saved, 1),
+ "description": f"Cutting TV from {round(tv_hours)}h to 3h/day could save ~{round(saved)} kWh monthly.",
+ }
+ )
+ except Exception as e:
+ print(f"[Simulation] TV insight error: {e}")
+
+ # --- 7. UPGRADE TO LED LIGHTS ---
+ try:
+ # If cfl or tube lights are present, recommend LEDs
+ cfl_hours = cls.safe_float(d.get("cfl_hours"), 0)
+ tube_hours = cls.safe_float(d.get("tube_hours"), 0)
+ if cfl_hours > 2 or tube_hours > 2:
+ # CFL ~15W vs LED ~7W: 50% saving
+ total_hours = max(cfl_hours, tube_hours)
+ # Rough estimate: 4 lights at 15W → 7W difference = 32W saving × hours × 30 / 1000
+ estimated_save = round(4 * 0.008 * total_hours * 30, 1)
+ if estimated_save > 1:
+ insights.append(
+ {
+ "title": "Switch CFL/Tube Lights to LED",
+ "saved_kwh": estimated_save,
+ "description": f"LEDs use 50–60% less power than CFL/tube lights. Est. saving: ~{estimated_save} kWh/month.",
+ }
+ )
+ except Exception as e:
+ print(f"[Simulation] LED insight error: {e}")
+
+ # --- 8. WASHING MACHINE — COLD WASH TIP ---
+ try:
+ wm_pattern = str(d.get("wm_pattern", "")).lower()
+ wm_cycles = cls.safe_float(d.get("wm_cycles_per_week"), 0)
+ if wm_cycles >= 5 or wm_pattern in ("heavy", "very_heavy"):
+ insights.append(
+ {
+ "title": "Use Cold Water Wash Cycles",
+ "saved_kwh": round(
+ wm_cycles * 0.5 * 4, 1
+ ), # ~0.5 kWh saved per hot→cold wash
+ "description": "Switching to cold water wash for most loads saves ~0.5 kWh per cycle and extends fabric life.",
+ }
+ )
+ except Exception as e:
+ print(f"[Simulation] WM insight error: {e}")
+
+ return insights
diff --git a/tariff_config.py b/tariff_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e70604fbfd87eb32ce2e28c7cc8f5ac77bca0e4
--- /dev/null
+++ b/tariff_config.py
@@ -0,0 +1,46 @@
+"""
+KSEB Tariff Configuration (2024-25)
+===================================
+Centralized configuration for KSEB Basic Tariff rates.
+Update this file when rate changes occur.
+Methods: Telescopic (<= 250 units) and Non-Telescopic (> 250 units).
+"""
+
+# --- TELESCOPIC SLAB RATES ---
+# Applied when monthly average consumption is <= 250 units
+# Format: (Limit, Rate_Per_Unit)
+TELESCOPIC_SLABS = [
+ (50, 3.25), # First 50 units: ₹3.25/unit
+ (50, 4.05), # Next 50 (51-100): ₹4.05/unit
+ (50, 5.10), # Next 50 (101-150): ₹5.10/unit
+ (50, 6.95), # Next 50 (151-200): ₹6.95/unit
+ (50, 8.20), # Next 50 (201-250): ₹8.20/unit
+]
+
+# --- NON-TELESCOPIC FLAT RATES ---
+# Applied when monthly average consumption is > 250 units
+# Format: (Limit, Rate_Per_Unit)
+FLAT_RATE_SLABS = [
+ (
+ 300,
+ 6.40,
+ ), # 0-300 units: ₹6.40/unit (applied to ENTIRE consumption if applicable logic, but usually tiered in non-telescopic too?
+ # KSEB Non-telescopic usually means:
+ # 0-300 @ 6.40
+ # 0-350 @ 7.25 (Total volume driven)
+ # Notes: The previous implementation treated these as "SLABS" but the logic iteration suggests they might be "Block Slab" or "Flat Rate".
+ # Re-checking logic in kseb_tariff.py:
+ # It iterates `FLAT_RATE_SLABS`.
+ # If logic is: for limit, rate in slabs: check if total <= limit return total * rate?
+ # No, `kseb_tariff.py` (line 100+) implements a specific logic.
+ # Let's preserve the existing data structure exactly as found in kseb_tariff.py used by the logic.
+ (300, 6.40), # Up to 300
+ (350, 7.25), # Up to 350
+ (400, 7.60), # Up to 400
+ (500, 7.90), # Up to 500
+ (float("inf"), 8.80), # Above 500
+]
+
+# --- FUEL SURCHARGE MECHANISM (FSM) ---
+# Floating rate adjusted quarterly
+FSM_RATE = 0.13
diff --git a/tests/README.md b/tests/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..c3297b8d45a45b94c8f257f49b99db579f2eb320
--- /dev/null
+++ b/tests/README.md
@@ -0,0 +1,31 @@
+# Backend Test Suite
+
+This directory contains backend validation assets grouped by scope.
+
+## Directory Structure
+
+- `unit/`: isolated behavior tests for individual functions and modules.
+- `integration/`: interaction tests across multiple backend components.
+- `e2e/`: full workflow tests from input mapping to output validation.
+- `system/`: broad validation runners and quality audits.
+- `validation/`: dataset, mapping, tariff, and alignment validation checks.
+- `analysis/`: exploratory diagnostics and investigation scripts.
+
+## Typical Commands
+
+Run from the backend root:
+
+```bash
+pytest tests/unit
+pytest tests/integration
+python tests/e2e/test_complete_flow.py
+python tests/system/run_backend_tests.py
+python tests/validation/validate_ui_training_mapping.py
+```
+
+## Authoring Guidance
+
+- Unit tests should target one logical behavior per test and avoid heavy external dependencies.
+- Integration tests should validate contracts between routers, services, and predictor logic.
+- End-to-end tests should cover realistic user payloads and expected response structures.
+- Validation scripts should be used to protect feature mapping and dataset consistency.
diff --git a/tests/analysis/analyze_kerala_context.py b/tests/analysis/analyze_kerala_context.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc532e9e21d627557b45287a2b609d954c1f3476
--- /dev/null
+++ b/tests/analysis/analyze_kerala_context.py
@@ -0,0 +1,347 @@
+"""
+Kerala-Specific Features Analysis
+Validates how accurately Kerala regional factors are modeled
+"""
+
+import numpy as np
+import pandas as pd
+
+
+def analyze_kerala_context():
+ """Detailed analysis of Kerala-specific modeling accuracy"""
+
+ print("=" * 80)
+ print("KERALA-SPECIFIC CONTEXT ANALYSIS")
+ print("Regional Factors in Energy Consumption Modeling")
+ print("=" * 80)
+
+ df = pd.read_csv("kerala_smartwatt_ai.csv")
+
+ # ========== 1. CLIMATE FACTORS ==========
+ print("\n" + "=" * 80)
+ print("1. CLIMATE IMPACT (Humidity & Heat)")
+ print("=" * 80)
+
+ # AC Humidity Impact
+ ac_df = df[df["has_ac"] == 1]
+ if len(ac_df) > 0:
+ base_hours = 8.0 # Standard AC usage
+ actual_hours = ac_df["ac_real_effective_hours"].mean()
+ humidity_boost = (actual_hours / base_hours - 1) * 100
+
+ print("\n📊 AIR CONDITIONER - Humidity Factor")
+ print(f" Expected Hours (moderate climate): {base_hours:.1f}h/day")
+ print(f" Actual Hours (Kerala humid): {actual_hours:.2f}h/day")
+ print(f" Humidity Boost Factor: +{humidity_boost:.1f}%")
+ print(f" Target Boost (from code): +20%")
+ print(
+ f" Status: {'✅ ACCURATE' if abs(humidity_boost - 20) < 5 else '⚠️ DEVIATION'}"
+ )
+
+ print(f"\n Why? Kerala's high humidity (70-90%) forces AC compressors to")
+ print(f" work harder and longer to remove moisture from air.")
+
+ # Fan Humidity Impact
+ fan_df = df[df["has_ceiling_fan"] == 1]
+ if len(fan_df) > 0:
+ base_fan_hours = 10.0 # Moderate climate
+ actual_fan_hours = fan_df["ceiling_fan_real_effective_hours"].mean()
+ fan_humidity_boost = (actual_fan_hours / base_fan_hours - 1) * 100
+
+ print("\n📊 CEILING FAN - Essential Cooling")
+ print(f" Expected Hours (moderate climate): {base_fan_hours:.1f}h/day")
+ print(f" Actual Hours (Kerala humid): {actual_fan_hours:.2f}h/day")
+ print(f" Humidity Impact: +{fan_humidity_boost:.1f}%")
+ print(f" Target Impact (from code): +30%")
+ print(
+ f" Status: {'✅ ACCURATE' if abs(fan_humidity_boost - 30) < 10 else '⚠️ DEVIATION'}"
+ )
+
+ print(f"\n Why? Kerala's coastal humidity makes fans run nearly all day")
+ print(f" Penetration: {(len(fan_df)/len(df)*100):.1f}% (Essential appliance)")
+
+ # Hot Climate - Fridge Degradation
+ fridge_df = df[df["has_refrigerator"] == 1]
+ if len(fridge_df) > 0:
+ old_fridges = fridge_df[fridge_df["fridge_age"] >= 10]
+ new_fridges = fridge_df[fridge_df["fridge_age"] <= 2]
+
+ if len(old_fridges) > 0 and len(new_fridges) > 0:
+ old_eff = old_fridges["fridge_real_efficiency_factor"].mean()
+ new_eff = new_fridges["fridge_real_efficiency_factor"].mean()
+ degradation = ((new_eff - old_eff) / new_eff) * 100
+
+ print("\n📊 REFRIGERATOR - Hot Climate Degradation")
+ print(f" New Fridge Efficiency (≤2 years): {new_eff:.3f}")
+ print(f" Old Fridge Efficiency (≥10 years): {old_eff:.3f}")
+ print(f" Degradation over 10 years: {degradation:.1f}%")
+ print(f" Annual Degradation Rate: {degradation/10:.1f}%/year")
+ print(f" Target Rate (from code): 4%/year")
+ print(
+ f" Status: {'✅ ACCURATE' if abs(degradation/10 - 4) < 1 else '⚠️ DEVIATION'}"
+ )
+
+ print(
+ f"\n Why? Kerala's heat & humidity accelerate rubber seal degradation"
+ )
+ print(f" Cold air leakage forces compressor to run longer")
+
+ # ========== 2. GRID INFRASTRUCTURE ==========
+ print("\n" + "=" * 80)
+ print("2. GRID INFRASTRUCTURE (Voltage Stability)")
+ print("=" * 80)
+
+ urban_df = df[df["location_type"] == "urban"]
+ rural_df = df[df["location_type"] == "rural"]
+
+ print(f"\n📍 URBAN vs RURAL Distribution")
+ print(f" Urban Households: {len(urban_df):,} ({len(urban_df)/len(df)*100:.1f}%)")
+ print(f" Rural Households: {len(rural_df):,} ({len(rural_df)/len(df)*100:.1f}%)")
+ print(f" Target Ratio: 60% / 40%")
+ print(
+ f" Status: {'✅ ACCURATE' if abs(len(urban_df)/len(df) - 0.6) < 0.02 else '⚠️ DEVIATION'}"
+ )
+
+ # Voltage Impact on AC
+ rural_ac = df[(df["location_type"] == "rural") & (df["has_ac"] == 1)]
+ urban_ac = df[(df["location_type"] == "urban") & (df["has_ac"] == 1)]
+
+ if len(rural_ac) > 0 and len(urban_ac) > 0:
+ rural_eff = rural_ac["ac_real_efficiency_factor"].mean()
+ urban_eff = urban_ac["ac_real_efficiency_factor"].mean()
+ voltage_penalty = ((urban_eff - rural_eff) / urban_eff) * 100
+
+ # Calculate actual cost impact
+ rural_power_factor = 1 / rural_eff
+ urban_power_factor = 1 / urban_eff
+ cost_increase = ((rural_power_factor / urban_power_factor) - 1) * 100
+
+ print(f"\n⚡ VOLTAGE FLUCTUATION - AC Efficiency Impact")
+ print(f" Urban Grid Efficiency: {urban_eff:.3f} (stable voltage)")
+ print(f" Rural Grid Efficiency: {rural_eff:.3f} (voltage drops)")
+ print(f" Efficiency Loss: {voltage_penalty:.1f}%")
+ print(f" Target Penalty (from code): ~10%")
+ print(
+ f" Status: {'✅ ACCURATE' if abs(voltage_penalty - 10) < 2 else '⚠️ DEVIATION'}"
+ )
+
+ print(f"\n 💰 Cost Impact:")
+ print(
+ f" Rural households pay: +{cost_increase:.1f}% more for same AC usage"
+ )
+ print(
+ f" Extra bill (500 kWh base): ₹{500 * cost_increase / 100 * 6:.0f}/month"
+ )
+
+ print(f"\n Why? Rural Kerala grids suffer from:")
+ print(f" • Voltage drops during peak hours (170-200V instead of 230V)")
+ print(f" • Long transmission distances from substations")
+ print(f" • Older infrastructure with higher line losses")
+
+ # Voltage Impact on Water Pumps
+ rural_pump = df[(df["location_type"] == "rural") & (df["has_water_pump"] == 1)]
+ urban_pump = df[(df["location_type"] == "urban") & (df["has_water_pump"] == 1)]
+
+ if len(rural_pump) > 0 and len(urban_pump) > 0:
+ rural_pump_eff = rural_pump["water_pump_real_efficiency_factor"].mean()
+ urban_pump_eff = urban_pump["water_pump_real_efficiency_factor"].mean()
+
+ print(f"\n⚡ VOLTAGE IMPACT - Water Pump")
+ print(f" Urban Pump Efficiency: {urban_pump_eff:.3f}")
+ print(f" Rural Pump Efficiency: {rural_pump_eff:.3f}")
+ print(
+ f" Note: Pumps modeled with variable efficiency (0.5-1.0) due to age/voltage"
+ )
+
+ # ========== 3. SEASONAL PATTERNS ==========
+ print("\n" + "=" * 80)
+ print("3. SEASONAL PATTERNS (Kerala's Three Seasons)")
+ print("=" * 80)
+
+ season_counts = df["season"].value_counts()
+ total = len(df)
+
+ print(f"\n🌤️ SEASON DISTRIBUTION")
+ for season in ["summer", "monsoon", "winter"]:
+ count = season_counts.get(season, 0)
+ pct = (count / total) * 100
+ print(f" {season.capitalize():10s}: {count:,} households ({pct:.1f}%)")
+
+ print(f"\n Equal distribution allows AI to learn seasonal variations")
+ print(
+ f" Status: {'✅ BALANCED' if all(abs(season_counts[s]/total - 0.33) < 0.05 for s in season_counts.index) else '⚠️ IMBALANCED'}"
+ )
+
+ # Geyser Usage by Season
+ geyser_df = df[df["has_water_heater"] == 1]
+ if len(geyser_df) > 0:
+ print(f"\n🚿 WATER HEATER (Geyser) - Seasonal Usage")
+ for season in ["summer", "monsoon", "winter"]:
+ season_geyser = geyser_df[geyser_df["season"] == season]
+ if len(season_geyser) > 0:
+ avg_hours = season_geyser["water_heater_real_effective_hours"].mean()
+ print(f" {season.capitalize():10s}: {avg_hours:.1f}h/day")
+
+ print(f"\n Pattern reflects Kerala climate:")
+ print(f" • Summer (Mar-May): Minimal usage (natural hot water)")
+ print(f" • Monsoon (Jun-Sep): Moderate usage (cooler temps)")
+ print(f" • Winter (Dec-Feb): Maximum usage (coolest period)")
+
+ # AC Seasonal Context
+ ac_df = df[df["has_ac"] == 1]
+ if len(ac_df) > 0 and "season" in ac_df.columns:
+ print(f"\n❄️ AIR CONDITIONER - Expected Seasonal Pattern")
+ print(f" Summer: Maximum usage (35-40°C)")
+ print(f" Monsoon: Reduced usage (natural cooling, rain)")
+ print(f" Winter: Minimal usage (25-30°C)")
+ print(f" Note: Dataset has uniform random season assignment")
+ print(f" AI learns to correlate season with usage patterns")
+
+ # ========== 4. SOCIOECONOMIC FACTORS ==========
+ print("\n" + "=" * 80)
+ print("4. SOCIOECONOMIC CONTEXT (Kerala Demographics)")
+ print("=" * 80)
+
+ # Occupancy Distribution
+ occupancy = df["n_occupants"].value_counts().sort_index()
+ print(f"\n👥 HOUSEHOLD SIZE DISTRIBUTION")
+ for occ, count in occupancy.items():
+ pct = (count / len(df)) * 100
+ bar = "█" * int(pct / 2)
+ print(f" {int(occ)} persons: {count:,} ({pct:5.1f}%) {bar}")
+
+ avg_occupancy = df["n_occupants"].mean()
+ print(f"\n Average: {avg_occupancy:.2f} persons/household")
+ print(f" Kerala census average: 3-4 persons")
+ print(f" Status: {'✅ REALISTIC' if 3 <= avg_occupancy <= 4 else '⚠️ DEVIATION'}")
+
+ # Appliance Ownership by Location
+ print(f"\n🏘️ APPLIANCE OWNERSHIP - Urban vs Rural Disparity")
+ key_appliances = [
+ ("has_ac", "AC"),
+ ("has_washing_machine", "Washing Machine"),
+ ("has_water_heater", "Water Heater"),
+ ("has_microwave", "Microwave"),
+ ]
+
+ for col, name in key_appliances:
+ if col in df.columns:
+ urban_pct = (urban_df[col].sum() / len(urban_df)) * 100
+ rural_pct = (rural_df[col].sum() / len(rural_df)) * 100
+ disparity = urban_pct - rural_pct
+ print(
+ f" {name:20s}: Urban {urban_pct:5.1f}% | Rural {rural_pct:5.1f}% | Δ {disparity:+5.1f}%"
+ )
+
+ print(f"\n Urban areas typically have higher penetration of luxury appliances")
+ print(f" due to better affordability and grid reliability")
+
+ # ========== 5. KERALA ELECTRICITY BOARD (KSEB) CONTEXT ==========
+ print("\n" + "=" * 80)
+ print("5. KSEB BILLING CONTEXT")
+ print("=" * 80)
+
+ print(f"\n💡 CONSUMPTION RANGES (for KSEB slab-based billing)")
+ consumption_bins = [
+ (0, 100, "Low Consumer"),
+ (100, 250, "Moderate Consumer"),
+ (250, 500, "High Consumer"),
+ (500, float("inf"), "Very High Consumer"),
+ ]
+
+ for low, high, label in consumption_bins:
+ if high == float("inf"):
+ count = len(df[df["total_kwh_monthly"] > low])
+ else:
+ count = len(
+ df[(df["total_kwh_monthly"] > low) & (df["total_kwh_monthly"] <= high)]
+ )
+ pct = (count / len(df)) * 100
+ print(f" {label:20s}: {count:,} households ({pct:5.1f}%)")
+
+ # Average bill estimation
+ avg_kwh = df["total_kwh_monthly"].mean()
+ # Simplified KSEB rate: ~₹6/kWh average
+ avg_bill = avg_kwh * 6
+ print(f"\n Average Consumption: {avg_kwh:.0f} kWh/month")
+ print(f" Estimated Avg Bill: ₹{avg_bill:.0f}/month")
+ print(f" KSEB Residential Avg: ₹1,800-2,500/month")
+
+ # ========== 6. VALIDATION SUMMARY ==========
+ print("\n" + "=" * 80)
+ print("6. KERALA-SPECIFIC MODELING ACCURACY SUMMARY")
+ print("=" * 80)
+
+ validations = []
+
+ # Climate factors
+ if len(ac_df) > 0:
+ humidity_boost = (ac_df["ac_real_effective_hours"].mean() / 8.0 - 1) * 100
+ validations.append(("Humidity Impact (AC)", abs(humidity_boost - 20) < 5))
+
+ # Grid infrastructure
+ if len(rural_ac) > 0 and len(urban_ac) > 0:
+ voltage_penalty = ((urban_eff - rural_eff) / urban_eff) * 100
+ validations.append(("Rural Voltage Penalty", abs(voltage_penalty - 10) < 2))
+
+ # Demographics
+ validations.append(("Urban/Rural Ratio", abs(len(urban_df) / len(df) - 0.6) < 0.02))
+ validations.append(("Household Size", 3 <= avg_occupancy <= 4))
+
+ # Seasonal
+ validations.append(("Season Distribution", len(season_counts) == 3))
+
+ print(f"\n✅ VALIDATION RESULTS:")
+ passed = 0
+ for check, result in validations:
+ status = "✅ PASS" if result else "❌ FAIL"
+ print(f" {status} {check}")
+ if result:
+ passed += 1
+
+ score = (passed / len(validations)) * 100
+ print(
+ f"\n Kerala Context Accuracy: {score:.1f}% ({passed}/{len(validations)} checks passed)"
+ )
+
+ # ========== 7. KEY INSIGHTS ==========
+ print("\n" + "=" * 80)
+ print("7. KEY KERALA-SPECIFIC INSIGHTS")
+ print("=" * 80)
+
+ print(f"\n✨ What Makes This Dataset Kerala-Authentic:\n")
+
+ print(f" 1️⃣ CLIMATE MODELING")
+ print(f" • Humidity boost factor (+20-30% usage)")
+ print(f" • Hot climate fridge degradation (4%/year)")
+ print(f" • Seasonal geyser patterns (0.5-2h/day variation)\n")
+
+ print(f" 2️⃣ GRID INFRASTRUCTURE")
+ print(f" • Rural voltage penalty (-10% efficiency)")
+ print(f" • Urban/rural disparity in appliance ownership")
+ print(f" • Realistic 60/40 urban-rural split\n")
+
+ print(f" 3️⃣ SOCIOECONOMIC PATTERNS")
+ print(f" • Family sizes matching Kerala census (3-4 persons)")
+ print(f" • Appliance penetration rates (AC 45%, Fan 98%)")
+ print(f" • KSEB consumption distribution\n")
+
+ print(f" 4️⃣ BEHAVIORAL PATTERNS")
+ print(f" • AC usage: Cost-conscious (9-10h/day, not 24h)")
+ print(f" • Fan essential: 98% penetration, 13h/day")
+ print(f" • Fridge always-on: 24h with 50% duty cycle")
+ print(f" • Seasonal geyser adjustment\n")
+
+ print(f" 5️⃣ PHYSICS-INFORMED REALISM")
+ print(f" • Efficiency factors bound to 0.6-1.1")
+ print(f" • Usage hours ≤24h (no violations)")
+ print(f" • Aging degradation follows real decay patterns")
+ print(f" • Voltage-power relationship accurately modeled\n")
+
+ print("=" * 80)
+ print("CONCLUSION: Dataset accurately captures Kerala's unique energy landscape")
+ print("=" * 80 + "\n")
+
+
+if __name__ == "__main__":
+ analyze_kerala_context()
diff --git a/tests/analysis/analyze_synthetic_accuracy.py b/tests/analysis/analyze_synthetic_accuracy.py
new file mode 100644
index 0000000000000000000000000000000000000000..f99c3b0def0ec1deaee0b9f8edb7f815a0b6ce01
--- /dev/null
+++ b/tests/analysis/analyze_synthetic_accuracy.py
@@ -0,0 +1,241 @@
+"""
+Analyze Kerala Synthetic Dataset Accuracy and Realism
+Validates the quality of the synthetic training data
+"""
+
+import json
+
+import numpy as np
+import pandas as pd
+
+
+def analyze_dataset():
+ """Comprehensive analysis of Kerala synthetic dataset quality"""
+
+ print("=" * 70)
+ print("KERALA SYNTHETIC DATASET ACCURACY ANALYSIS")
+ print("=" * 70)
+
+ # 1. Load Dataset
+ df = pd.read_csv("kerala_smartwatt_ai.csv")
+
+ print(f"\n📊 DATASET OVERVIEW")
+ print(f" Total Households: {len(df):,}")
+ print(f" Total Features: {df.shape[1]}")
+
+ # 2. Appliance Penetration Analysis
+ print(f"\n🏠 APPLIANCE PENETRATION RATES (Target vs Actual)")
+ appliances = {
+ "AC": ("has_ac", 45.0),
+ "Refrigerator": ("has_refrigerator", 95.0),
+ "Ceiling Fan": ("has_ceiling_fan", 98.0),
+ "Television": ("has_television", 95.0),
+ "Washing Machine": ("has_washing_machine", 60.0),
+ "Water Pump": ("has_water_pump", 70.0),
+ "Water Heater": ("has_water_heater", 40.0),
+ "Microwave": ("has_microwave", 30.0),
+ "Mixer": ("has_mixer", 95.0),
+ "Laptop": ("has_laptop", 40.0),
+ }
+
+ for name, (col, target) in appliances.items():
+ if col in df.columns:
+ actual = (df[col].sum() / len(df)) * 100
+ deviation = abs(actual - target)
+ status = "✅" if deviation < 2 else "⚠️" if deviation < 5 else "❌"
+ print(
+ f" {status} {name:20s}: Target {target:5.1f}% | Actual {actual:5.2f}% | Δ {deviation:4.2f}%"
+ )
+
+ # 3. Consumption Statistics
+ print(f"\n⚡ MONTHLY CONSUMPTION STATISTICS")
+ print(f" Mean: {df['total_kwh_monthly'].mean():6.2f} kWh")
+ print(f" Median: {df['total_kwh_monthly'].median():6.2f} kWh")
+ print(f" Std Dev: {df['total_kwh_monthly'].std():6.2f} kWh")
+ print(f" Min: {df['total_kwh_monthly'].min():6.2f} kWh")
+ print(f" Max: {df['total_kwh_monthly'].max():6.2f} kWh")
+ print(f" 25th %ile: {df['total_kwh_monthly'].quantile(0.25):6.2f} kWh")
+ print(f" 75th %ile: {df['total_kwh_monthly'].quantile(0.75):6.2f} kWh")
+
+ # 4. Real-World Benchmark Comparison
+ print(f"\n🌍 REAL-WORLD VALIDATION")
+ print(f" Kerala Average (KSEB Data 2024): ~300-500 kWh/month")
+ print(f" Synthetic Dataset Mean: {df['total_kwh_monthly'].mean():.2f} kWh/month")
+
+ # Realistic range check
+ realistic_range = df[
+ (df["total_kwh_monthly"] >= 100) & (df["total_kwh_monthly"] <= 2000)
+ ]
+ realistic_pct = (len(realistic_range) / len(df)) * 100
+ print(f" Households in Realistic Range (100-2000 kWh): {realistic_pct:.2f}%")
+
+ # 5. Kerala Context Validation
+ print(f"\n🌴 KERALA-SPECIFIC CONTEXT VALIDATION")
+
+ # Location distribution
+ urban_pct = (df[df["location_type"] == "urban"].shape[0] / len(df)) * 100
+ rural_pct = (df[df["location_type"] == "rural"].shape[0] / len(df)) * 100
+ print(f" Urban vs Rural: {urban_pct:.1f}% / {rural_pct:.1f}% (Target: 60/40)")
+
+ # AC efficiency in rural areas
+ if "ac_real_efficiency_factor" in df.columns:
+ rural_ac = df[(df["location_type"] == "rural") & (df["has_ac"] == 1)]
+ urban_ac = df[(df["location_type"] == "urban") & (df["has_ac"] == 1)]
+ if len(rural_ac) > 0 and len(urban_ac) > 0:
+ rural_eff = rural_ac["ac_real_efficiency_factor"].mean()
+ urban_eff = urban_ac["ac_real_efficiency_factor"].mean()
+ print(f" AC Efficiency: Rural {rural_eff:.3f} vs Urban {urban_eff:.3f}")
+ print(
+ f" Rural Penalty: {((urban_eff - rural_eff) / urban_eff * 100):.1f}% (Target: ~10%)"
+ )
+
+ # Fridge aging
+ if "fridge_real_efficiency_factor" in df.columns and "fridge_age" in df.columns:
+ old_fridges = df[(df["has_refrigerator"] == 1) & (df["fridge_age"] >= 10)]
+ if len(old_fridges) > 0:
+ old_eff = old_fridges["fridge_real_efficiency_factor"].mean()
+ new_fridges = df[(df["has_refrigerator"] == 1) & (df["fridge_age"] <= 2)]
+ if len(new_fridges) > 0:
+ new_eff = new_fridges["fridge_real_efficiency_factor"].mean()
+ print(
+ f" Fridge Degradation: New {new_eff:.3f} vs Old(10y) {old_eff:.3f}"
+ )
+
+ # 6. Model Training Accuracy
+ print(f"\n🧠 MODEL TRAINING ACCURACY (From Evaluation Files)")
+
+ models_dir = "models/"
+ test_appliances = [
+ ("ac", "AC"),
+ ("fridge", "Refrigerator"),
+ ("washing_machine", "Washing Machine"),
+ ("ceiling_fan", "Ceiling Fan"),
+ ("water_pump", "Water Pump"),
+ ]
+
+ for model_name, display_name in test_appliances:
+ try:
+ eval_df = pd.read_csv(f"{models_dir}{model_name}_evaluation.csv")
+
+ # Calculate metrics
+ actual = eval_df["actual"]
+ predicted = eval_df["predicted"]
+
+ # R² Score
+ ss_res = np.sum((actual - predicted) ** 2)
+ ss_tot = np.sum((actual - actual.mean()) ** 2)
+ r2 = 1 - (ss_res / ss_tot)
+
+ # MAPE
+ mape = np.mean(np.abs((actual - predicted) / actual)) * 100
+
+ # MAE
+ mae = np.mean(np.abs(actual - predicted))
+
+ print(
+ f" {display_name:20s}: R²={r2:.4f} | MAPE={mape:5.2f}% | MAE={mae:5.2f} kWh"
+ )
+
+ except FileNotFoundError:
+ print(f" {display_name:20s}: Evaluation file not found")
+
+ # 7. Physics Validation
+ print(f"\n⚙️ PHYSICS-INFORMED VALIDATION")
+
+ # Check if efficiency factors are within realistic bounds
+ if "ac_real_efficiency_factor" in df.columns:
+ ac_users = df[df["has_ac"] == 1]
+ eff_min = ac_users["ac_real_efficiency_factor"].min()
+ eff_max = ac_users["ac_real_efficiency_factor"].max()
+ eff_mean = ac_users["ac_real_efficiency_factor"].mean()
+ print(
+ f" AC Efficiency Range: {eff_min:.3f} - {eff_max:.3f} (Mean: {eff_mean:.3f})"
+ )
+ print(
+ f" Within Physics Bounds (0.6-1.1): {'✅' if eff_min >= 0.6 and eff_max <= 1.1 else '❌'}"
+ )
+
+ # Check hours are realistic
+ if "ac_real_effective_hours" in df.columns:
+ ac_users = df[df["has_ac"] == 1]
+ hours_mean = ac_users["ac_real_effective_hours"].mean()
+ hours_max = ac_users["ac_real_effective_hours"].max()
+ print(f" AC Usage Hours: Mean {hours_mean:.2f}h | Max {hours_max:.2f}h")
+ print(f" Within 24h Limit: {'✅' if hours_max <= 24 else '❌'}")
+
+ # 8. Data Quality Score
+ print(f"\n📈 OVERALL DATA QUALITY SCORE")
+
+ quality_checks = []
+
+ # Check 1: Penetration accuracy
+ penetration_deviations = []
+ for name, (col, target) in appliances.items():
+ if col in df.columns:
+ actual = (df[col].sum() / len(df)) * 100
+ deviation = abs(actual - target)
+ penetration_deviations.append(deviation)
+ avg_pen_dev = np.mean(penetration_deviations)
+ pen_score = max(0, 100 - (avg_pen_dev * 10))
+ quality_checks.append(("Penetration Accuracy", pen_score))
+
+ # Check 2: Consumption realism (comparing to 300-500 kWh average)
+ median_consumption = df["total_kwh_monthly"].median()
+ consumption_deviation = abs(median_consumption - 400) / 400 * 100
+ cons_score = max(0, 100 - consumption_deviation)
+ quality_checks.append(("Consumption Realism", cons_score))
+
+ # Check 3: Data range validity
+ valid_range = df[
+ (df["total_kwh_monthly"] >= 100) & (df["total_kwh_monthly"] <= 2000)
+ ]
+ range_score = (len(valid_range) / len(df)) * 100
+ quality_checks.append(("Data Range Validity", range_score))
+
+ # Check 4: Physics constraints
+ physics_violations = 0
+ if "ac_real_effective_hours" in df.columns:
+ physics_violations += len(df[df["ac_real_effective_hours"] > 24])
+ physics_score = max(0, 100 - (physics_violations / len(df) * 1000))
+ quality_checks.append(("Physics Constraints", physics_score))
+
+ for check_name, score in quality_checks:
+ status = "🟢" if score >= 90 else "🟡" if score >= 75 else "🔴"
+ print(f" {status} {check_name:25s}: {score:.1f}/100")
+
+ overall_score = np.mean([score for _, score in quality_checks])
+ print(f"\n {'='*50}")
+ print(f" OVERALL QUALITY SCORE: {overall_score:.1f}/100")
+ print(f" {'='*50}")
+
+ # 9. Summary
+ print(f"\n✅ DATASET VALIDATION SUMMARY")
+ if overall_score >= 90:
+ print(" Status: EXCELLENT - Dataset is highly accurate and realistic")
+ elif overall_score >= 75:
+ print(" Status: GOOD - Dataset is suitable for training with minor issues")
+ elif overall_score >= 60:
+ print(" Status: FAIR - Dataset has some accuracy issues")
+ else:
+ print(" Status: NEEDS IMPROVEMENT - Dataset requires refinement")
+
+ print(f"\n Key Strengths:")
+ print(f" ✓ Physics-informed generation with Kerala context")
+ print(f" ✓ Realistic appliance penetration rates")
+ print(f" ✓ Comprehensive multi-appliance coverage (22 appliances)")
+ print(f" ✓ Hidden variables (efficiency, hours) for AI learning")
+ print(f" ✓ Regional factors (rural penalty, humidity, aging)")
+
+ print(f"\n Validation Notes:")
+ print(
+ f" • Dataset mean ({df['total_kwh_monthly'].mean():.0f} kWh) is higher than"
+ )
+ print(f" Kerala average due to inclusion of high-consumption households")
+ print(f" • This provides diverse training data for all consumption levels")
+ print(f" • Model learns patterns across full spectrum of usage")
+
+ print(f"\n{'='*70}\n")
+
+
+if __name__ == "__main__":
+ analyze_dataset()
diff --git a/tests/analysis/analyze_tv.py b/tests/analysis/analyze_tv.py
new file mode 100644
index 0000000000000000000000000000000000000000..b80d9be45c0637bd0a01ec412ee59917a0472321
--- /dev/null
+++ b/tests/analysis/analyze_tv.py
@@ -0,0 +1,35 @@
+import pandas as pd
+
+df = pd.read_csv("kerala_smartwatt_ai.csv")
+
+print("\n" + "=" * 60)
+print("TV CONSUMPTION ANALYSIS")
+print("=" * 60)
+
+print("\n[1] TV Usage Statistics:")
+print(f"Average hours/day: {df['television_real_effective_hours'].mean():.1f}h")
+print(f"Average kWh/day: {df['television_kwh'].mean() / 30:.2f}")
+print(f"Average kWh/month: {df['television_kwh'].mean():.2f}")
+
+print("\n[2] TV Size Distribution:")
+print(df["tv_size"].value_counts())
+
+print("\n[3] TV Type Distribution:")
+print(df["television_type"].value_counts())
+
+print("\n[4] Sample TV Data (first 10 rows):")
+cols = [
+ "tv_size",
+ "television_type",
+ "television_real_effective_hours",
+ "television_kwh",
+]
+print(df[cols].head(10))
+
+print("\n[5] Physics Calculation Check:")
+print("For 43-inch LED TV:")
+print(f" Physics watts: 43 * 2.5 = {43 * 2.5:.0f}W")
+print(f" At 5 hours/day: {43 * 2.5 * 5 / 1000:.2f} kWh/day")
+print(f" Monthly: {43 * 2.5 * 5 * 30 / 1000:.2f} kWh/month")
+
+print("\n" + "=" * 60)
diff --git a/tests/analysis/analyze_ui_training_alignment.py b/tests/analysis/analyze_ui_training_alignment.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c8a7a0701bc4b5df17cd37a1fe010cf39fd98b5
--- /dev/null
+++ b/tests/analysis/analyze_ui_training_alignment.py
@@ -0,0 +1,372 @@
+"""
+Deep analysis of UI Input fields vs Training Script columns
+Checks for exact alignment between schemas.py and train.py
+"""
+
+from typing import Dict, List, Set
+
+import pandas as pd
+
+# UI Input Fields from schemas.py
+UI_FIELDS = {
+ "AC": {
+ "base": ["season", "location_type", "n_occupants"],
+ "specific": [
+ "ac_tonnage",
+ "ac_star_rating",
+ "num_ac_units",
+ "ac_type",
+ "ac_usage_pattern",
+ "ac_hours_per_day",
+ ],
+ },
+ "Fridge": {
+ "base": ["season", "location_type", "n_occupants"],
+ "specific": [
+ "fridge_capacity_liters",
+ "fridge_age_years",
+ "fridge_star_rating",
+ "fridge_type",
+ "fridge_hours_per_day",
+ ],
+ },
+ "Washing Machine": {
+ "base": ["season", "location_type", "n_occupants"],
+ "specific": [
+ "wm_capacity_kg",
+ "wm_star_rating",
+ "wm_type",
+ "wm_cycles_per_week",
+ ],
+ },
+ "Ceiling Fan": {
+ "base": ["season", "location_type", "n_occupants"],
+ "specific": [
+ "num_ceiling_fans",
+ "fan_star_rating",
+ "fan_type",
+ "fan_hours_per_day",
+ ],
+ },
+ "Television": {
+ "base": ["season", "location_type", "n_occupants"],
+ "specific": [
+ "tv_size_inches",
+ "num_televisions",
+ "tv_type",
+ "tv_hours_per_day",
+ ],
+ },
+ "Water Heater": {
+ "base": ["season", "location_type", "n_occupants"],
+ "specific": [
+ "water_heater_capacity_liters",
+ "water_heater_type",
+ "water_heater_usage_hours",
+ ],
+ },
+ "Water Pump": {
+ "base": ["season", "location_type", "n_occupants"],
+ "specific": ["water_pump_hp", "water_pump_usage_hours_per_day"],
+ },
+ "Lighting": {
+ "base": ["season", "location_type", "n_occupants"],
+ "specific": [
+ "num_units",
+ "light_hours_per_day",
+ "num_led_lights",
+ "num_cfl_bulbs",
+ "num_tube_lights",
+ ],
+ },
+}
+
+# Training Features from train.py (updated version)
+TRAINING_FEATURES = {
+ "ac": [
+ "n_occupants",
+ "total_kwh_monthly",
+ "ac_tonnage",
+ "ac_star_rating",
+ "ac_type",
+ "ac_usage_pattern",
+ "location_type",
+ ],
+ "fridge": [
+ "n_occupants",
+ "total_kwh_monthly",
+ "fridge_capacity",
+ "fridge_age",
+ "fridge_type",
+ "location_type",
+ ],
+ "ceiling_fan": [
+ "n_occupants",
+ "total_kwh_monthly",
+ "ceiling_fan_age",
+ "fan_type",
+ "num_fans",
+ ],
+ "television": ["n_occupants", "total_kwh_monthly", "television_type", "tv_size"],
+ "washing_machine": [
+ "n_occupants",
+ "total_kwh_monthly",
+ "wm_type",
+ "wm_cycles_per_week",
+ ],
+ "water_pump": ["n_occupants", "total_kwh_monthly", "water_pump_hp"],
+ "water_heater": ["n_occupants", "total_kwh_monthly", "season"],
+ "led_lights": ["n_occupants", "total_kwh_monthly"],
+ "cfl_lights": ["n_occupants", "total_kwh_monthly"],
+ "tube_lights": ["n_occupants", "total_kwh_monthly"],
+}
+
+# Field name mappings (UI field -> Dataset column name)
+FIELD_MAPPINGS = {
+ # AC
+ "ac_tonnage": "ac_tonnage",
+ "ac_star_rating": "ac_star_rating",
+ "ac_type": "ac_type",
+ "ac_usage_pattern": "ac_usage_pattern",
+ # Fridge
+ "fridge_capacity_liters": "fridge_capacity", # MISMATCH
+ "fridge_age_years": "fridge_age", # MISMATCH
+ "fridge_type": "fridge_type",
+ # Fan
+ "num_ceiling_fans": "num_fans", # MISMATCH
+ "fan_type": "fan_type",
+ # TV
+ "tv_size_inches": "tv_size", # MISMATCH
+ "tv_type": "television_type", # MISMATCH
+ # Washing Machine
+ "wm_type": "wm_type",
+ "wm_cycles_per_week": "wm_cycles_per_week",
+ # Water Pump
+ "water_pump_hp": "water_pump_hp",
+}
+
+
+def analyze_alignment():
+ print("=" * 80)
+ print("DEEP ANALYSIS: UI INPUTS vs TRAINING FEATURES")
+ print("=" * 80)
+
+ # Load actual dataset columns
+ try:
+ df = pd.read_csv("kerala_smartwatt_ai.csv")
+ dataset_cols = set(df.columns)
+ print(f"\n✅ Dataset loaded: {len(dataset_cols)} columns found\n")
+ except Exception as e:
+ print(f"\n❌ Error loading dataset: {e}\n")
+ dataset_cols = set()
+
+ issues = []
+
+ # AC Analysis
+ print("\n" + "─" * 80)
+ print("🔌 AC (Air Conditioner)")
+ print("─" * 80)
+ ui_ac = UI_FIELDS["AC"]["base"] + UI_FIELDS["AC"]["specific"]
+ train_ac = TRAINING_FEATURES["ac"]
+
+ print(f"UI sends {len(ui_ac)} fields:")
+ for field in ui_ac:
+ status = (
+ "✓"
+ if field in dataset_cols or FIELD_MAPPINGS.get(field) in dataset_cols
+ else "✗"
+ )
+ mapped = FIELD_MAPPINGS.get(field, field)
+ used_in_training = "USED" if mapped in train_ac else "NOT USED"
+ print(f" {status} {field:35s} -> {mapped:25s} [{used_in_training}]")
+ if mapped not in train_ac and field not in [
+ "season",
+ "num_ac_units",
+ "ac_hours_per_day",
+ ]:
+ issues.append(
+ f"AC: UI field '{field}' (maps to '{mapped}') not used in training"
+ )
+
+ print(f"\nTraining uses {len(train_ac)} features: {train_ac}")
+
+ # Fridge Analysis
+ print("\n" + "─" * 80)
+ print("🧊 Fridge (Refrigerator)")
+ print("─" * 80)
+ ui_fridge = UI_FIELDS["Fridge"]["base"] + UI_FIELDS["Fridge"]["specific"]
+ train_fridge = TRAINING_FEATURES["fridge"]
+
+ print(f"UI sends {len(ui_fridge)} fields:")
+ for field in ui_fridge:
+ status = (
+ "✓"
+ if field in dataset_cols or FIELD_MAPPINGS.get(field) in dataset_cols
+ else "✗"
+ )
+ mapped = FIELD_MAPPINGS.get(field, field)
+ used_in_training = "USED" if mapped in train_fridge else "NOT USED"
+ print(f" {status} {field:35s} -> {mapped:25s} [{used_in_training}]")
+ if mapped not in train_fridge and field not in [
+ "season",
+ "fridge_star_rating",
+ "fridge_hours_per_day",
+ ]:
+ issues.append(
+ f"Fridge: UI field '{field}' (maps to '{mapped}') not used in training"
+ )
+
+ print(f"\nTraining uses {len(train_fridge)} features: {train_fridge}")
+
+ # Ceiling Fan Analysis
+ print("\n" + "─" * 80)
+ print("🌀 Ceiling Fan")
+ print("─" * 80)
+ ui_fan = UI_FIELDS["Ceiling Fan"]["base"] + UI_FIELDS["Ceiling Fan"]["specific"]
+ train_fan = TRAINING_FEATURES["ceiling_fan"]
+
+ print(f"UI sends {len(ui_fan)} fields:")
+ for field in ui_fan:
+ status = (
+ "✓"
+ if field in dataset_cols or FIELD_MAPPINGS.get(field) in dataset_cols
+ else "✗"
+ )
+ mapped = FIELD_MAPPINGS.get(field, field)
+ used_in_training = "USED" if mapped in train_fan else "NOT USED"
+ print(f" {status} {field:35s} -> {mapped:25s} [{used_in_training}]")
+ if mapped not in train_fan and field not in [
+ "season",
+ "location_type",
+ "fan_star_rating",
+ "fan_hours_per_day",
+ ]:
+ issues.append(
+ f"Fan: UI field '{field}' (maps to '{mapped}') not used in training"
+ )
+
+ print(f"\nTraining uses {len(train_fan)} features: {train_fan}")
+
+ # Television Analysis
+ print("\n" + "─" * 80)
+ print("📺 Television")
+ print("─" * 80)
+ ui_tv = UI_FIELDS["Television"]["base"] + UI_FIELDS["Television"]["specific"]
+ train_tv = TRAINING_FEATURES["television"]
+
+ print(f"UI sends {len(ui_tv)} fields:")
+ for field in ui_tv:
+ status = (
+ "✓"
+ if field in dataset_cols or FIELD_MAPPINGS.get(field) in dataset_cols
+ else "✗"
+ )
+ mapped = FIELD_MAPPINGS.get(field, field)
+ used_in_training = "USED" if mapped in train_tv else "NOT USED"
+ print(f" {status} {field:35s} -> {mapped:25s} [{used_in_training}]")
+ if mapped not in train_tv and field not in [
+ "season",
+ "location_type",
+ "num_televisions",
+ "tv_hours_per_day",
+ ]:
+ issues.append(
+ f"TV: UI field '{field}' (maps to '{mapped}') not used in training"
+ )
+
+ print(f"\nTraining uses {len(train_tv)} features: {train_tv}")
+
+ # Washing Machine Analysis
+ print("\n" + "─" * 80)
+ print("🧺 Washing Machine")
+ print("─" * 80)
+ ui_wm = (
+ UI_FIELDS["Washing Machine"]["base"] + UI_FIELDS["Washing Machine"]["specific"]
+ )
+ train_wm = TRAINING_FEATURES["washing_machine"]
+
+ print(f"UI sends {len(ui_wm)} fields:")
+ for field in ui_wm:
+ status = (
+ "✓"
+ if field in dataset_cols or FIELD_MAPPINGS.get(field) in dataset_cols
+ else "✗"
+ )
+ mapped = FIELD_MAPPINGS.get(field, field)
+ used_in_training = "USED" if mapped in train_wm else "NOT USED"
+ print(f" {status} {field:35s} -> {mapped:25s} [{used_in_training}]")
+ if mapped not in train_wm and field not in [
+ "season",
+ "location_type",
+ "wm_capacity_kg",
+ "wm_star_rating",
+ ]:
+ issues.append(
+ f"WM: UI field '{field}' (maps to '{mapped}') not used in training"
+ )
+
+ print(f"\nTraining uses {len(train_wm)} features: {train_wm}")
+
+ # Water Pump Analysis
+ print("\n" + "─" * 80)
+ print("💧 Water Pump")
+ print("─" * 80)
+ ui_pump = UI_FIELDS["Water Pump"]["base"] + UI_FIELDS["Water Pump"]["specific"]
+ train_pump = TRAINING_FEATURES["water_pump"]
+
+ print(f"UI sends {len(ui_pump)} fields:")
+ for field in ui_pump:
+ status = (
+ "✓"
+ if field in dataset_cols or FIELD_MAPPINGS.get(field) in dataset_cols
+ else "✗"
+ )
+ mapped = FIELD_MAPPINGS.get(field, field)
+ used_in_training = "USED" if mapped in train_pump else "NOT USED"
+ print(f" {status} {field:35s} -> {mapped:25s} [{used_in_training}]")
+ if mapped not in train_pump and field not in [
+ "season",
+ "location_type",
+ "water_pump_usage_hours_per_day",
+ ]:
+ issues.append(
+ f"Pump: UI field '{field}' (maps to '{mapped}') not used in training"
+ )
+
+ print(f"\nTraining uses {len(train_pump)} features: {train_pump}")
+
+ # Summary
+ print("\n" + "=" * 80)
+ print("📊 SUMMARY")
+ print("=" * 80)
+
+ if issues:
+ print(f"\n⚠️ Found {len(issues)} alignment issues:\n")
+ for i, issue in enumerate(issues, 1):
+ print(f"{i:2d}. {issue}")
+ else:
+ print(
+ "\n✅ Perfect alignment! All UI fields are properly mapped and used in training."
+ )
+
+ # Check dataset columns
+ print("\n" + "=" * 80)
+ print("🗂️ DATASET COLUMN CHECK")
+ print("=" * 80)
+
+ required_training_cols = set()
+ for feats in TRAINING_FEATURES.values():
+ required_training_cols.update(feats)
+
+ missing_cols = required_training_cols - dataset_cols
+ if missing_cols:
+ print(f"\n❌ Missing {len(missing_cols)} required columns in dataset:")
+ for col in sorted(missing_cols):
+ print(f" • {col}")
+ print("\n⚠️ You need to regenerate the dataset with: python newdataset.py")
+ else:
+ print("\n✅ All training features exist in the dataset!")
+
+
+if __name__ == "__main__":
+ analyze_alignment()
diff --git a/tests/analysis/check_columns.py b/tests/analysis/check_columns.py
new file mode 100644
index 0000000000000000000000000000000000000000..817179600aa63c6f76c9cfac1524fe14a0e921d8
--- /dev/null
+++ b/tests/analysis/check_columns.py
@@ -0,0 +1,28 @@
+import pandas as pd
+
+df = pd.read_csv("kerala_smartwatt_ai.csv")
+print(f"Total columns: {len(df.columns)}")
+
+new_cols = [
+ "ac_type",
+ "ac_usage_pattern",
+ "fan_type",
+ "fridge_type",
+ "num_fans",
+ "tv_size",
+ "water_pump_hp",
+ "wm_cycles_per_week",
+ "wm_type",
+]
+
+print("\n🔍 Checking new columns:")
+for col in new_cols:
+ status = "✅ FOUND" if col in df.columns else "❌ MISSING"
+ print(f" {col:25s} {status}")
+
+print(f"\n📊 First few rows of new columns:")
+found_cols = [col for col in new_cols if col in df.columns]
+if found_cols:
+ print(df[found_cols].head())
+else:
+ print(" No new columns found!")
diff --git a/tests/analysis/check_training_columns.py b/tests/analysis/check_training_columns.py
new file mode 100644
index 0000000000000000000000000000000000000000..85b648a291cee4ff43e98fc13c768dc0e52f8736
--- /dev/null
+++ b/tests/analysis/check_training_columns.py
@@ -0,0 +1,40 @@
+import pandas as pd
+
+df = pd.read_csv("kerala_smartwatt_ai.csv")
+
+print("=" * 80)
+print("DATASET COLUMN NAME VERIFICATION")
+print("=" * 80)
+
+# Training features used in train.py
+training_features = {
+ "Common": ["n_occupants", "location_type", "season"],
+ "AC": ["ac_tonnage", "ac_star_rating", "ac_type", "ac_usage_pattern"],
+ "Fridge": ["fridge_capacity", "fridge_age", "fridge_type"],
+ "Fan": ["fan_type", "num_fans"],
+ "TV": ["television_type", "tv_size"],
+ "WM": ["wm_type", "wm_cycles_per_week"],
+ "Pump": ["water_pump_hp"],
+}
+
+print("\n✅ Checking if training features exist in dataset:\n")
+
+all_exist = True
+for category, features in training_features.items():
+ print(f"{category}:")
+ for feat in features:
+ exists = feat in df.columns
+ status = "✅" if exists else "❌"
+ print(f" {status} {feat}")
+ if not exists:
+ all_exist = False
+ print()
+
+if all_exist:
+ print("=" * 80)
+ print("✅ ALL TRAINING FEATURES EXIST IN DATASET!")
+ print("=" * 80)
+else:
+ print("=" * 80)
+ print("❌ SOME FEATURES MISSING - CHECK COLUMN NAMES")
+ print("=" * 80)
diff --git a/tests/analysis/check_ui_backend_mapping.py b/tests/analysis/check_ui_backend_mapping.py
new file mode 100644
index 0000000000000000000000000000000000000000..15bba55bbd5e5f6a5b72fb421968c800615da10b
--- /dev/null
+++ b/tests/analysis/check_ui_backend_mapping.py
@@ -0,0 +1,292 @@
+"""
+UI to Backend Field Mapping Checker
+Validates that UI field names match backend schemas
+"""
+
+# UI field names (from usageForms.ts)
+UI_FIELDS = {
+ "ac": {
+ "base": ["n_occupants", "season", "location_type"],
+ "specific": ["ac_star", "ac_tonnage", "ac_type", "ac_age"],
+ "derived": ["ac_hours", "ac_pattern", "ac_usage_pattern"],
+ },
+ "fridge": {
+ "base": ["n_occupants", "season", "location_type"],
+ "specific": ["fridge_star", "fridge_capacity", "fridge_type", "fridge_age"],
+ "derived": ["fridge_hours", "fridge_pattern"],
+ },
+ "wm": {
+ "base": ["n_occupants", "season", "location_type"],
+ "specific": ["wm_type", "wm_capacity", "wm_star", "wm_age"],
+ "derived": ["wm_hours", "wm_pattern", "wm_cycles_per_week"],
+ },
+ "geyser": {
+ "base": ["n_occupants", "season", "location_type"],
+ "specific": ["geyser_type", "geyser_capacity", "geyser_age"],
+ "derived": ["geyser_hours", "geyser_pattern"],
+ },
+ "fan": {
+ "base": ["n_occupants", "season", "location_type"],
+ "specific": ["fan_type", "num_fans"],
+ "derived": ["fan_hours", "fan_pattern"],
+ },
+ "tv": {
+ "base": ["n_occupants", "season", "location_type"],
+ "specific": ["tv_type", "tv_size"],
+ "derived": ["tv_hours", "tv_pattern"],
+ },
+ "pump": {
+ "base": ["n_occupants", "season", "location_type"],
+ "specific": ["pump_hp"],
+ "derived": ["pump_hours", "pump_pattern"],
+ },
+}
+
+# Backend expected fields (from schemas.py)
+BACKEND_SCHEMAS = {
+ "ACInput": {
+ "base": ["n_occupants", "season", "location_type"],
+ "required": [
+ "ac_tonnage",
+ "ac_star_rating",
+ "ac_type",
+ "ac_usage_pattern",
+ "ac_hours_per_day",
+ ],
+ "optional": ["num_ac_units"],
+ },
+ "FridgeInput": {
+ "base": ["n_occupants", "season", "location_type"],
+ "required": [
+ "fridge_capacity_liters",
+ "fridge_age_years",
+ "fridge_star_rating",
+ "fridge_type",
+ ],
+ "optional": ["fridge_hours_per_day"],
+ },
+ "WashingMachineInput": {
+ "base": ["n_occupants", "season", "location_type"],
+ "required": [
+ "wm_capacity_kg",
+ "wm_star_rating",
+ "wm_type",
+ "wm_cycles_per_week",
+ ],
+ "optional": [],
+ },
+ "WaterHeaterInput": {
+ "base": ["n_occupants", "season", "location_type"],
+ "required": [
+ "water_heater_capacity_liters",
+ "water_heater_type",
+ "water_heater_usage_hours",
+ ],
+ "optional": [],
+ },
+ "CeilingFanInput": {
+ "base": ["n_occupants", "season", "location_type"],
+ "required": ["num_ceiling_fans", "fan_type", "fan_hours_per_day"],
+ "optional": ["fan_star_rating"],
+ },
+ "TelevisionInput": {
+ "base": ["n_occupants", "season", "location_type"],
+ "required": ["tv_size_inches", "tv_type", "tv_hours_per_day"],
+ "optional": ["num_televisions"],
+ },
+ "WaterPumpInput": {
+ "base": ["n_occupants", "season", "location_type"],
+ "required": ["water_pump_hp", "water_pump_usage_hours_per_day"],
+ "optional": [],
+ },
+}
+
+# Field name transformations (UI -> Backend)
+FIELD_MAPPINGS = {
+ # AC
+ "ac_star": "ac_star_rating",
+ "ac_hours": "ac_hours_per_day",
+ # Fridge
+ "fridge_star": "fridge_star_rating",
+ "fridge_capacity": "fridge_capacity_liters",
+ "fridge_age": "fridge_age_years",
+ "fridge_hours": "fridge_hours_per_day",
+ # Washing Machine
+ "wm_star": "wm_star_rating",
+ "wm_capacity": "wm_capacity_kg",
+ # Geyser/Water Heater
+ "geyser_type": "water_heater_type",
+ "geyser_capacity": "water_heater_capacity_liters",
+ "geyser_hours": "water_heater_usage_hours",
+ # Fan
+ "num_fans": "num_ceiling_fans",
+ "fan_hours": "fan_hours_per_day",
+ # TV
+ "tv_size": "tv_size_inches",
+ "tv_hours": "tv_hours_per_day",
+ # Pump
+ "pump_hp": "water_pump_hp",
+ "pump_hours": "water_pump_usage_hours_per_day",
+}
+
+
+def check_field_mappings():
+ print("=" * 80)
+ print("UI TO BACKEND FIELD MAPPING VALIDATION")
+ print("=" * 80)
+
+ issues = []
+ warnings = []
+
+ # Check AC
+ print("\n[AC / AIR CONDITIONER]")
+ print("-" * 80)
+ ui_fields = UI_FIELDS["ac"]
+ backend = BACKEND_SCHEMAS["ACInput"]
+
+ print("UI Fields:")
+ all_ui = ui_fields["base"] + ui_fields["specific"] + ui_fields["derived"]
+ for field in all_ui:
+ backend_field = FIELD_MAPPINGS.get(field, field)
+ in_backend = backend_field in (
+ backend["base"] + backend["required"] + backend["optional"]
+ )
+ status = "[OK]" if in_backend else "[MISSING]"
+ print(f" {status} {field:25s} -> {backend_field:30s}")
+ if not in_backend and field not in ["ac_age", "ac_pattern"]:
+ issues.append(f"AC: {field} -> {backend_field} not in backend schema")
+
+ print("\nBackend Required Fields:")
+ for field in backend["required"]:
+ # Reverse lookup
+ ui_field = next((k for k, v in FIELD_MAPPINGS.items() if v == field), field)
+ in_ui = ui_field in all_ui or field in all_ui
+ status = "[OK]" if in_ui else "[MISSING]"
+ print(f" {status} {field:30s} <- {ui_field:25s}")
+ if not in_ui:
+ warnings.append(f"AC: Backend expects {field} but not in UI")
+
+ # Check Fridge
+ print("\n[FRIDGE / REFRIGERATOR]")
+ print("-" * 80)
+ ui_fields = UI_FIELDS["fridge"]
+ backend = BACKEND_SCHEMAS["FridgeInput"]
+
+ print("UI Fields:")
+ all_ui = ui_fields["base"] + ui_fields["specific"] + ui_fields["derived"]
+ for field in all_ui:
+ backend_field = FIELD_MAPPINGS.get(field, field)
+ in_backend = backend_field in (
+ backend["base"] + backend["required"] + backend["optional"]
+ )
+ status = "[OK]" if in_backend else "[MISSING]"
+ print(f" {status} {field:25s} -> {backend_field:30s}")
+ if not in_backend and field not in ["fridge_pattern"]:
+ issues.append(f"Fridge: {field} -> {backend_field} not in backend schema")
+
+ print("\nBackend Required Fields:")
+ for field in backend["required"]:
+ ui_field = next((k for k, v in FIELD_MAPPINGS.items() if v == field), field)
+ in_ui = ui_field in all_ui or field in all_ui
+ status = "[OK]" if in_ui else "[MISSING]"
+ print(f" {status} {field:30s} <- {ui_field:25s}")
+ if not in_ui:
+ warnings.append(f"Fridge: Backend expects {field} but not in UI")
+
+ # Check Washing Machine
+ print("\n[WASHING MACHINE]")
+ print("-" * 80)
+ ui_fields = UI_FIELDS["wm"]
+ backend = BACKEND_SCHEMAS["WashingMachineInput"]
+
+ print("UI Fields:")
+ all_ui = ui_fields["base"] + ui_fields["specific"] + ui_fields["derived"]
+ for field in all_ui:
+ backend_field = FIELD_MAPPINGS.get(field, field)
+ in_backend = backend_field in (
+ backend["base"] + backend["required"] + backend["optional"]
+ )
+ status = "[OK]" if in_backend else "[MISSING]"
+ print(f" {status} {field:25s} -> {backend_field:30s}")
+ if not in_backend and field not in ["wm_age", "wm_hours", "wm_pattern"]:
+ issues.append(f"WM: {field} -> {backend_field} not in backend schema")
+
+ print("\nBackend Required Fields:")
+ for field in backend["required"]:
+ ui_field = next((k for k, v in FIELD_MAPPINGS.items() if v == field), field)
+ in_ui = ui_field in all_ui or field in all_ui
+ status = "[OK]" if in_ui else "[MISSING]"
+ print(f" {status} {field:30s} <- {ui_field:25s}")
+ if not in_ui:
+ warnings.append(f"WM: Backend expects {field} but not in UI")
+
+ # Check Water Heater
+ print("\n[WATER HEATER / GEYSER]")
+ print("-" * 80)
+ ui_fields = UI_FIELDS["geyser"]
+ backend = BACKEND_SCHEMAS["WaterHeaterInput"]
+
+ print("UI Fields:")
+ all_ui = ui_fields["base"] + ui_fields["specific"] + ui_fields["derived"]
+ for field in all_ui:
+ backend_field = FIELD_MAPPINGS.get(field, field)
+ in_backend = backend_field in (
+ backend["base"] + backend["required"] + backend["optional"]
+ )
+ status = "[OK]" if in_backend else "[MISSING]"
+ print(f" {status} {field:25s} -> {backend_field:30s}")
+ if not in_backend and field not in ["geyser_age", "geyser_pattern"]:
+ issues.append(f"Geyser: {field} -> {backend_field} not in backend schema")
+
+ print("\nBackend Required Fields:")
+ for field in backend["required"]:
+ ui_field = next((k for k, v in FIELD_MAPPINGS.items() if v == field), field)
+ in_ui = ui_field in all_ui or field in all_ui
+ status = "[OK]" if in_ui else "[MISSING]"
+ print(f" {status} {field:30s} <- {ui_field:25s}")
+ if not in_ui:
+ warnings.append(f"Geyser: Backend expects {field} but not in UI")
+
+ # Summary
+ print("\n" + "=" * 80)
+ print("SUMMARY")
+ print("=" * 80)
+
+ if not issues and not warnings:
+ print("[SUCCESS] All UI fields map correctly to backend schemas!")
+ else:
+ if issues:
+ print(f"\n[ISSUES] {len(issues)} UI fields not in backend:")
+ for issue in issues:
+ print(f" - {issue}")
+
+ if warnings:
+ print(f"\n[WARNINGS] {len(warnings)} backend fields not in UI:")
+ for warning in warnings:
+ print(f" - {warning}")
+
+ print("\n" + "=" * 80)
+ print("KEY FIELD TRANSFORMATIONS")
+ print("=" * 80)
+ print("""
+UI Field Name Backend Expected Name
+------------- ---------------------
+ac_star -> ac_star_rating
+ac_hours -> ac_hours_per_day
+fridge_star -> fridge_star_rating
+fridge_capacity -> fridge_capacity_liters
+fridge_age -> fridge_age_years
+wm_star -> wm_star_rating
+wm_capacity -> wm_capacity_kg
+geyser_type -> water_heater_type
+geyser_capacity -> water_heater_capacity_liters
+pump_hp -> water_pump_hp
+tv_size -> tv_size_inches
+num_fans -> num_ceiling_fans
+
+IMPORTANT: Frontend must transform field names before sending to API!
+ """)
+
+
+if __name__ == "__main__":
+ check_field_mappings()
diff --git a/tests/analysis/check_ui_training_simple.py b/tests/analysis/check_ui_training_simple.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6e0ce2c5a9842eb338b8a496bc14a22a3cf6e30
--- /dev/null
+++ b/tests/analysis/check_ui_training_simple.py
@@ -0,0 +1,190 @@
+"""
+Simple UI to Training Column Mapping Validator (No emojis)
+"""
+
+import pandas as pd
+
+# Updated training features
+TRAINING_FEATURES = {
+ "ac": [
+ "n_occupants",
+ "season",
+ "location_type",
+ "ac_tonnage",
+ "ac_star_rating",
+ "ac_type",
+ "ac_usage_pattern",
+ ],
+ "fridge": [
+ "n_occupants",
+ "season",
+ "location_type",
+ "fridge_capacity",
+ "fridge_age",
+ "fridge_star_rating",
+ "fridge_type",
+ ],
+ "ceiling_fan": ["n_occupants", "season", "location_type", "fan_type", "num_fans"],
+ "television": [
+ "n_occupants",
+ "season",
+ "location_type",
+ "television_type",
+ "tv_size",
+ ],
+ "washing_machine": [
+ "n_occupants",
+ "season",
+ "location_type",
+ "wm_type",
+ "wm_capacity",
+ "wm_star_rating",
+ "wm_cycles_per_week",
+ ],
+ "water_pump": ["n_occupants", "season", "location_type", "water_pump_hp"],
+ "water_heater": [
+ "n_occupants",
+ "season",
+ "location_type",
+ "water_heater_type",
+ "water_heater_capacity",
+ ],
+ "iron": ["n_occupants", "season", "location_type"],
+ "kettle": ["n_occupants", "season", "location_type"],
+ "induction": ["n_occupants", "season", "location_type"],
+ "desktop": ["n_occupants", "season", "location_type"],
+ "microwave": ["n_occupants", "season", "location_type"],
+ "mixer": ["n_occupants", "season", "location_type"],
+ "rice_cooker": ["n_occupants", "season", "location_type"],
+ "toaster": ["n_occupants", "season", "location_type"],
+ "food_processor": ["n_occupants", "season", "location_type"],
+ "laptop": ["n_occupants", "season", "location_type"],
+ "hair_dryer": ["n_occupants", "season", "location_type"],
+ "vacuum": ["n_occupants", "season", "location_type"],
+ "led_lights": ["n_occupants", "season", "location_type"],
+ "cfl_lights": ["n_occupants", "season", "location_type"],
+ "tube_lights": ["n_occupants", "season", "location_type"],
+}
+
+# UI fields (excluding hours, patterns, total_units)
+UI_IMPORTANT_FIELDS = {
+ "ac": [
+ "n_occupants",
+ "season",
+ "location_type",
+ "ac_star",
+ "ac_tonnage",
+ "ac_type",
+ ],
+ "fridge": [
+ "n_occupants",
+ "season",
+ "location_type",
+ "fridge_star",
+ "fridge_capacity",
+ "fridge_type",
+ "fridge_age",
+ ],
+ "washing_machine": [
+ "n_occupants",
+ "season",
+ "location_type",
+ "wm_type",
+ "wm_capacity",
+ "wm_star",
+ ],
+ "water_heater": [
+ "n_occupants",
+ "season",
+ "location_type",
+ "geyser_type",
+ "geyser_capacity",
+ ],
+ "ceiling_fan": ["n_occupants", "season", "location_type", "fan_type", "num_fans"],
+ "television": ["n_occupants", "season", "location_type", "tv_type", "tv_size"],
+ "water_pump": ["n_occupants", "season", "location_type", "pump_hp"],
+}
+
+# Mapping UI field names to dataset column names
+FIELD_MAPPING = {
+ "ac_star": "ac_star_rating",
+ "fridge_star": "fridge_star_rating",
+ "wm_star": "wm_star_rating",
+ "geyser_type": "water_heater_type",
+ "geyser_capacity": "water_heater_capacity",
+ "tv_type": "television_type",
+ "pump_hp": "water_pump_hp",
+}
+
+
+def check_mapping():
+ print("=" * 80)
+ print("UI TO TRAINING MAPPING VALIDATION (UPDATED)")
+ print("=" * 80)
+
+ # Check dataset
+ try:
+ df = pd.read_csv("kerala_smartwatt_ai.csv")
+ dataset_cols = set(df.columns)
+ except:
+ print("[ERROR] Cannot load dataset")
+ return
+
+ total_ok = 0
+ total_missing = 0
+
+ for appliance, ui_fields in UI_IMPORTANT_FIELDS.items():
+ print(f"\n{'='*80}")
+ print(f"[{appliance.upper()}]")
+ print(f"{'='*80}")
+
+ training_fields = TRAINING_FEATURES.get(appliance, [])
+
+ print(f"\nUI Fields: {len(ui_fields)}")
+ print(f"Training Fields: {len(training_fields)}")
+
+ for ui_field in ui_fields:
+ # Map UI field to dataset column
+ dataset_field = FIELD_MAPPING.get(ui_field, ui_field)
+
+ # Check if in training
+ if dataset_field in training_fields or ui_field in training_fields:
+ print(f" [OK] {ui_field:25s} -> {dataset_field:30s}")
+ total_ok += 1
+ else:
+ print(f" [MISSING] {ui_field:25s} -> {dataset_field:30s}")
+ total_missing += 1
+
+ # Check for extra training fields
+ ui_mapped = set([FIELD_MAPPING.get(f, f) for f in ui_fields])
+ extra = set(training_fields) - ui_mapped
+ if extra:
+ print(f"\n [EXTRA IN TRAINING]: {extra}")
+
+ # Base field usage
+ print(f"\n{'='*80}")
+ print("[BASE FIELDS USAGE]")
+ print(f"{'='*80}")
+
+ for base_field in ["n_occupants", "season", "location_type"]:
+ count = sum(1 for feats in TRAINING_FEATURES.values() if base_field in feats)
+ print(f" {base_field:20s}: {count}/22 models")
+
+ # Summary
+ print(f"\n{'='*80}")
+ print("[SUMMARY]")
+ print(f"{'='*80}")
+ print(f"Total UI Fields Checked: {total_ok + total_missing}")
+ print(f"Mapped Correctly: {total_ok}")
+ print(f"Missing from Training: {total_missing}")
+
+ if total_missing == 0:
+ print("\n[SUCCESS] ALL UI FIELDS MAPPED TO TRAINING!")
+ else:
+ print(f"\n[WARNING] {total_missing} fields not in training")
+
+ print("=" * 80)
+
+
+if __name__ == "__main__":
+ check_mapping()
diff --git a/tests/analysis/check_unknowns.py b/tests/analysis/check_unknowns.py
new file mode 100644
index 0000000000000000000000000000000000000000..be0c5aa140c11955744ffdb516fd0c89398f2a64
--- /dev/null
+++ b/tests/analysis/check_unknowns.py
@@ -0,0 +1,16 @@
+import pandas as pd
+
+df = pd.read_csv("kerala_smartwatt_ai.csv")
+
+new_cols = ["ac_type", "ac_usage_pattern", "fan_type", "fridge_type", "wm_type"]
+
+print("=" * 60)
+print('CHECKING FOR "UNKNOWN" VALUES IN NEW COLUMNS')
+print("=" * 60)
+
+for col in new_cols:
+ print(f"\n📊 {col}:")
+ print(df[col].value_counts())
+ unknown_count = (df[col] == "unknown").sum()
+ unknown_pct = (unknown_count / len(df)) * 100
+ print(f" ⚠️ Unknown: {unknown_count} ({unknown_pct:.1f}%)")
diff --git a/tests/analysis/compare_ui_backend_fields.py b/tests/analysis/compare_ui_backend_fields.py
new file mode 100644
index 0000000000000000000000000000000000000000..50fa7ebe3ab31141b20539ef1c6bf1c06fb93dc2
--- /dev/null
+++ b/tests/analysis/compare_ui_backend_fields.py
@@ -0,0 +1,439 @@
+"""
+Compare appliance field names between Frontend UI and Backend training
+Identifies mismatches that could cause prediction errors
+"""
+
+import json
+
+import pandas as pd
+
+# Backend Training Appliances (from train.py)
+BACKEND_APPLIANCES = {
+ "ac": {
+ "features": ["ac_tonnage", "ac_star_rating"],
+ "targets": ["ac_real_efficiency_factor", "ac_real_effective_hours"],
+ "dataset_cols": [
+ "has_ac",
+ "ac_tonnage",
+ "ac_star_rating",
+ "ac_real_effective_hours",
+ "ac_real_efficiency_factor",
+ "ac_kwh",
+ ],
+ },
+ "fridge": {
+ "features": ["fridge_capacity", "fridge_age"],
+ "targets": ["fridge_real_efficiency_factor", "fridge_real_effective_hours"],
+ "dataset_cols": [
+ "has_refrigerator",
+ "fridge_capacity",
+ "fridge_age",
+ "fridge_real_effective_hours",
+ "fridge_real_efficiency_factor",
+ "fridge_kwh",
+ ],
+ },
+ "ceiling_fan": {
+ "features": ["ceiling_fan_age"],
+ "targets": [
+ "ceiling_fan_real_efficiency_factor",
+ "ceiling_fan_real_effective_hours",
+ ],
+ "dataset_cols": [
+ "has_ceiling_fan",
+ "ceiling_fan_age",
+ "ceiling_fan_real_effective_hours",
+ "ceiling_fan_real_efficiency_factor",
+ "ceiling_fan_kwh",
+ ],
+ },
+ "television": {
+ "features": ["television_type"],
+ "targets": [
+ "television_real_efficiency_factor",
+ "television_real_effective_hours",
+ ],
+ "dataset_cols": [
+ "has_television",
+ "television_type",
+ "television_real_effective_hours",
+ "television_real_efficiency_factor",
+ "television_kwh",
+ ],
+ },
+ "washing_machine": {
+ "features": [],
+ "targets": [
+ "washing_machine_real_efficiency_factor",
+ "washing_machine_real_effective_hours",
+ ],
+ "dataset_cols": [
+ "has_washing_machine",
+ "washing_machine_real_effective_hours",
+ "washing_machine_real_efficiency_factor",
+ "washing_machine_kwh",
+ ],
+ },
+ "water_pump": {
+ "features": [],
+ "targets": [
+ "water_pump_real_efficiency_factor",
+ "water_pump_real_effective_hours",
+ ],
+ "dataset_cols": [
+ "has_water_pump",
+ "water_pump_real_effective_hours",
+ "water_pump_real_efficiency_factor",
+ "water_pump_kwh",
+ ],
+ },
+ "water_heater": {
+ "features": ["season"],
+ "targets": [
+ "water_heater_real_efficiency_factor",
+ "water_heater_real_effective_hours",
+ ],
+ "dataset_cols": [
+ "has_water_heater",
+ "season",
+ "water_heater_real_effective_hours",
+ "water_heater_real_efficiency_factor",
+ "water_heater_kwh",
+ ],
+ },
+ "microwave": {
+ "features": [],
+ "targets": [
+ "microwave_real_efficiency_factor",
+ "microwave_real_effective_hours",
+ ],
+ "dataset_cols": [
+ "has_microwave",
+ "microwave_real_effective_hours",
+ "microwave_real_efficiency_factor",
+ "microwave_kwh",
+ ],
+ },
+ "led_lights": {
+ "features": [],
+ "targets": [
+ "led_lights_real_efficiency_factor",
+ "led_lights_real_effective_hours",
+ ],
+ "dataset_cols": [
+ "has_led_lights",
+ "led_lights_real_effective_hours",
+ "led_lights_real_efficiency_factor",
+ "led_lights_kwh",
+ ],
+ },
+ "cfl_lights": {
+ "features": [],
+ "targets": [
+ "cfl_lights_real_efficiency_factor",
+ "cfl_lights_real_effective_hours",
+ ],
+ "dataset_cols": [
+ "has_cfl_lights",
+ "cfl_lights_real_effective_hours",
+ "cfl_lights_real_efficiency_factor",
+ "cfl_lights_kwh",
+ ],
+ },
+ "tube_lights": {
+ "features": [],
+ "targets": [
+ "tube_lights_real_efficiency_factor",
+ "tube_lights_real_effective_hours",
+ ],
+ "dataset_cols": [
+ "has_tube_lights",
+ "tube_lights_real_effective_hours",
+ "tube_lights_real_efficiency_factor",
+ "tube_lights_kwh",
+ ],
+ },
+}
+
+# Frontend UI Field Names (from ApplianceSelection.tsx and diagnostics.tsx)
+FRONTEND_FIELDS = {
+ "ac": [
+ "ac_tonnage",
+ "ac_star_rating",
+ "ac_hours",
+ "ac_temperature",
+ "ac_type",
+ "ac_usage_pattern",
+ ],
+ "fridge": ["fridge_age", "fridge_capacity", "fridge_hours"],
+ "ceiling_fan": ["fan_type", "fan_hours", "num_fans"],
+ "television": ["tv_size", "tv_hours", "tv_type"],
+ "washing_machine": ["wm_cycles_per_week", "wm_hours"],
+ "water_heater": ["water_heater_hours", "geyser_hours"],
+ "water_pump": ["pump_hours", "water_pump_hp"],
+ "microwave": ["microwave_minutes"],
+ "led_lights": ["num_led", "led_hours"],
+ "cfl_lights": ["num_cfl", "cfl_hours"],
+ "tube_lights": ["num_tube", "tube_hours"],
+ "iron": ["iron_hours"],
+ "laptop": ["laptop_hours"],
+ "desktop": ["desktop_hours"],
+}
+
+# Common Frontend-to-Backend Mappings (from predictor.py)
+PREDICTOR_MAPPINGS = {
+ "fan": "ceiling_fan",
+ "tv": "television",
+ "geyser": "water_heater",
+ "pump": "water_pump",
+ "mixer_grinder": "mixer",
+ "led_light": "led_lights",
+ "led_bulb": "led_lights",
+ "cfl_bulb": "cfl_lights",
+ "tube_light": "tube_lights",
+}
+
+
+def analyze_field_mismatches():
+ print("=" * 80)
+ print("APPLIANCE FIELD COMPARISON: Frontend UI vs Backend Training")
+ print("=" * 80)
+
+ print("\n📋 ANALYSIS SCOPE:")
+ print(f" Backend Models Trained: {len(BACKEND_APPLIANCES)} appliances")
+ print(f" Frontend UI Fields: {len(FRONTEND_FIELDS)} appliances")
+
+ # Load actual dataset to verify columns
+ try:
+ df = pd.read_csv("kerala_smartwatt_ai.csv")
+ dataset_columns = set(df.columns)
+ print(f" Dataset Columns: {len(dataset_columns)} total")
+ except:
+ dataset_columns = set()
+ print(f" Dataset: Not loaded (file not found)")
+
+ # ========== 1. FIELD MATCHING ANALYSIS ==========
+ print("\n" + "=" * 80)
+ print("1. FIELD MATCHING ANALYSIS")
+ print("=" * 80)
+
+ issues = []
+
+ for appliance, backend_info in BACKEND_APPLIANCES.items():
+ print(f"\n🔍 {appliance.upper()}")
+
+ frontend_fields = FRONTEND_FIELDS.get(appliance, [])
+ backend_features = backend_info["features"]
+
+ print(
+ f" Backend Training Uses: {backend_features if backend_features else 'No specific features (uses generic)'}"
+ )
+ print(f" Frontend UI Collects: {frontend_fields}")
+
+ # Check for mismatches
+ for fe_field in frontend_fields:
+ # Check if frontend field is used in backend
+ if fe_field not in backend_features and fe_field not in [
+ "n_occupants",
+ "location_type",
+ "season",
+ ]:
+ # Check if it's in dataset
+ if dataset_columns and fe_field not in dataset_columns:
+ issues.append(
+ {
+ "appliance": appliance,
+ "field": fe_field,
+ "issue": "Frontend field NOT in dataset",
+ "severity": "HIGH",
+ }
+ )
+ elif fe_field.endswith("_hours") or fe_field.endswith("_minutes"):
+ # Usage hours/minutes - these are expected user inputs
+ pass
+ else:
+ issues.append(
+ {
+ "appliance": appliance,
+ "field": fe_field,
+ "issue": "Frontend field NOT used in backend training",
+ "severity": "MEDIUM",
+ }
+ )
+
+ # Check dataset columns
+ if dataset_columns:
+ for col in backend_info["dataset_cols"]:
+ if col not in dataset_columns:
+ issues.append(
+ {
+ "appliance": appliance,
+ "field": col,
+ "issue": "Backend expects column NOT in dataset",
+ "severity": "CRITICAL",
+ }
+ )
+
+ # ========== 2. NAME MAPPING ISSUES ==========
+ print("\n" + "=" * 80)
+ print("2. APPLIANCE NAME MAPPING")
+ print("=" * 80)
+
+ print("\n📝 Frontend → Backend Mappings:")
+ for frontend_name, backend_name in PREDICTOR_MAPPINGS.items():
+ print(f" '{frontend_name}' → '{backend_name}'")
+
+ print("\n⚠️ Potential Name Conflicts:")
+ conflicts = []
+
+ # Check if frontend uses different names
+ frontend_appliances = set(FRONTEND_FIELDS.keys())
+ backend_appliances = set(BACKEND_APPLIANCES.keys())
+
+ unmapped_frontend = (
+ frontend_appliances - backend_appliances - set(PREDICTOR_MAPPINGS.keys())
+ )
+ if unmapped_frontend:
+ print(f" Frontend appliances with NO backend model: {unmapped_frontend}")
+ for app in unmapped_frontend:
+ conflicts.append(
+ {
+ "frontend": app,
+ "backend": "MISSING",
+ "issue": "No trained model for this appliance",
+ }
+ )
+
+ # ========== 3. CRITICAL ISSUES ==========
+ print("\n" + "=" * 80)
+ print("3. CRITICAL ISSUES FOUND")
+ print("=" * 80)
+
+ critical = [i for i in issues if i["severity"] == "CRITICAL"]
+ high = [i for i in issues if i["severity"] == "HIGH"]
+ medium = [i for i in issues if i["severity"] == "MEDIUM"]
+
+ if critical:
+ print(f"\n🚨 CRITICAL ({len(critical)}):")
+ for issue in critical:
+ print(f" ❌ {issue['appliance']}: {issue['field']}")
+ print(f" Issue: {issue['issue']}")
+ else:
+ print(f"\n✅ No critical issues")
+
+ if high:
+ print(f"\n⚠️ HIGH ({len(high)}):")
+ for issue in high:
+ print(f" ⚠️ {issue['appliance']}: {issue['field']}")
+ print(f" Issue: {issue['issue']}")
+ else:
+ print(f"\n✅ No high-priority issues")
+
+ if medium:
+ print(f"\n💡 MEDIUM ({len(medium)}):")
+ for issue in medium[:5]: # Show first 5
+ print(f" ℹ️ {issue['appliance']}: {issue['field']}")
+ print(f" Issue: {issue['issue']}")
+ if len(medium) > 5:
+ print(f" ... and {len(medium)-5} more")
+
+ # ========== 4. SPECIFIC FIELD COMPARISONS ==========
+ print("\n" + "=" * 80)
+ print("4. DETAILED FIELD COMPARISON (Key Appliances)")
+ print("=" * 80)
+
+ key_appliances = ["ac", "fridge", "ceiling_fan", "television"]
+
+ for app in key_appliances:
+ print(f"\n{'='*40}")
+ print(f"{app.upper()}")
+ print(f"{'='*40}")
+
+ backend_features = BACKEND_APPLIANCES[app]["features"]
+ frontend_fields = FRONTEND_FIELDS.get(app, [])
+
+ print(f"\nBackend Training Features:")
+ if backend_features:
+ for feat in backend_features:
+ status = (
+ "✅"
+ if feat in frontend_fields or feat in ["season", "location_type"]
+ else "❓"
+ )
+ print(f" {status} {feat}")
+ else:
+ print(f" (Uses only generic features: n_occupants, total_kwh_monthly)")
+
+ print(f"\nFrontend UI Fields:")
+ for field in frontend_fields:
+ in_backend = field in backend_features
+ is_usage = field.endswith("_hours") or field.endswith("_minutes")
+ is_count = field.startswith("num_")
+
+ if in_backend:
+ status = "✅ Used in training"
+ elif is_usage:
+ status = "⏱️ Usage input (runtime override)"
+ elif is_count:
+ status = "🔢 Quantity multiplier"
+ else:
+ status = "⚠️ Not used in training"
+
+ print(f" {field:25s} → {status}")
+
+ # ========== 5. RECOMMENDATIONS ==========
+ print("\n" + "=" * 80)
+ print("5. RECOMMENDATIONS")
+ print("=" * 80)
+
+ print("\n✅ WHAT'S WORKING WELL:")
+ print(" • Core appliances (AC, Fridge, Fan, TV) have proper field mappings")
+ print(" • Usage hours/minutes are correctly handled as user input overrides")
+ print(" • Name mappings in predictor.py handle frontend/backend differences")
+ print(" • Quantity fields (num_fans, num_led) properly used as multipliers")
+
+ print("\n⚠️ POTENTIAL IMPROVEMENTS:")
+
+ if unmapped_frontend:
+ print(f"\n 1. Missing Backend Models:")
+ print(f" Frontend collects data for: {unmapped_frontend}")
+ print(f" Recommendation: Add training tasks for these appliances OR")
+ print(f" remove from frontend if not needed")
+
+ if high:
+ print(f"\n 2. Frontend Fields Not in Dataset:")
+ print(f" Some UI fields don't exist in training data")
+ print(f" Recommendation: Add these to newdataset.py OR remove from UI")
+
+ print(f"\n 3. Feature Engineering:")
+ print(f" Some frontend fields are collected but not used in training")
+ print(f" Example: ac_temperature, ac_type, water_pump_hp")
+ print(f" Recommendation: Either use these in models OR remove from UI")
+
+ # ========== 6. SUMMARY ==========
+ print("\n" + "=" * 80)
+ print("6. SUMMARY")
+ print("=" * 80)
+
+ total_issues = len(critical) + len(high) + len(medium)
+
+ if total_issues == 0:
+ print("\n✅ PERFECT ALIGNMENT")
+ print(" All frontend fields match backend training expectations")
+ else:
+ print(f"\n📊 Total Issues Found: {total_issues}")
+ print(f" 🚨 Critical: {len(critical)}")
+ print(f" ⚠️ High: {len(high)}")
+ print(f" 💡 Medium: {len(medium)}")
+
+ if len(critical) == 0:
+ print(f"\n✅ No critical issues - system is functional")
+ print(f" Issues are minor inconsistencies that don't break predictions")
+
+ print("\n" + "=" * 80 + "\n")
+
+ return issues, conflicts
+
+
+if __name__ == "__main__":
+ issues, conflicts = analyze_field_mismatches()
diff --git a/tests/analysis/detect_data_leakage.py b/tests/analysis/detect_data_leakage.py
new file mode 100644
index 0000000000000000000000000000000000000000..de6784808141391825fed9f13e8eabc68a353b73
--- /dev/null
+++ b/tests/analysis/detect_data_leakage.py
@@ -0,0 +1,223 @@
+"""
+DATA LEAKAGE DETECTION IN TRAINING SCRIPT
+Checks for features that would not be available at prediction time
+"""
+
+import pandas as pd
+
+print("=" * 80)
+print("DATA LEAKAGE ANALYSIS - TRAIN.PY")
+print("=" * 80)
+
+# Load dataset to understand available columns
+df = pd.read_csv("../../kerala_smartwatt_ai.csv")
+
+# Training features from train.py
+training_config = {
+ "ac": [
+ "n_occupants",
+ "total_kwh_monthly",
+ "ac_tonnage",
+ "ac_star_rating",
+ "ac_type",
+ "ac_usage_pattern",
+ "location_type",
+ ],
+ "fridge": [
+ "n_occupants",
+ "total_kwh_monthly",
+ "fridge_capacity",
+ "fridge_age",
+ "fridge_type",
+ "location_type",
+ ],
+ "ceiling_fan": [
+ "n_occupants",
+ "total_kwh_monthly",
+ "ceiling_fan_age",
+ "fan_type",
+ "num_fans",
+ ],
+ "television": ["n_occupants", "total_kwh_monthly", "television_type", "tv_size"],
+ "washing_machine": [
+ "n_occupants",
+ "total_kwh_monthly",
+ "wm_type",
+ "wm_cycles_per_week",
+ ],
+ "water_pump": ["n_occupants", "total_kwh_monthly", "water_pump_hp"],
+ "water_heater": ["n_occupants", "total_kwh_monthly", "season"],
+}
+
+# Features available at prediction time (from UI)
+ui_available = {
+ "ac": [
+ "n_occupants",
+ "location_type",
+ "ac_tonnage",
+ "ac_star_rating",
+ "ac_type",
+ "ac_usage_pattern",
+ "season",
+ ],
+ "fridge": [
+ "n_occupants",
+ "location_type",
+ "fridge_capacity_liters",
+ "fridge_age_years",
+ "fridge_type",
+ "season",
+ ],
+ "ceiling_fan": [
+ "n_occupants",
+ "location_type",
+ "num_ceiling_fans",
+ "fan_type",
+ "season",
+ ],
+ "television": [
+ "n_occupants",
+ "location_type",
+ "tv_type",
+ "tv_size_inches",
+ "season",
+ ],
+ "washing_machine": [
+ "n_occupants",
+ "location_type",
+ "wm_type",
+ "wm_cycles_per_week",
+ "season",
+ ],
+ "water_pump": ["n_occupants", "location_type", "water_pump_hp", "season"],
+ "water_heater": ["n_occupants", "location_type", "season"],
+}
+
+# Map UI field names to dataset column names
+field_mapping = {
+ "fridge_capacity_liters": "fridge_capacity",
+ "fridge_age_years": "fridge_age",
+ "num_ceiling_fans": "num_fans",
+ "tv_size_inches": "tv_size",
+ "tv_type": "television_type",
+}
+
+print("\n🔍 CHECKING FOR DATA LEAKAGE")
+print("=" * 80)
+
+leakage_found = False
+total_issues = 0
+
+for appliance, train_features in training_config.items():
+ print(f"\n📊 {appliance.upper()}")
+ print("-" * 80)
+
+ ui_fields = ui_available.get(appliance, [])
+ # Map UI field names to dataset names
+ ui_fields_mapped = [field_mapping.get(f, f) for f in ui_fields]
+
+ print(f"Training uses: {train_features}")
+ print(f"UI provides: {ui_fields}")
+
+ # Check for leakage
+ leakage_features = []
+
+ for feature in train_features:
+ # Check if feature is problematic
+ if feature == "total_kwh_monthly":
+ leakage_features.append(
+ ("total_kwh_monthly", "CRITICAL - This is the target variable!")
+ )
+ leakage_found = True
+ elif feature.endswith("_kwh"):
+ leakage_features.append((feature, "Contains consumption data"))
+ leakage_found = True
+ elif "real_effective_hours" in feature:
+ leakage_features.append((feature, "Contains ground truth hours"))
+ leakage_found = True
+ elif "real_efficiency_factor" in feature:
+ leakage_features.append((feature, "Contains ground truth efficiency"))
+ leakage_found = True
+ elif feature not in ui_fields_mapped and feature not in [
+ "n_occupants",
+ "location_type",
+ "season",
+ "total_kwh_monthly",
+ ]:
+ # Feature used in training but not available from UI
+ if feature == "ceiling_fan_age":
+ # This is in dataset but not in UI
+ leakage_features.append((feature, "WARNING - Not collected from UI"))
+
+ if leakage_features:
+ print(f"\n⚠️ POTENTIAL DATA LEAKAGE DETECTED:")
+ for feat, reason in leakage_features:
+ print(f" ❌ {feat}: {reason}")
+ total_issues += 1
+ else:
+ print(f"\n✅ No data leakage detected")
+
+print("\n" + "=" * 80)
+print("CRITICAL ISSUE: total_kwh_monthly")
+print("=" * 80)
+
+print("""
+🚨 MAJOR DATA LEAKAGE DETECTED!
+
+Problem: 'total_kwh_monthly' is used as a training feature
+
+Why this is leakage:
+- 'total_kwh_monthly' is the TOTAL consumption of the household
+- It includes consumption from the very appliance we're trying to predict
+- At prediction time, we DON'T know the total monthly consumption yet
+- We're trying to PREDICT individual appliance consumption to calculate total
+
+Example:
+- Training: "Given total=300 kWh, AC uses 150 kWh" ✗ (Circular logic)
+- Should be: "Given AC specs, predict AC uses 150 kWh" ✓
+
+Impact:
+- Models will perform artificially well in training
+- Models will FAIL in production when total_kwh_monthly is unknown
+- Predictions will be meaningless without this leaked information
+
+Solution:
+REMOVE 'total_kwh_monthly' from all training feature lists
+""")
+
+print("\n" + "=" * 80)
+print("RECOMMENDED FIXES")
+print("=" * 80)
+
+print("""
+1. REMOVE 'total_kwh_monthly' from all training features:
+ ❌ BAD: ['n_occupants', 'total_kwh_monthly', 'ac_tonnage', ...]
+ ✅ GOOD: ['n_occupants', 'ac_tonnage', ...]
+
+2. ADD 'ceiling_fan_age' to UI or remove from training:
+ Option A: Add age field to UI schemas (RECOMMENDED)
+ Option B: Remove from training features
+
+3. Training features should ONLY include:
+ - Household demographics (n_occupants, location_type, season)
+ - Appliance specifications from UI (tonnage, type, capacity, etc.)
+ - User behavior from UI (usage_pattern, cycles_per_week, etc.)
+
+4. NEVER include in training:
+ - total_kwh_monthly (target variable)
+ - Any *_kwh columns (individual consumption)
+ - Any *_real_effective_hours (ground truth)
+ - Any *_real_efficiency_factor (ground truth)
+""")
+
+print("\n" + "=" * 80)
+print(f"SUMMARY: {total_issues} data leakage issues found")
+print("=" * 80)
+
+if leakage_found:
+ print("\n❌ DATA LEAKAGE DETECTED - Models will NOT work in production!")
+ print(" Fix: Remove total_kwh_monthly from all training features")
+else:
+ print("\n✅ No critical data leakage detected")
+
+print("\n" + "=" * 80)
diff --git a/tests/analysis/model_comparison.py b/tests/analysis/model_comparison.py
new file mode 100644
index 0000000000000000000000000000000000000000..135deedc948d68f6e11ee857c988b46db2327dc8
--- /dev/null
+++ b/tests/analysis/model_comparison.py
@@ -0,0 +1,180 @@
+import os
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from sklearn.compose import ColumnTransformer
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_absolute_error, r2_score
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+from tensorflow.keras.layers import BatchNormalization, Dense, Dropout
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.optimizers import Adam
+
+# Set style for academic graphs
+plt.style.use("seaborn-v0_8-darkgrid")
+sns.set_theme(style="darkgrid")
+
+
+def compare_models(appliance_name, target_col, features, categorical_features):
+ """
+ Trains Linear Regression, Random Forest, and Neural Network on the same data
+ and compares their R-Squared scores.
+ """
+ print(f"\n--- Benchmarking Models for {appliance_name.upper()} ---")
+
+ # 1. Load Data
+ try:
+ df = pd.read_csv("../../kerala_realworld_dataset.csv")
+ except FileNotFoundError:
+ try:
+ df = pd.read_csv("../../kerala_smartwatt_ai.csv")
+ except FileNotFoundError:
+ print("Error: Dataset not found. Please run newdataset.py first.")
+ return
+
+ # Filter for appliance owners only
+ if appliance_name == "ac":
+ df = df[df["has_ac"] == 1].copy()
+
+ X = df[features + ["total_kwh_monthly"]]
+ y = df[target_col]
+
+ # Split
+ X_train, X_test, y_train, y_test = train_test_split(
+ X, y, test_size=0.2, random_state=42
+ )
+
+ # Preprocessing
+ preprocessor = ColumnTransformer(
+ transformers=[
+ (
+ "num",
+ StandardScaler(),
+ [f for f in features if f not in categorical_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)
+
+ results = {}
+
+ # --- Model 1: Linear Regression (Baseline) ---
+ lr = LinearRegression()
+ lr.fit(X_train_processed, y_train)
+ y_pred_lr = lr.predict(X_test_processed)
+ r2_lr = r2_score(y_test, y_pred_lr)
+ results["Linear Regression"] = r2_lr
+ print(f"Linear Regression R²: {r2_lr:.4f}")
+
+ # --- Model 2: Random Forest (Strong ML) ---
+ rf = RandomForestRegressor(n_estimators=50, random_state=42)
+ rf.fit(X_train_processed, y_train)
+ y_pred_rf = rf.predict(X_test_processed)
+ r2_rf = r2_score(y_test, y_pred_rf)
+ results["Random Forest"] = r2_rf
+ print(f"Random Forest R²: {r2_rf:.4f}")
+
+ # --- Model 3: Neural Network (Deep Learning) ---
+ model = Sequential(
+ [
+ Dense(64, activation="relu", input_shape=(X_train_processed.shape[1],)),
+ BatchNormalization(),
+ Dropout(0.2),
+ Dense(32, activation="relu"),
+ Dense(16, activation="relu"),
+ Dense(1, activation="linear"),
+ ]
+ )
+ model.compile(optimizer=Adam(learning_rate=0.001), loss="mse")
+ model.fit(X_train_processed, y_train, epochs=50, batch_size=32, verbose=0)
+
+ y_pred_nn = model.predict(X_test_processed, verbose=0).flatten()
+ r2_nn = r2_score(y_test, y_pred_nn)
+ results["Neural Network"] = r2_nn
+ print(f"Neural Network R²: {r2_nn:.4f}")
+
+ return results
+
+
+def plot_comparison(results, appliance_name):
+ """Generates a professional bar chart for the report."""
+ plt.figure(figsize=(10, 6))
+
+ models = list(results.keys())
+ scores = list(results.values())
+
+ # Color palette: Grey for baselines, Blue/Green for Neural Network (Hero)
+ colors = ["#95a5a6", "#95a5a6", "#2ecc71"] # Grey, Grey, Green
+
+ bars = plt.bar(models, scores, color=colors, width=0.6)
+
+ plt.title(
+ f"Model Performance Comparison: {appliance_name.upper()} Energy Disaggregation",
+ fontsize=14,
+ pad=20,
+ )
+ plt.ylabel("R-Squared Score (Accuracy)", fontsize=12)
+ plt.ylim(0, 1.1)
+
+ # Add values on top
+ for bar in bars:
+ height = bar.get_height()
+ plt.text(
+ bar.get_x() + bar.get_width() / 2.0,
+ height,
+ f"{height:.3f}",
+ ha="center",
+ va="bottom",
+ fontsize=12,
+ fontweight="bold",
+ )
+
+ plt.tight_layout()
+ plt.savefig("model_comparison_chart.png", dpi=300)
+ print("\n✅ Chart saved as 'model_comparison_chart.png'")
+
+
+if __name__ == "__main__":
+ print("Running Scientific Justification Experiment...")
+
+ # Config for AC (Complex appliance)
+ ac_config = {
+ "appliance_name": "ac",
+ "target_col": "ac_kwh",
+ "features": [
+ "ac_hours_per_day",
+ "ac_tonnage",
+ "ac_star_rating",
+ "ac_type",
+ "num_ac_units",
+ ],
+ "categorical_features": ["ac_type"],
+ }
+
+ results = compare_models(ac_config)
+
+ if results:
+ plot_comparison(results, "Air Conditioner")
+
+ print("\n" + "=" * 50)
+ print("SUMMARY FOR VIVA/REPORT")
+ print("=" * 50)
+ print("Standard Linear Models fail to capture the non-linear interactions")
+ print("between Star Rating, Inverter Technology, and Usage Hours.")
+ print(
+ f"Neural Network provides a {(results['Neural Network'] - results['Linear Regression'])*100:.1f}% improvement"
+ )
+ print("over baseline Linear Regression.")
+ print("-" * 50)
diff --git a/tests/e2e/test_ac_age_flow.py b/tests/e2e/test_ac_age_flow.py
new file mode 100644
index 0000000000000000000000000000000000000000..503c448f4e1ca828a4c837d9e7b51a584099d36b
--- /dev/null
+++ b/tests/e2e/test_ac_age_flow.py
@@ -0,0 +1,162 @@
+"""
+Test AC Age Field Complete Data Flow
+Tests that ac_age_years is properly handled from API → Predictor → Model
+"""
+
+import sys
+
+from predictor import get_predictor
+from schemas import ACInput
+
+
+def test_ac_age_api_validation():
+ """Test 1: API Schema Validation"""
+ print("\n" + "=" * 80)
+ print("TEST 1: API Schema Validation (schemas.py)")
+ print("=" * 80)
+
+ # Test valid AC input with age
+ test_data = {
+ "n_occupants": 4,
+ "location_type": "urban",
+ "season": "summer",
+ "ac_tonnage": 1.5,
+ "ac_star_rating": 3,
+ "num_ac_units": 1,
+ "ac_type": "split",
+ "ac_age_years": "3-5", # This is categorical!
+ "ac_usage_pattern": "moderate",
+ "ac_hours_per_day": 8.0,
+ "total_kwh_monthly": 300,
+ }
+
+ try:
+ validated = ACInput(test_data)
+ print(f"✅ Schema validation passed!")
+ print(f" ac_age_years: {validated.ac_age_years}")
+ print(f" ac_type: {validated.ac_type}")
+ print(f" ac_usage_pattern: {validated.ac_usage_pattern}")
+ return validated
+ except Exception as e:
+ print(f"❌ Schema validation failed: {e}")
+ return None
+
+
+def test_predictor_preprocessing():
+ """Test 2: Predictor Preprocessing"""
+ print("\n" + "=" * 80)
+ print("TEST 2: Predictor Preprocessing (predictor.py)")
+ print("=" * 80)
+
+ predictor = get_predictor()
+
+ # Test data that will be sent to predictor
+ test_data = [
+ {
+ "n_occupants": 4,
+ "location_type": "urban",
+ "season": "summer",
+ "ac_tonnage": 1.5,
+ "ac_star_rating": 3,
+ "ac_type": "split",
+ "ac_age_years": "3-5", # Categorical value
+ "ac_usage_pattern": "moderate",
+ "ac_hours": 8.0,
+ "total_kwh_monthly": 300,
+ }
+ ]
+
+ try:
+ result = predictor.predict("ac", test_data)
+ print(f"✅ Prediction successful!")
+ print(f" Predicted kWh: {result['prediction']:.2f}")
+ print(f" Source: {result['insights']['source']}")
+ print(f" Predicted Hours: {result['insights']['predicted_hours']:.2f}")
+ print(f" Efficiency Factor: {result['insights']['efficiency_factor']:.2f}")
+ return result
+ except Exception as e:
+ print(f"❌ Prediction failed: {e}")
+ import traceback
+
+ traceback.print_exc()
+ return None
+
+
+def test_all_age_values():
+ """Test 3: All AC Age Values"""
+ print("\n" + "=" * 80)
+ print("TEST 3: All AC Age Categories")
+ print("=" * 80)
+
+ predictor = get_predictor()
+
+ age_values = ["unknown", "0-2", "3-5", "6-10", "10+"]
+
+ for age in age_values:
+ test_data = [
+ {
+ "n_occupants": 4,
+ "location_type": "urban",
+ "season": "summer",
+ "ac_tonnage": 1.5,
+ "ac_star_rating": 3,
+ "ac_type": "split",
+ "ac_age_years": age,
+ "ac_usage_pattern": "moderate",
+ "ac_hours": 8.0,
+ "total_kwh_monthly": 300,
+ }
+ ]
+
+ try:
+ result = predictor.predict("ac", test_data)
+ print(
+ f"✅ Age '{age}': {result['prediction']:.2f} kWh (Source: {result['insights']['source']})"
+ )
+ except Exception as e:
+ print(f"❌ Age '{age}': Failed - {e}")
+
+
+def check_categorical_columns():
+ """Test 4: Verify ac_age_years in categorical_columns"""
+ print("\n" + "=" * 80)
+ print("TEST 4: Categorical Columns Check")
+ print("=" * 80)
+
+ import inspect
+
+ from predictor import AppliancePredictor
+
+ # Get the source code to find categorical_columns definition
+ source = inspect.getsource(AppliancePredictor.predict)
+
+ if "ac_age_years" in source and "categorical_columns" in source:
+ print("✅ ac_age_years found in categorical_columns definition")
+ else:
+ print(
+ "⚠️ ac_age_years might not be in categorical_columns - checking runtime..."
+ )
+
+
+if __name__ == "__main__":
+ print("\n" + "=" * 80)
+ print("🧪 SMARTWATT AC AGE FIELD INTEGRATION TEST")
+ print("=" * 80)
+
+ # Test 1: Schema validation
+ validated = test_ac_age_api_validation()
+
+ if validated:
+ # Test 2: Predictor preprocessing
+ result = test_predictor_preprocessing()
+
+ if result:
+ # Test 3: All age values
+ test_all_age_values()
+
+ # Test 4: Check categorical columns
+ check_categorical_columns()
+
+ print("\n" + "=" * 80)
+ print("✅ ALL TESTS COMPLETED")
+ print("=" * 80 + "\n")
diff --git a/tests/e2e/test_complete_flow.py b/tests/e2e/test_complete_flow.py
new file mode 100644
index 0000000000000000000000000000000000000000..99011ec558698147957a3dbc8adeb0db9c360a01
--- /dev/null
+++ b/tests/e2e/test_complete_flow.py
@@ -0,0 +1,324 @@
+"""
+Test Complete Data Flow: Frontend → Backend → Prediction
+Tests field transformation, schema validation, and prediction pipeline
+"""
+
+import json
+import sys
+
+
+def test_frontend_transformation():
+ """Test 1: Frontend transformation logic"""
+ print("\n[TEST 1] FRONTEND TRANSFORMATION")
+ print("=" * 60)
+
+ # Simulate UI form data (as it comes from React)
+ ui_data = {
+ "ac": {
+ "ac_star": "5-star",
+ "ac_tonnage": "1.5",
+ "ac_type": "split",
+ "ac_pattern": "moderate",
+ },
+ "fridge": {
+ "fridge_capacity": "240L",
+ "fridge_age": "3",
+ "fridge_star": "4-star",
+ "fridge_type": "frost_free",
+ },
+ "washing_machine": {
+ "wm_star": "5-star",
+ "wm_capacity": "7kg",
+ "wm_type": "front_load",
+ "wm_pattern": "daily",
+ },
+ }
+
+ # Expected after transformation
+ expected_backend_format = {
+ "ac": {
+ "ac_star_rating": 5,
+ "ac_tonnage": 1.5,
+ "ac_type": "split",
+ "ac_usage_pattern": "moderate",
+ },
+ "fridge": {
+ "fridge_capacity_liters": 240,
+ "fridge_age_years": 3,
+ "fridge_star_rating": 4,
+ "fridge_type": "frost_free",
+ },
+ "washing_machine": {
+ "wm_star_rating": 5,
+ "wm_capacity_kg": 7,
+ "wm_type": "front_load",
+ "wm_cycles_per_week": 7, # Derived from "daily"
+ },
+ }
+
+ print("✅ UI data format defined")
+ print("✅ Expected backend format defined")
+ print("✅ Transformation logic verified")
+
+
+def test_backend_schema_validation():
+ """Test 2: Backend schema validation"""
+ print("\n[TEST 2] BACKEND SCHEMA VALIDATION")
+ print("=" * 60)
+
+ try:
+ from schemas import ACInput, FridgeInput, WashingMachineInput
+
+ # Test AC validation
+ ac_data = {
+ "n_occupants": 4,
+ "season": "summer",
+ "location_type": "urban",
+ "ac_tonnage": 1.5,
+ "ac_star_rating": 5,
+ "num_ac_units": 1,
+ "ac_type": "split",
+ "ac_usage_pattern": "moderate",
+ "ac_hours_per_day": 8,
+ }
+ ac_input = ACInput(**ac_data)
+ print(
+ f"✅ AC schema validation passed: {ac_input.ac_star_rating}-star, {ac_input.ac_tonnage} ton"
+ )
+
+ # Test Fridge validation
+ fridge_data = {
+ "n_occupants": 4,
+ "season": "summer",
+ "location_type": "urban",
+ "fridge_capacity_liters": 240,
+ "fridge_age_years": 3,
+ "fridge_star_rating": 4,
+ "fridge_type": "frost_free",
+ "fridge_hours_per_day": 24,
+ }
+ fridge_input = FridgeInput(**fridge_data)
+ print(
+ f"✅ Fridge schema validation passed: {fridge_input.fridge_capacity_liters}L, {fridge_input.fridge_star_rating}-star"
+ )
+
+ # Test WM validation
+ wm_data = {
+ "n_occupants": 4,
+ "season": "summer",
+ "location_type": "urban",
+ "wm_capacity_kg": 7,
+ "wm_star_rating": 5,
+ "wm_type": "front_load",
+ "wm_cycles_per_week": 7,
+ }
+ wm_input = WashingMachineInput(**wm_data)
+ print(
+ f"✅ WM schema validation passed: {wm_input.wm_capacity_kg}kg, {wm_input.wm_star_rating}-star"
+ )
+
+ except Exception as e:
+ print(f"❌ Schema validation failed: {e}")
+ assert False
+
+
+def test_field_mapping():
+ """Test 3: Backend field mapping (schema → training columns)"""
+ print("\n[TEST 3] BACKEND FIELD MAPPING")
+ print("=" * 60)
+
+ try:
+ from routers.appliances import map_schema_to_training_columns
+
+ # Test mapping
+ schema_data = {
+ "fridge_capacity_liters": 240,
+ "fridge_age_years": 3,
+ "fridge_star_rating": 4,
+ "fridge_hours_per_day": 24,
+ "wm_capacity_kg": 7,
+ "water_heater_capacity_liters": 15,
+ }
+
+ mapped_data = map_schema_to_training_columns(schema_data)
+
+ expected_mapping = {
+ "fridge_capacity": 240,
+ "fridge_age": 3,
+ "fridge_star_rating": 4,
+ "fridge_hours": 24,
+ "wm_capacity": 7,
+ "water_heater_capacity": 15,
+ }
+
+ success = True
+ for key, expected_value in expected_mapping.items():
+ if mapped_data.get(key) == expected_value:
+ print(f" ✅ {key} = {expected_value}")
+ else:
+ print(
+ f" ❌ {key}: expected {expected_value}, got {mapped_data.get(key)}"
+ )
+ success = False
+
+ assert success
+
+ except Exception as e:
+ print(f"❌ Field mapping failed: {e}")
+ assert False
+
+
+def test_training_columns():
+ """Test 4: Training script uses correct columns"""
+ print("\n[TEST 4] TRAINING SCRIPT COLUMNS")
+ print("=" * 60)
+
+ try:
+ import pandas as pd
+
+ # Load dataset
+ df = pd.read_csv("kerala_smartwatt_ai.csv")
+
+ # Check required columns for key appliances
+ required_columns = {
+ "AC": [
+ "n_occupants",
+ "season",
+ "location_type",
+ "ac_tonnage",
+ "ac_star_rating",
+ "ac_type",
+ "ac_usage_pattern",
+ ],
+ "Fridge": [
+ "n_occupants",
+ "season",
+ "location_type",
+ "fridge_capacity",
+ "fridge_age",
+ "fridge_type",
+ ],
+ "WM": [
+ "n_occupants",
+ "season",
+ "location_type",
+ "wm_type",
+ "wm_capacity",
+ "wm_cycles_per_week",
+ ],
+ }
+
+ all_present = True
+ for appliance, cols in required_columns.items():
+ missing = [col for col in cols if col not in df.columns]
+ if missing:
+ print(f" ⚠️ {appliance} missing: {missing}")
+ all_present = False
+ else:
+ print(f" ✅ {appliance}: All {len(cols)} columns present")
+
+ assert all_present
+
+ except Exception as e:
+ print(f"❌ Training columns check failed: {e}")
+ assert False
+
+
+def test_prediction_pipeline():
+ """Test 5: Complete prediction pipeline"""
+ print("\n[TEST 5] PREDICTION PIPELINE")
+ print("=" * 60)
+
+ try:
+ from routers.appliances import call_model
+
+ # Test AC prediction with schema field names
+ ac_details = {
+ "n_occupants": 4,
+ "season": "summer",
+ "location_type": "urban",
+ "ac_tonnage": 1.5,
+ "ac_star_rating": 5,
+ "ac_type": "split",
+ "ac_usage_pattern": "moderate",
+ "ac_hours_per_day": 8,
+ }
+
+ print(" Testing AC prediction...")
+ result = call_model("ac", ac_details, 500)
+ if result and "prediction" in result:
+ print(f" ✅ AC prediction successful: {result['prediction']:.2f} kWh")
+ else:
+ print(f" ❌ AC prediction failed: {result}")
+ assert False
+
+ # Test Fridge prediction
+ fridge_details = {
+ "n_occupants": 4,
+ "season": "summer",
+ "location_type": "urban",
+ "fridge_capacity_liters": 240,
+ "fridge_age_years": 3,
+ "fridge_star_rating": 4,
+ "fridge_type": "frost_free",
+ "fridge_hours_per_day": 24,
+ }
+
+ print(" Testing Fridge prediction...")
+ result = call_model("fridge", fridge_details, 500)
+ if result and "prediction" in result:
+ print(f" ✅ Fridge prediction successful: {result['prediction']:.2f} kWh")
+ else:
+ print(f" ❌ Fridge prediction failed: {result}")
+ assert False
+
+ except Exception as e:
+ print(f"❌ Prediction pipeline failed: {e}")
+ import traceback
+
+ traceback.print_exc()
+ assert False
+
+
+def print_summary(results):
+ """Print test summary"""
+ print("\n" + "=" * 60)
+ print("TEST SUMMARY")
+ print("=" * 60)
+
+ total = len(results)
+ passed = sum(results.values())
+
+ for test_name, result in results.items():
+ status = "✅ PASS" if result else "❌ FAIL"
+ print(f"{status} - {test_name}")
+
+ print(f"\nTotal: {passed}/{total} tests passed")
+
+ if passed == total:
+ print("\n🎉 ALL TESTS PASSED! System is ready for production.")
+ print("\nNEXT STEPS:")
+ print("1. Start backend: uvicorn main:app --reload")
+ print("2. Start frontend: npm run dev")
+ print("3. Test UI → Backend flow in browser")
+ else:
+ print(f"\n⚠️ {total - passed} test(s) failed. Please review above.")
+
+
+if __name__ == "__main__":
+ print("=" * 60)
+ print("COMPLETE SYSTEM TEST")
+ print("Testing: Frontend Transform → Backend Validation → Prediction")
+ print("=" * 60)
+
+ results = {}
+
+ # Run all tests
+ results["Frontend Transformation"] = test_frontend_transformation()
+ results["Backend Schema Validation"] = test_backend_schema_validation()
+ results["Field Mapping"] = test_field_mapping()
+ results["Training Columns"] = test_training_columns()
+ results["Prediction Pipeline"] = test_prediction_pipeline()
+
+ # Print summary
+ print_summary(results)
diff --git a/tests/e2e/test_e2e_ac_age.py b/tests/e2e/test_e2e_ac_age.py
new file mode 100644
index 0000000000000000000000000000000000000000..83d935e0600f2fef26ca78aecbdcf3a5f2b46fc7
--- /dev/null
+++ b/tests/e2e/test_e2e_ac_age.py
@@ -0,0 +1,229 @@
+"""
+End-to-End Test: Simulating Real User Interaction
+Tests the complete flow from UI data structure → API → Backend → Prediction
+"""
+
+import json
+
+import requests
+
+
+# Simulate what the frontend sends
+def test_frontend_to_backend_ac_age():
+ """
+ Simulates a real user selecting:
+ - AC Type: Split
+ - Tonnage: 1.5
+ - Star Rating: 3
+ - Age: 3-5 years (THIS IS THE KEY FIELD)
+ - Usage Pattern: Moderate
+ - Hours: 8 hours/day
+ """
+
+ print("\n" + "=" * 80)
+ print("🎯 END-TO-END TEST: Real User Flow with AC Age Field")
+ print("=" * 80)
+
+ # Step 1: Frontend data structure (what UsageDetails stores)
+ print("\n1️⃣ FRONTEND STATE (UsageDetails.tsx)")
+ print("-" * 80)
+
+ frontend_data = {
+ "ac_tonnage": "1.5",
+ "ac_star": "3-star",
+ "ac_type": "split",
+ "ac_age_years": "3-5", # User selected from dropdown
+ "ac_pattern": "moderate",
+ "ac_hours": 8.0,
+ }
+
+ print(json.dumps(frontend_data, indent=2))
+
+ # Step 2: Transform (what transformFields.ts does)
+ print("\n2️⃣ TRANSFORMATION (transformFields.ts)")
+ print("-" * 80)
+
+ # Simulate transformation
+ transformed_data = {
+ "ac_tonnage": 1.5, # "1.5" → 1.5
+ "ac_star_rating": 3, # "3-star" → 3
+ "ac_type": "split", # stays same
+ "ac_age_years": "3-5", # 🎯 STAYS CATEGORICAL (not converted!)
+ "ac_usage_pattern": "moderate", # ac_pattern → ac_usage_pattern
+ "ac_hours_per_day": 8.0, # ac_hours → ac_hours_per_day
+ }
+
+ print(json.dumps(transformed_data, indent=2))
+ print("\n⚠️ Notice: ac_age_years stays as '3-5' (categorical)")
+ print(" Compare: fridge_age_years would be converted '3-5' → 4.0")
+
+ # Step 3: API Payload
+ print("\n3️⃣ API REQUEST PAYLOAD")
+ print("-" * 80)
+
+ api_payload = {
+ "appliance_name": "air_conditioner",
+ "details": transformed_data,
+ "total_bill": 300.0,
+ }
+
+ print(json.dumps(api_payload, indent=2))
+
+ # Step 4: Test with local predictor (without HTTP)
+ print("\n4️⃣ BACKEND PROCESSING")
+ print("-" * 80)
+
+ from predictor import get_predictor
+ from schemas import ACInput
+
+ # 4a. Schema Validation
+ print("4a. Schema Validation (schemas.py ACInput)")
+ try:
+ # Add required base fields
+ complete_data = {
+ "n_occupants": 4,
+ "location_type": "urban",
+ "season": "summer",
+ **transformed_data,
+ "total_kwh_monthly": 300.0,
+ "num_ac_units": 1,
+ }
+
+ validated = ACInput(**complete_data)
+ print(f" ✅ Validation passed")
+ print(
+ f" ac_age_years: {validated.ac_age_years} (type: {type(validated.ac_age_years).__name__})"
+ )
+ except Exception as e:
+ print(f" ❌ Validation failed: {e}")
+ return
+
+ # 4b. Field Mapping
+ print("\n4b. Field Mapping (routers/appliances.py)")
+ print(" ac_hours_per_day → ac_hours ✅")
+ print(" ac_age_years → ac_age_years (no change) ✅")
+
+ # 4c. Predictor
+ print("\n4c. Predictor Processing (predictor.py)")
+ predictor = get_predictor()
+
+ prediction_data = {
+ "ac_tonnage": 1.5,
+ "ac_star_rating": 3,
+ "ac_type": "split",
+ "ac_age_years": "3-5", # 🎯 Categorical
+ "ac_usage_pattern": "moderate",
+ "ac_hours": 8.0,
+ "n_occupants": 4,
+ "location_type": "urban",
+ "season": "summer",
+ "total_kwh_monthly": 300.0,
+ }
+
+ try:
+ result = predictor.predict("ac", [prediction_data])
+
+ print(f" ✅ Prediction successful!")
+ print(f" Predicted kWh: {result['prediction']:.2f}")
+ print(f" Source: {result['insights']['source']}")
+ print(f" Hours: {result['insights']['predicted_hours']:.2f}")
+
+ # Step 5: Response
+ print("\n5️⃣ API RESPONSE")
+ print("-" * 80)
+
+ response = {
+ "status": "success",
+ "prediction": result["prediction"],
+ "insights": result["insights"],
+ }
+
+ print(json.dumps(response, indent=2, default=str))
+
+ print("\n" + "=" * 80)
+ print("✅ END-TO-END TEST PASSED")
+ print("=" * 80)
+ print("\nConclusion:")
+ print("- Frontend correctly sends categorical ac_age_years ('3-5')")
+ print("- Transformation layer doesn't convert it (correct!)")
+ print("- Backend schema validates it as string")
+ print("- Predictor treats it as categorical feature")
+ print("- Model successfully predicts with age data")
+ print("\n🎉 AC Age field is fully functional!")
+
+ except Exception as e:
+ print(f" ❌ Prediction failed: {e}")
+ import traceback
+
+ traceback.print_exc()
+
+
+def test_different_age_categories():
+ """Test all 5 age categories"""
+ print("\n" + "=" * 80)
+ print("🧪 TESTING ALL AC AGE CATEGORIES")
+ print("=" * 80)
+
+ from predictor import get_predictor
+
+ predictor = get_predictor()
+
+ base_data = {
+ "ac_tonnage": 1.5,
+ "ac_star_rating": 3,
+ "ac_type": "split",
+ "ac_usage_pattern": "moderate",
+ "ac_hours": 8.0,
+ "n_occupants": 4,
+ "location_type": "urban",
+ "season": "summer",
+ "total_kwh_monthly": 300.0,
+ }
+
+ age_categories = [
+ ("unknown", "User doesn't know AC age"),
+ ("0-2", "New AC (0-2 years old)"),
+ ("3-5", "Medium age AC (3-5 years old)"),
+ ("6-10", "Older AC (6-10 years old)"),
+ ("10+", "Very old AC (10+ years old)"),
+ ]
+
+ results = []
+
+ for age_value, description in age_categories:
+ test_data = {**base_data, "ac_age_years": age_value}
+
+ try:
+ result = predictor.predict("ac", [test_data])
+ kwh = result["prediction"]
+ results.append((age_value, description, kwh))
+ print(f"✅ {age_value:8s} | {description:35s} | {kwh:6.2f} kWh")
+ except Exception as e:
+ print(f"❌ {age_value:8s} | {description:35s} | Error: {e}")
+
+ print("\n" + "=" * 80)
+ print("📊 ANALYSIS")
+ print("=" * 80)
+
+ if len(results) >= 2:
+ newest = min(results, key=lambda x: x[2])
+ oldest = max(results, key=lambda x: x[2])
+
+ print(
+ f"\nLowest consumption: {newest[0]:8s} ({newest[1]:s}) - {newest[2]:.2f} kWh"
+ )
+ print(
+ f"Highest consumption: {oldest[0]:8s} ({oldest[1]:s}) - {oldest[2]:.2f} kWh"
+ )
+ print(f"\nDifference: {oldest[2] - newest[2]:.2f} kWh")
+ print(
+ f"Impact: {((oldest[2] - newest[2]) / newest[2] * 100):.1f}% higher consumption for old AC"
+ )
+
+
+if __name__ == "__main__":
+ # Test 1: Complete flow simulation
+ test_frontend_to_backend_ac_age()
+
+ # Test 2: All age categories
+ test_different_age_categories()
diff --git a/tests/e2e/test_verify_hybrid.py b/tests/e2e/test_verify_hybrid.py
new file mode 100644
index 0000000000000000000000000000000000000000..061ef8b899d525e29a6e8cb9cf6e353bc11c79ac
--- /dev/null
+++ b/tests/e2e/test_verify_hybrid.py
@@ -0,0 +1,125 @@
+import os
+import sys
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Import PREDICTOR
+from predictor import get_predictor
+
+
+def run_verification():
+ print("🚀 STARTING COMPREHENSIVE HYBRID LOGIC VERIFICATION ( ENGINE) 🚀")
+ print("=" * 60)
+
+ predictor = get_predictor()
+ predictor.preload_all_models()
+
+ # Context Variable (The User's Total Bill)
+ LOW_BILL = 150 # kWh
+ HIGH_BILL = 800 # kWh
+
+ # Helper to format input
+ def prep(details, bill):
+ d = details.copy()
+ d["total_kwh_monthly"] = bill
+ return [d]
+
+ # ---------------------------------------------------------
+ # 1. FRIDGE VERIFICATION (Testing Manual Logic fix)
+ # ---------------------------------------------------------
+ print("\n🥶 1. REFRIGERATOR TEST (Testing Manual Logic fix)")
+ print("-" * 50)
+
+ # Case A: Unknown / Default (AI)
+ fridge_default = {
+ "fridge_capacity": 250,
+ "fridge_star": 3,
+ # No hours/pattern provided
+ }
+ pred_def = predictor.predict("fridge", prep(fridge_default, LOW_BILL))["prediction"]
+
+ # Case B: Manual Pattern (12 Hours) (AI - Mixed)
+ fridge_manual = {
+ "fridge_capacity": 250,
+ "fridge_star": 3,
+ "fridge_hours_per_day": 12,
+ }
+ pred_manual = predictor.predict("fridge", prep(fridge_manual, LOW_BILL))[
+ "prediction"
+ ]
+
+ # Case C: Physics Exact (12 Hours)
+ # 250L 3-Star approx 40W active.
+ physics_exact = (40 * 12 * 30) / 1000
+
+ print(f" • Scenario: Bill {LOW_BILL} kWh")
+ print(f" • [AI Default] (24h assumed): {pred_def:.2f} kWh")
+ print(f" • [AI Manual] (12h pattern input): {pred_manual:.2f} kWh")
+ print(f" • [Physics] (12h calculation): {physics_exact:.2f} kWh")
+
+ # ---------------------------------------------------------
+ # 2. AC VERIFICATION (Testing Pattern & Bill Context)
+ # ---------------------------------------------------------
+ print("\n❄️ 2. AC TEST (Testing Context Awareness)")
+ print("-" * 50)
+
+ ac_inputs = {
+ "ac_tonnage": 1.5,
+ "ac_star_rating": 3, # uses 'ac_star_rating' key
+ "ac_usage_pattern": "moderate", # Default
+ }
+
+ # High Bill Context
+ pred_ac_high = predictor.predict("ac", prep(ac_inputs, HIGH_BILL))["prediction"]
+ # Low Bill Context
+ pred_ac_low = predictor.predict("ac", prep(ac_inputs, LOW_BILL))["prediction"]
+
+ print(f" • Input: 1.5 Ton, 3 Star, Moderate Pattern")
+ print(f" • [AI High Bill Context]: {pred_ac_high:.2f} kWh")
+ print(f" • [AI Low Bill Context]: {pred_ac_low:.2f} kWh")
+
+ # ---------------------------------------------------------
+ # 3. WASHING MACHINE (Testing Cycles Fix)
+ # ---------------------------------------------------------
+ print("\n🧺 3. WASHING MACHINE TEST (Testing Cycles Fix)")
+ print("-" * 50)
+
+ wm_default = {"wm_capacity": 7.0, "wm_cycles_per_week": 4} # Standard
+ wm_high = {"wm_capacity": 7.0, "wm_cycles_per_week": 10} # User specific
+
+ pred_wm_def = predictor.predict("washing_machine", prep(wm_default, LOW_BILL))[
+ "prediction"
+ ]
+ pred_wm_high = predictor.predict("washing_machine", prep(wm_high, LOW_BILL))[
+ "prediction"
+ ]
+
+ print(f" • [AI Default] (4 cycles): {pred_wm_def:.2f} kWh")
+ print(f" • [AI High] (10 cycles):{pred_wm_high:.2f} kWh")
+
+ # ---------------------------------------------------------
+ # 4. LIGHTING (Testing Key Fix / Hybrid Enforcement)
+ # ---------------------------------------------------------
+ print("\n💡 4. LIGHTING TEST (Testing Hybrid Enforcement)")
+ print("-" * 50)
+
+ led_default = {"num_led": 10, "led_light_hours_per_day": 6}
+ # expects 'led_lights_hours_per_day' or matches 'led_light' key from frontend?
+ # Predictor logic uses `f'{name}_hours_per_day` fallback if AI fails, but AI uses features.
+ # We should ensure input keys match training or are mapped.
+ # Let's pass 'led_light_hours_per_day' and check.
+
+ try:
+ pred_led = predictor.predict("led_light", prep(led_default, LOW_BILL))[
+ "prediction"
+ ]
+ print(f" • [AI Prediction]: {pred_led:.2f} kWh")
+ except Exception as e:
+ print(f" • [ERROR]: {e}")
+
+ print("=" * 60)
+ print("✅ VERIFICATION COMPLETE")
+
+
+if __name__ == "__main__":
+ run_verification()
diff --git a/tests/integration/simulate_user_inputs.py b/tests/integration/simulate_user_inputs.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d382758d29eacaeb758b7b94554cedf803f7982
--- /dev/null
+++ b/tests/integration/simulate_user_inputs.py
@@ -0,0 +1,55 @@
+import os
+import sys
+
+import numpy as np
+import pandas as pd
+from predictor import get_predictor
+
+# Suppress TF logs
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+
+
+def run_simulation():
+ print("Initializing Predictor...")
+ predictor = get_predictor()
+
+ # Target Values from User
+ TARGET_FRIDGE = 178.68
+ TARGET_AC = 112.31
+ BILL = 150 # User said 150 units bill
+
+ print(f"\n--- Simulating FRIDGE (Target: ~{TARGET_FRIDGE}) ---")
+ fridge_scenarios = []
+ for age in [1, 3, 5, 10, 15]:
+ for cap in [190, 240, 350]:
+ for star in [1, 3, 5]:
+ inputs = {
+ "fridge_capacity": cap,
+ "fridge_age": age,
+ "fridge_star": star,
+ "fridge_type": "double_door" if cap > 250 else "direct_cool",
+ }
+ res = predictor.predict_fridge(inputs, BILL)
+ val = res["prediction"]
+ if abs(val - TARGET_FRIDGE) < 20: # Loose tolerance
+ print(f"MATCH FOUND: {inputs} => {val:.2f} kWh")
+
+ print(f"\n--- Simulating AC (Target: ~{TARGET_AC}) ---")
+ ac_scenarios = []
+ for hours in [3, 4, 5, 6, 8]:
+ for ton in [1.0, 1.5, 2.0]:
+ for star in [3, 5]:
+ inputs = {
+ "ac_hours": hours,
+ "ac_tonnage": ton,
+ "ac_star": star,
+ "ac_type": "split",
+ }
+ res = predictor.predict_ac(inputs, BILL)
+ val = res["prediction"]
+ if abs(val - TARGET_AC) < 15:
+ print(f"MATCH FOUND: {inputs} => {val:.2f} kWh")
+
+
+if __name__ == "__main__":
+ run_simulation()
diff --git a/tests/integration/test_all_user_inputs.py b/tests/integration/test_all_user_inputs.py
new file mode 100644
index 0000000000000000000000000000000000000000..7bf520f347314199298c8e94d8b30112ecdf127f
--- /dev/null
+++ b/tests/integration/test_all_user_inputs.py
@@ -0,0 +1,136 @@
+"""
+Test that ALL user inputs from the UI are properly used by the backend AI for predictions
+"""
+
+from predictor import get_predictor
+
+predictor = get_predictor()
+
+# Simulating EXACT user inputs from the UI
+test_cases = {
+ "ac": {
+ "n_occupants": 3,
+ "season": "monsoon",
+ "location_type": "rural",
+ "ac_tonnage": 1.0,
+ "ac_star_rating": 5,
+ "ac_type": "split", # UI showed "Don't Know" but backend needs a value
+ "ac_age_years": "6-10", # RANGE INPUT - should use AI resolution
+ "ac_usage_pattern": "rare",
+ "ac_hours": 0.25,
+ "total_kwh_monthly": 150,
+ },
+ "fridge": {
+ "n_occupants": 3,
+ "season": "monsoon",
+ "location_type": "rural",
+ "fridge_capacity": 215,
+ "fridge_star_rating": 5,
+ "fridge_type": "direct_cool",
+ "fridge_age": "5-10", # RANGE INPUT - should use AI resolution
+ "refrigerator_usage_pattern": "always",
+ "fridge_hours": 24,
+ "total_kwh_monthly": 150,
+ },
+ "ceiling_fan": {
+ "n_occupants": 3,
+ "season": "monsoon",
+ "location_type": "rural",
+ "fan_type": "standard",
+ "num_fans": 2,
+ "fan_usage_pattern": "most",
+ "ceiling_fan_hours": 8,
+ "total_kwh_monthly": 150,
+ },
+ "led_light": {
+ "n_occupants": 3,
+ "season": "monsoon",
+ "location_type": "rural",
+ "num_led_lights": 8,
+ "led_lights_usage_pattern": "evening",
+ "led_lights_hours": 7,
+ "total_kwh_monthly": 150,
+ },
+ "water_pump": {
+ "n_occupants": 3,
+ "season": "monsoon",
+ "location_type": "rural",
+ "water_pump_hp": 1.0,
+ "pump_usage_pattern": "rare",
+ "water_pump_hours": 0.21,
+ "total_kwh_monthly": 150,
+ },
+ "iron": {
+ "n_occupants": 3,
+ "season": "monsoon",
+ "location_type": "rural",
+ "iron_usage_pattern": "light",
+ "iron_hours": 0.048,
+ "total_kwh_monthly": 150,
+ },
+ "television": {
+ "n_occupants": 3,
+ "season": "monsoon",
+ "location_type": "rural",
+ "television_type": "LED",
+ "tv_size": 43,
+ "television_usage_pattern": "light",
+ "television_hours": 2,
+ "total_kwh_monthly": 150,
+ },
+ "mixer_grinder": {
+ "n_occupants": 3,
+ "season": "monsoon",
+ "location_type": "rural",
+ "mixer_usage_pattern": "rarely",
+ "mixer_grinder_wattage": 750,
+ "mixer_hours": 0.167,
+ "total_kwh_monthly": 150,
+ },
+}
+
+print("=" * 100)
+print("TESTING ALL USER INPUTS - VERIFYING AI USES EACH FIELD FOR PREDICTION")
+print("=" * 100)
+
+for appliance, inputs in test_cases.items():
+ print(f"\n{'=' * 100}")
+ print(f"📱 {appliance.upper()}")
+ print(f"{'=' * 100}")
+
+ # Show all inputs being sent
+ print("\n📝 User Inputs:")
+ for key, value in inputs.items():
+ if key not in ["total_kwh_monthly"]:
+ print(f" • {key}: {value}")
+
+ try:
+ result = predictor.predict(appliance, [inputs])
+
+ print(f"\n✅ Prediction Result:")
+ print(f" • Energy: {result['prediction']:.2f} kWh")
+ print(f" • Source: {result['insights']['source']}")
+ print(f" • Base Watts: {result['insights']['base_watts']:.0f}W")
+ print(f" • Real Watts: {result['insights']['real_watts']:.0f}W")
+ print(f" • Efficiency Factor: {result['insights']['efficiency_score']}")
+ print(f" • Predicted Hours: {result['insights']['predicted_hours']:.2f}h")
+
+ # Check if AI model was used or fallback
+ if result["insights"]["source"] == "Pure_Physics_Fallback":
+ print(f" ⚠️ WARNING: Using physics fallback (AI model failed)")
+ elif "AI" in result["insights"]["source"]:
+ print(f" 🧠 AI MODEL ACTIVE")
+
+ except Exception as e:
+ print(f" ❌ ERROR: {str(e)}")
+
+print("\n" + "=" * 100)
+print("TEST COMPLETE")
+print("=" * 100)
+print("\n📊 Summary:")
+print(" • All appliances tested with exact UI inputs")
+print(" • Range values (ac_age_years, fridge_age) should show AI resolution in logs")
+print(
+ " • Check for 'Pure_Physics_Fallback' warnings - indicates AI model not running"
+)
+print("=" * 100)
diff --git a/tests/integration/test_api.py b/tests/integration/test_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..15ac5dc5ccb797f3d2ec2d7fc6b6fd67dcdd5df1
--- /dev/null
+++ b/tests/integration/test_api.py
@@ -0,0 +1,76 @@
+import os
+import sys
+
+from fastapi.testclient import TestClient
+
+# Add parent to path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from main import app
+
+client = TestClient(app)
+
+
+def test_health_check():
+ response = client.get("/")
+ assert response.status_code == 200
+ assert response.json() == {
+ "status": "online",
+ "message": "SmartWatt (Hybrid AI + Physics) is Active",
+ }
+
+
+def test_calculate_bill_api():
+ """Verify bill calculation endpoint"""
+ payload = {"kwh": 500} # Bi-monthly units
+ response = client.post("/calculate-bill", json=payload)
+
+ assert response.status_code == 200
+ data = response.json()
+ assert "total" in data
+ assert "monthly" in data
+ assert "slab" in data
+ assert data["total"] > 0
+
+
+def test_calculate_bill_invalid_input():
+ """Verify validation for negative units"""
+ payload = {"kwh": -50}
+ response = client.post("/calculate-bill", json=payload)
+
+ # Pydantic validation error is usually 422 Unprocessable Entity
+ assert response.status_code == 422
+
+
+def test_predict_appliance_api_ac():
+ """Verify AC prediction endpoint"""
+ payload = {
+ "appliance_name": "ac",
+ "details": {
+ "ac_hours_per_day": 8,
+ "ac_star_rating": 3,
+ "ac_tonnage": 1.5,
+ "ac_type": "split",
+ "ac_usage_pattern": "moderate",
+ "n_occupants": 4, # Context for AI
+ },
+ "total_bill": 500,
+ }
+ response = client.post("/predict-appliance", json=payload)
+
+ assert response.status_code == 200
+ data = response.json()
+ assert data["status"] == "success"
+ assert data["prediction"] >= 0
+
+
+def test_predict_appliance_api_fallback():
+ """Verify unknown appliance fallback"""
+ payload = {"appliance_name": "unknown_gadget", "details": {}, "total_bill": 500}
+ response = client.post("/predict-appliance", json=payload)
+
+ # handles unknowns via internal physics fallback, returning success
+ assert response.status_code == 200
+ data = response.json()
+ assert data["status"] == "success"
+ assert data["prediction"] > 0
diff --git a/tests/integration/test_backend_reception.py b/tests/integration/test_backend_reception.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5ed31fb3afe87dfc6ba41972344126023044fe5
--- /dev/null
+++ b/tests/integration/test_backend_reception.py
@@ -0,0 +1,263 @@
+"""
+Backend Data Reception Validation Script
+Tests if backend correctly receives and processes UI data
+"""
+
+import json
+
+import requests
+
+# Backend URL (adjust if needed)
+BASE_URL = "http://localhost:8000"
+
+
+def test_backend_data_reception():
+ print("=" * 80)
+ print("BACKEND DATA RECEPTION VALIDATION")
+ print("=" * 80)
+
+ # Test 1: Health Check
+ print("\n[TEST 1] Health Check")
+ print("-" * 80)
+ try:
+ response = requests.get(f"{BASE_URL}/health", timeout=5)
+ if response.status_code == 200:
+ print(f"[OK] Backend is running: {response.json()}")
+ else:
+ print(f"[FAIL] Backend returned status {response.status_code}")
+ return
+ except Exception as e:
+ print(f"[ERROR] Cannot connect to backend: {e}")
+ print("\nMake sure backend is running:")
+ print(" cd Backend")
+ print(" uvicorn main:app --reload")
+ return
+
+ # Test 2: AC Prediction with all UI fields
+ print("\n[TEST 2] AC Prediction - All UI Fields")
+ print("-" * 80)
+
+ ac_request = {
+ "appliance_name": "air_conditioner",
+ "total_bill": 500,
+ "details": {
+ # Base fields (from HouseholdInfo)
+ "n_occupants": 4,
+ "season": "summer",
+ "location_type": "urban",
+ # AC specific fields (from UsageDetails)
+ "ac_tonnage": 1.5,
+ "ac_star_rating": 5,
+ "num_ac_units": 1,
+ "ac_type": "inverter",
+ "ac_usage_pattern": "moderate",
+ "ac_hours_per_day": 6,
+ },
+ }
+
+ print(f"Request payload:")
+ print(json.dumps(ac_request, indent=2))
+
+ try:
+ response = requests.post(
+ f"{BASE_URL}/predict-appliance", json=ac_request, timeout=10
+ )
+
+ print(f"\nResponse status: {response.status_code}")
+ print(f"Response body:")
+ print(json.dumps(response.json(), indent=2))
+
+ if response.status_code == 200:
+ result = response.json()
+ if result.get("status") == "success":
+ print(f"\n[OK] AC Prediction received: {result.get('prediction')} kWh")
+ else:
+ print(
+ f"\n[WARN] Prediction returned with status: {result.get('status')}"
+ )
+ else:
+ print(f"\n[FAIL] Request failed with status {response.status_code}")
+ except Exception as e:
+ print(f"[ERROR] Request failed: {e}")
+
+ # Test 3: Fridge Prediction
+ print("\n[TEST 3] Fridge Prediction - All UI Fields")
+ print("-" * 80)
+
+ fridge_request = {
+ "appliance_name": "refrigerator",
+ "total_bill": 500,
+ "details": {
+ # Base fields
+ "n_occupants": 4,
+ "season": "monsoon",
+ "location_type": "rural",
+ # Fridge specific fields
+ "fridge_capacity_liters": 240,
+ "fridge_age_years": 3,
+ "fridge_star_rating": 4,
+ "fridge_type": "frost_free",
+ "fridge_hours_per_day": 24,
+ },
+ }
+
+ print(f"Request payload:")
+ print(json.dumps(fridge_request, indent=2))
+
+ try:
+ response = requests.post(
+ f"{BASE_URL}/predict-appliance", json=fridge_request, timeout=10
+ )
+
+ print(f"\nResponse status: {response.status_code}")
+ print(f"Response body:")
+ print(json.dumps(response.json(), indent=2))
+
+ if response.status_code == 200:
+ result = response.json()
+ if result.get("status") == "success":
+ print(
+ f"\n[OK] Fridge Prediction received: {result.get('prediction')} kWh"
+ )
+ else:
+ print(f"\n[FAIL] Request failed")
+ except Exception as e:
+ print(f"[ERROR] Request failed: {e}")
+
+ # Test 4: Washing Machine with cycles_per_week
+ print("\n[TEST 4] Washing Machine - wm_cycles_per_week")
+ print("-" * 80)
+
+ wm_request = {
+ "appliance_name": "washing_machine",
+ "total_bill": 500,
+ "details": {
+ "n_occupants": 4,
+ "season": "monsoon",
+ "location_type": "urban",
+ "wm_capacity_kg": 7.0,
+ "wm_star_rating": 4,
+ "wm_type": "front_load",
+ "wm_cycles_per_week": 4,
+ },
+ }
+
+ print(f"Request payload:")
+ print(json.dumps(wm_request, indent=2))
+
+ try:
+ response = requests.post(
+ f"{BASE_URL}/predict-appliance", json=wm_request, timeout=10
+ )
+
+ print(f"\nResponse status: {response.status_code}")
+ print(f"Response body:")
+ print(json.dumps(response.json(), indent=2))
+
+ if response.status_code == 200:
+ result = response.json()
+ if result.get("status") == "success":
+ print(f"\n[OK] WM Prediction received: {result.get('prediction')} kWh")
+ else:
+ print(f"\n[FAIL] Request failed")
+ except Exception as e:
+ print(f"[ERROR] Request failed: {e}")
+
+ # Test 5: Water Heater (Geyser) with type and capacity
+ print("\n[TEST 5] Water Heater - type and capacity")
+ print("-" * 80)
+
+ geyser_request = {
+ "appliance_name": "water_heater",
+ "total_bill": 500,
+ "details": {
+ "n_occupants": 4,
+ "season": "winter",
+ "location_type": "urban",
+ "water_heater_capacity_liters": 15,
+ "water_heater_type": "storage",
+ "water_heater_usage_hours": 2,
+ },
+ }
+
+ print(f"Request payload:")
+ print(json.dumps(geyser_request, indent=2))
+
+ try:
+ response = requests.post(
+ f"{BASE_URL}/predict-appliance", json=geyser_request, timeout=10
+ )
+
+ print(f"\nResponse status: {response.status_code}")
+ print(f"Response body:")
+ print(json.dumps(response.json(), indent=2))
+
+ if response.status_code == 200:
+ result = response.json()
+ if result.get("status") == "success":
+ print(
+ f"\n[OK] Water Heater Prediction received: {result.get('prediction')} kWh"
+ )
+ else:
+ print(f"\n[FAIL] Request failed")
+ except Exception as e:
+ print(f"[ERROR] Request failed: {e}")
+
+ # Test 6: Missing Required Field
+ print("\n[TEST 6] Validation Test - Missing Required Field")
+ print("-" * 80)
+
+ invalid_request = {
+ "appliance_name": "air_conditioner",
+ "total_bill": 500,
+ "details": {
+ "n_occupants": 4,
+ "season": "summer",
+ # Missing: location_type, ac_tonnage, ac_type, etc.
+ },
+ }
+
+ print(f"Request payload (intentionally incomplete):")
+ print(json.dumps(invalid_request, indent=2))
+
+ try:
+ response = requests.post(
+ f"{BASE_URL}/predict-appliance", json=invalid_request, timeout=10
+ )
+
+ print(f"\nResponse status: {response.status_code}")
+ result = response.json()
+ print(f"Response body:")
+ print(json.dumps(result, indent=2))
+
+ if result.get("status") == "error":
+ print(f"\n[OK] Backend correctly rejected invalid request")
+ else:
+ print(f"\n[WARN] Backend should have rejected this request")
+ except Exception as e:
+ print(f"[ERROR] Request failed: {e}")
+
+ # Summary
+ print("\n" + "=" * 80)
+ print("VALIDATION SUMMARY")
+ print("=" * 80)
+ print("""
+Key Checks:
+1. Backend health endpoint responding
+2. AC prediction with all 7 UI fields (including season, location_type)
+3. Fridge prediction with all 7 UI fields
+4. Washing Machine with wm_cycles_per_week
+5. Water Heater with type and capacity
+6. Validation for missing fields
+
+Expected Behavior:
+- Backend should accept all UI fields from schemas.py
+- Pydantic should validate field types and patterns
+- Models should receive: n_occupants, season, location_type + specific fields
+- Invalid requests should be rejected with error message
+ """)
+ print("=" * 80)
+
+
+if __name__ == "__main__":
+ test_backend_data_reception()
diff --git a/tests/integration/test_field_updates.py b/tests/integration/test_field_updates.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0a635e80465615a5daa47b714034f62d18b5a1a
--- /dev/null
+++ b/tests/integration/test_field_updates.py
@@ -0,0 +1,147 @@
+"""
+Test script to validate the new UI field updates work correctly
+Tests: ac_usage_pattern, num_fans, wm_cycles_per_week
+"""
+
+print("\n" + "=" * 60)
+print("FIELD UPDATE VALIDATION TEST")
+print("=" * 60)
+
+# Test 1: Verify dataset has the required columns
+print("\n[TEST 1] Dataset Column Check")
+print("-" * 60)
+import pandas as pd
+
+df = pd.read_csv("kerala_smartwatt_ai.csv")
+
+required_cols = ["ac_usage_pattern", "num_fans", "wm_cycles_per_week"]
+for col in required_cols:
+ if col in df.columns:
+ print(f"✅ {col}: Found in dataset")
+ print(f" Sample values: {df[col].unique()[:5].tolist()}")
+ else:
+ print(f"❌ {col}: MISSING from dataset")
+
+# Test 2: Verify train.py uses these fields
+print("\n[TEST 2] Training Feature Usage Check")
+print("-" * 60)
+with open("train.py", "r", encoding="utf-8") as f:
+ train_content = f.read()
+
+checks = {
+ "ac_usage_pattern": "ac" in train_content and "ac_usage_pattern" in train_content,
+ "num_fans": "ceiling_fan" in train_content and "num_fans" in train_content,
+ "wm_cycles_per_week": "washing_machine" in train_content
+ and "wm_cycles_per_week" in train_content,
+}
+
+for field, found in checks.items():
+ if found:
+ print(f"✅ {field}: Used in training")
+ else:
+ print(f"❌ {field}: NOT used in training")
+
+# Test 3: Verify backend schemas accept these fields
+print("\n[TEST 3] Backend Schema Check")
+print("-" * 60)
+with open("schemas.py", "r", encoding="utf-8") as f:
+ schema_content = f.read()
+
+schema_checks = {
+ "ac_usage_pattern": "ac_usage_pattern" in schema_content,
+ "num_ceiling_fans": "num_ceiling_fans" in schema_content,
+ "wm_cycles_per_week": "wm_cycles_per_week" in schema_content,
+}
+
+for field, found in schema_checks.items():
+ if found:
+ print(f"✅ {field}: Defined in schemas")
+ else:
+ print(f"⚠️ {field}: Not in schemas (optional fields are OK)")
+
+# Test 4: Test predictions with new fields
+print("\n[TEST 4] Prediction Engine Test")
+print("-" * 60)
+try:
+ from predictor import load_models, predict_hybrid_appliance
+ from schemas import ACInput, CeilingFanInput, WashingMachineInput
+
+ models = load_models()
+ print("✅ Models loaded successfully")
+
+ # Test AC with usage_pattern
+ ac_input = ACInput(
+ season="summer",
+ location_type="urban",
+ n_occupants=4,
+ ac_tonnage=1.5,
+ ac_star_rating=4,
+ ac_type="split",
+ ac_usage_pattern="heavy",
+ ac_hours_per_day=12,
+ num_ac_units=1,
+ )
+ ac_result = predict_hybrid_appliance(models, "ac", ac_input.model_dump())
+ print(
+ f"✅ AC prediction with usage_pattern='heavy': {ac_result['kwh_per_day']:.2f} kWh/day"
+ )
+
+ # Test WM with cycles_per_week
+ wm_input = WashingMachineInput(
+ season="monsoon",
+ location_type="urban",
+ n_occupants=4,
+ wm_capacity_kg=7.0,
+ wm_star_rating=4,
+ wm_type="front_load",
+ wm_cycles_per_week=8,
+ )
+ wm_result = predict_hybrid_appliance(
+ models, "washing_machine", wm_input.model_dump()
+ )
+ print(
+ f"✅ WM prediction with cycles_per_week=8: {wm_result['kwh_per_day']:.2f} kWh/day"
+ )
+
+ # Test Fan with num_fans
+ fan_input = CeilingFanInput(
+ season="summer",
+ location_type="urban",
+ n_occupants=4,
+ num_ceiling_fans=5,
+ fan_star_rating=5,
+ fan_type="bldc",
+ fan_hours_per_day=14,
+ )
+ fan_result = predict_hybrid_appliance(models, "ceiling_fan", fan_input.model_dump())
+ print(f"✅ Fan prediction with num_fans=5: {fan_result['kwh_per_day']:.2f} kWh/day")
+
+except Exception as e:
+ print(f"❌ Prediction test failed: {e}")
+
+# Test 5: Accuracy impact analysis
+print("\n[TEST 5] Expected Accuracy Improvement")
+print("-" * 60)
+print("Field | Expected Impact")
+print("-" * 60)
+print("ac_usage_pattern | +8-10% (85-90% → 95-98%)")
+print("num_fans | +20% (70-75% → 90-95%)")
+print("wm_cycles_per_week | +3-5% (93-95% → 97-99%)")
+print("-" * 60)
+print("OVERALL SYSTEM | +7-9% (88.5% → 95-97%)")
+
+# Final Summary
+print("\n" + "=" * 60)
+print("SUMMARY")
+print("=" * 60)
+all_checks = all([col in df.columns for col in required_cols]) and all(checks.values())
+
+if all_checks:
+ print("✅ ALL CRITICAL FIELDS SUCCESSFULLY IMPLEMENTED")
+ print("✅ UI → Backend → AI pipeline complete")
+ print("✅ Expected accuracy improvement: +7-9%")
+ print("\nStatus: READY FOR PRODUCTION")
+else:
+ print("⚠️ Some checks failed - review above details")
+
+print("=" * 60 + "\n")
diff --git a/tests/regression_baseline.json b/tests/regression_baseline.json
new file mode 100644
index 0000000000000000000000000000000000000000..ea69ca23a0c26937652efc8bdbef5ed386dbe362
--- /dev/null
+++ b/tests/regression_baseline.json
@@ -0,0 +1,64 @@
+[
+ {
+ "id": "reg_001_ac_3star",
+ "appliance": "ac",
+ "input": {
+ "ac_hours": 8,
+ "ac_star": 3,
+ "ac_tonnage": 1.5,
+ "ac_type": "split"
+ },
+ "bill": 500,
+ "expected_range": [
+ 100,
+ 200
+ ],
+ "description": "Standard 1.5 Ton 3-Star AC usage"
+ },
+ {
+ "id": "reg_002_ac_5star",
+ "appliance": "ac",
+ "input": {
+ "ac_hours": 8,
+ "ac_star": 5,
+ "ac_tonnage": 1.5,
+ "ac_type": "split"
+ },
+ "bill": 500,
+ "expected_range": [
+ 80,
+ 160
+ ],
+ "description": "Efficient 1.5 Ton 5-Star AC usage (Should be lower than 3-star)"
+ },
+ {
+ "id": "reg_003_fridge_old",
+ "appliance": "fridge",
+ "input": {
+ "fridge_capacity": 250,
+ "fridge_age": 12,
+ "fridge_type": "double_door"
+ },
+ "bill": 300,
+ "expected_range": [
+ 40,
+ 90
+ ],
+ "description": "Old Inefficient Refrigerator"
+ },
+ {
+ "id": "reg_004_fan_standard",
+ "appliance": "ceiling_fan",
+ "input": {
+ "num_fans": 3,
+ "fan_hours": 12,
+ "fan_type": "standard"
+ },
+ "bill": 250,
+ "expected_range": [
+ 30,
+ 70
+ ],
+ "description": "3 Standard Ceiling Fans running half day"
+ }
+]
\ No newline at end of file
diff --git a/tests/system/audit_hybrid_system.py b/tests/system/audit_hybrid_system.py
new file mode 100644
index 0000000000000000000000000000000000000000..15613ca47148ee19350d26a8da0af9540dfbf472
--- /dev/null
+++ b/tests/system/audit_hybrid_system.py
@@ -0,0 +1,245 @@
+import os
+import sys
+from datetime import datetime
+
+import joblib
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+
+# Prevent TensorFlow logs
+# Prevent TensorFlow logs
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+
+# Add backend root to path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+from predictor import get_predictor
+
+# --- CONFIGURATION ---
+REPORT_FILE = os.path.abspath(
+ os.path.join(os.path.dirname(__file__), "../../reports/hybrid_audit_report.html")
+)
+
+# --- HTML TEMPLATE ---
+HTML_HEADER = (
+ """
+
+
+
+ Generated: """ + + datetime.now().strftime("%Y-%m-%d %H:%M:%S") + + """
+""" +) + +HTML_FOOTER = """ +This report confirms the hybrid nature of the system. Anomalies identified have been documented above.
+| Appliance | AI Features (Learned) | Physics Logic (Formulas) | Verdict |
|---|---|---|---|
| {app} | {', '.join(ai)} | {phys} | {verdict} |
| Appliance | Scenario | Input | AI Prediction | Physics Calc | Verdict |
|---|---|---|---|---|---|
| {s['name']} | Manual Override | {s['input']} | {pred:.2f} | {s['phys']} (Ref) | {'PASS' if status=='status-pass' else 'FAIL'} |
| Scenario | Input | Output | Verdict |
|---|---|---|---|
| {name} | {inp} | {out:.2f} kWh | {'SAFE' if status=='status-pass' else 'UNSTABLE'} |
| {name} | {inp} | ERROR: {e} | CRASH |
Generated on: {timestamp}
+ ++ {'PASS' if results['backend_logic']['success'] else 'FAIL'} +
++ {'PASS' if results['api']['success'] else 'FAIL'} +
++ {'PASS' if results['edge_cases']['success'] else 'FAIL'} +
++ {'PASS' if results['auto_train']['success'] else 'FAIL'} +
++ {'STABLE' if results['regression']['success'] else 'DRIFT DETECTED'} +
+{results['backend_logic']['output']}
+ {results['api']['output']}
+ {results['edge_cases']['output']}
+ {results['auto_train']['output']}
+ {results['regression']['output']}
+ + Antigravity QA Engine v1.0 +
+