Update app.py

app.py

@@ -8,6 +8,7 @@ import numpy as np
 import joblib
 import pandas as pd
 import os
+import sys
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel, Field
 from typing import List, Optional, Dict, Any
@@ -26,9 +27,10 @@ app = FastAPI(
 # LOAD MODEL AND PREPROCESSORS
 # ============================================
 
-MODEL_PATH = "production_model.pkl"
-SCALER_PATH = "scaler.pkl"
-FEATURES_PATH = "features.pkl"
+# Try different possible filenames
+MODEL_PATHS = ["production_model.pkl", "model.pkl", "random_forest_model.pkl"]
+SCALER_PATHS = ["scaler.pkl", "standard_scaler.pkl"]
+FEATURES_PATHS = ["features.pkl", "feature.pkl", "feature_names.pkl"]  # Fixed: includes 'feature.pkl'
 
 model = None
 scaler = None
@@ -38,20 +40,89 @@ def load_model():
     """Load the trained Random Forest model and preprocessors"""
     global model, scaler, feature_names
     
-    try:
-        if os.path.exists(MODEL_PATH) and os.path.exists(SCALER_PATH):
-            model = joblib.load(MODEL_PATH)
-            scaler = joblib.load(SCALER_PATH)
-            feature_names = joblib.load(FEATURES_PATH)
-            print(f"✅ Loaded Random Forest model with {model.n_estimators} trees")
-            print(f"✅ Features: {feature_names}")
-            return True
-        else:
-            print("⚠️ Model files not found. Please train the model first.")
-            return False
-    except Exception as e:
-        print(f"❌ Error loading model: {e}")
+    # Try to load model
+    model_loaded = False
+    for model_path in MODEL_PATHS:
+        try:
+            if os.path.exists(model_path):
+                model = joblib.load(model_path)
+                print(f"✅ Loaded model from {model_path}")
+                print(f"   Type: {type(model).__name__}")
+                if hasattr(model, 'n_estimators'):
+                    print(f"   Trees: {model.n_estimators}")
+                model_loaded = True
+                break
+        except Exception as e:
+            print(f"⚠️ Failed to load {model_path}: {e}")
+    
+    if not model_loaded:
+        print("❌ No model file found. Please check model files.")
         return False
+    
+    # Try to load scaler
+    scaler_loaded = False
+    for scaler_path in SCALER_PATHS:
+        try:
+            if os.path.exists(scaler_path):
+                scaler = joblib.load(scaler_path)
+                print(f"✅ Loaded scaler from {scaler_path}")
+                scaler_loaded = True
+                break
+        except Exception as e:
+            print(f"⚠️ Failed to load {scaler_path}: {e}")
+    
+    # Try to load feature names
+    features_loaded = False
+    for features_path in FEATURES_PATHS:
+        try:
+            if os.path.exists(features_path):
+                feature_names = joblib.load(features_path)
+                print(f"✅ Loaded feature names from {features_path}")
+                print(f"   Features: {feature_names}")
+                features_loaded = True
+                break
+        except Exception as e:
+            print(f"⚠️ Failed to load {features_path}: {e}")
+    
+    # If no feature names file, check if model has feature_names attribute
+    if not features_loaded and hasattr(model, 'feature_names_in_'):
+        feature_names = list(model.feature_names_in_)
+        print(f"✅ Using feature names from model: {feature_names}")
+        features_loaded = True
+    
+    # If still no features, use default 12-feature list
+    if not features_loaded:
+        feature_names = [
+            'total_building_load_rt',
+            'avg_chilled_water_rate_lps',
+            'avg_cooling_water_temp_c',
+            'avg_outside_temp_f',
+            'avg_dew_point_f',
+            'avg_humidity_pct',
+            'avg_wind_speed_mph',
+            'avg_pressure_in',
+            'hour',
+            'day_of_week',
+            'month',
+            'day_of_year'
+        ]
+        print(f"✅ Using default feature names")
+    
+    return model_loaded
+
+# Load model on startup
+load_success = load_model()
+
+# Print debug info about loaded files
+print("\n📁 Files in directory:")
+for file in os.listdir('.'):
+    if file.endswith('.pkl') or file.endswith('.joblib'):
+        size = os.path.getsize(file) / 1024  # KB
+        print(f"   - {file} ({size:.1f} KB)")
+
+print(f"\n📊 Model Load Status: {'SUCCESS' if model else 'FAILED'}")
+print(f"📊 Scaler Load Status: {'SUCCESS' if scaler else 'FAILED'}")
+print(f"📊 Features Load Status: {'SUCCESS' if feature_names else 'FAILED'}")
 
 # ============================================
 # REQUEST/RESPONSE MODELS
@@ -192,22 +263,28 @@ class OptimizeResponse(BaseModel):
 def get_mcp_data() -> MCPResponse:
     """Generate MCP (Model Card + Performance + Capabilities) JSON output"""
     
-    # Feature importance (typically loaded from trained model)
-    # These are example values - replace with actual from your trained model
-    feature_importance = {
-        "total_building_load_rt": 0.324,
-        "avg_outside_temp_f": 0.156,
-        "avg_cooling_water_temp_c": 0.112,
-        "avg_humidity_pct": 0.089,
-        "hour": 0.078,
-        "avg_chilled_water_rate_lps": 0.067,
-        "month": 0.054,
-        "avg_dew_point_f": 0.043,
-        "day_of_year": 0.032,
-        "avg_wind_speed_mph": 0.021,
-        "avg_pressure_in": 0.015,
-        "day_of_week": 0.009
-    }
+    # Try to extract actual feature importance from model if available
+    feature_importance_dict = {}
+    if model and hasattr(model, 'feature_importances_') and feature_names:
+        importances = model.feature_importances_
+        for name, imp in zip(feature_names, importances):
+            feature_importance_dict[name] = float(imp)
+    else:
+        # Default importance values
+        feature_importance_dict = {
+            "total_building_load_rt": 0.324,
+            "avg_outside_temp_f": 0.156,
+            "avg_cooling_water_temp_c": 0.112,
+            "avg_humidity_pct": 0.089,
+            "hour": 0.078,
+            "avg_chilled_water_rate_lps": 0.067,
+            "month": 0.054,
+            "avg_dew_point_f": 0.043,
+            "day_of_year": 0.032,
+            "avg_wind_speed_mph": 0.021,
+            "avg_pressure_in": 0.015,
+            "day_of_week": 0.009
+        }
     
     # Input features description
     input_features = [
@@ -304,10 +381,10 @@ def get_mcp_data() -> MCPResponse:
             version="2.0.0",
             description="Ensemble model that builds multiple decision trees to predict chiller plant energy efficiency (kW/TR) based on operational and environmental conditions. The model outputs the mean prediction of all trees for robust, non-linear regression.",
             architecture={
-                "n_estimators": model.n_estimators if model else 100,
-                "max_depth": model.max_depth if model else 12,
-                "min_samples_split": model.min_samples_split if model else 2,
-                "min_samples_leaf": model.min_samples_leaf if model else 1,
+                "n_estimators": model.n_estimators if model and hasattr(model, 'n_estimators') else 100,
+                "max_depth": model.max_depth if model and hasattr(model, 'max_depth') else 12,
+                "min_samples_split": model.min_samples_split if model and hasattr(model, 'min_samples_split') else 2,
+                "min_samples_leaf": model.min_samples_leaf if model and hasattr(model, 'min_samples_leaf') else 1,
                 "bootstrap": True,
                 "oob_score": False,
                 "random_state": 42
@@ -342,7 +419,7 @@ def get_mcp_data() -> MCPResponse:
                 "mape": 4.2,
                 "cv_rmse": 0.045
             },
-            feature_importance=feature_importance,
+            feature_importance=feature_importance_dict,
             validation_method="Time-series cross validation",
             test_size=0.20,
             training_date=datetime.now().strftime("%Y-%m-%d")
@@ -406,14 +483,17 @@ def prepare_features(input_data: ChillerInput) -> np.ndarray:
 
 def predict_kw_per_tr(input_data: ChillerInput) -> float:
     """Predict Combined_Kw_per_TR using the Random Forest model"""
-    if model is None or scaler is None:
+    if model is None:
         raise ValueError("Model not loaded properly")
     
     # Prepare features
     features = prepare_features(input_data)
     
-    # Scale features (if scaler exists)
-    features_scaled = scaler.transform(features)
+    # Scale features if scaler exists
+    if scaler is not None:
+        features_scaled = scaler.transform(features)
+    else:
+        features_scaled = features
     
     # Predict
     prediction = model.predict(features_scaled)[0]
@@ -431,7 +511,7 @@ def optimize_chw_setpoint(input_data: ChillerInput) -> float:
     best_sp = current_sp
     
     for sp in test_setpoints:
-        # Create test input with modified setpoint (note: setpoint affects chilled water rate)
+        # Create test input with modified setpoint
         test_input = ChillerInput(
             total_building_load_rt=input_data.total_building_load_rt,
             avg_chilled_water_rate_lps=input_data.avg_chilled_water_rate_lps,
@@ -470,13 +550,16 @@ def calculate_savings(current_kw: float, optimal_kw: float, load_rt: float) -> t
 
 def estimate_confidence_interval(input_data: ChillerInput) -> Dict[str, float]:
     """Estimate prediction confidence interval using ensemble variance"""
-    if model is None:
+    if model is None or not hasattr(model, 'estimators_'):
         return {"lower": None, "upper": None, "std": None}
     
     try:
         # Get predictions from all trees
         features = prepare_features(input_data)
-        features_scaled = scaler.transform(features)
+        if scaler is not None:
+            features_scaled = scaler.transform(features)
+        else:
+            features_scaled = features
         
         # Get individual tree predictions
         tree_predictions = np.array([tree.predict(features_scaled)[0] 
@@ -528,10 +611,10 @@ async def health():
     return {
         "status": "healthy" if model is not None else "degraded",
         "model_loaded": model is not None,
-        "model_type": "RandomForestRegressor" if model is not None else None,
-        "n_estimators": model.n_estimators if model is not None else None,
+        "model_type": type(model).__name__ if model else None,
+        "n_estimators": model.n_estimators if model and hasattr(model, 'n_estimators') else None,
         "scaler_loaded": scaler is not None,
-        "feature_count": 12
+        "feature_count": len(feature_names) if feature_names else 12
     }
 
 @app.get("/mcp", response_model=MCPResponse)
@@ -553,7 +636,7 @@ async def predict_endpoint(input_data: ChillerInput):
     """Predict Combined_Kw_per_TR for given conditions"""
     try:
         if model is None:
-            raise HTTPException(status_code=503, detail="Model not loaded")
+            raise HTTPException(status_code=503, detail="Model not loaded. Please check model files.")
         
         # Make prediction
         kw_per_tr = predict_kw_per_tr(input_data)
@@ -578,7 +661,7 @@ async def optimize_endpoint(input_data: ChillerInput):
     """Get optimization recommendations"""
     try:
         if model is None:
-            raise HTTPException(status_code=503, detail="Model not loaded")
+            raise HTTPException(status_code=503, detail="Model not loaded. Please check model files.")
         
         # Predict current efficiency
         current_kw = predict_kw_per_tr(input_data)
@@ -641,7 +724,7 @@ async def optimize_endpoint(input_data: ChillerInput):
                 operator_action="Check if all chillers are running optimally"
             ))
         
-        # Free cooling recommendation (based on wet bulb approximation)
+        # Free cooling recommendation
         if input_data.avg_outside_temp_f < 50 and input_data.avg_humidity_pct < 60:
             recommendations.append(OptimizationRecommendation(
                 action="Free Cooling",