Update app.py

app.py

@@ -1,6 +1,6 @@
 # ============================================
 # YORK CHILLER OPTIMIZER API
-# Using existing model files with NumPy 2.0
+# Using existing model files with NumPy 1.23.5
 # ============================================
 
 import os
@@ -8,31 +8,22 @@ import sys
 import warnings
 warnings.filterwarnings('ignore')
 
-# CRITICAL: Create numpy._core module before any imports
-# This is needed for models saved with NumPy 2.0
-import importlib
-import types
-
-# Create the missing _core module
-if 'numpy._core' not in sys.modules:
-    mock_core = types.ModuleType('numpy._core')
-    sys.modules['numpy._core'] = mock_core
-    print("✅ Created numpy._core module for compatibility")
-
-# Now import numpy (this will use our mock)
+# Import normally with NumPy 1.23.5
 import numpy as np
 print(f"NumPy version: {np.__version__}")
 
-# Now import everything else
+# Import rest of the libraries
 import joblib
 from datetime import datetime
 from typing import List, Optional, Dict, Any
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel, Field
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.preprocessing import StandardScaler
 
 app = FastAPI(
     title="York Chiller Energy Optimizer",
-    description="Random Forest Model for Chiller Energy Efficiency",
+    description="Random Forest Model for Chiller Energy Efficiency - Based on 12 Operational Features",
     version="2.0.0"
 )
 
@@ -52,26 +43,22 @@ def load_existing_model():
     print("\n📂 Checking for model files...")
     
     # Check what files exist
-    if os.path.exists("production_model.pkl"):
-        print(f"   ✅ Found: production_model.pkl")
-    else:
-        print(f"   ❌ Missing: production_model.pkl")
-        return False
-    
-    if os.path.exists("scaler.pkl"):
-        print(f"   ✅ Found: scaler.pkl")
-    else:
-        print(f"   ⚠️ Missing: scaler.pkl")
+    files_found = []
+    for file in ['production_model.pkl', 'scaler.pkl', 'features.pkl']:
+        if os.path.exists(file):
+            size = os.path.getsize(file) / 1024
+            files_found.append(f"{file} ({size:.1f} KB)")
+            print(f"   ✅ Found: {file}")
+        else:
+            print(f"   ❌ Missing: {file}")
     
-    if os.path.exists("features.pkl"):
-        print(f"   ✅ Found: features.pkl")
-    else:
-        print(f"   ⚠️ Missing: features.pkl")
+    if not os.path.exists("production_model.pkl"):
+        print("❌ production_model.pkl not found! Cannot continue.")
+        return False
     
-    # Load the model with special handling
+    # Load the model
     try:
-        # Try normal load first
-        import joblib
+        # Try loading with joblib
         model = joblib.load("production_model.pkl")
         print(f"\n✅ Model loaded successfully")
         print(f"   Type: {type(model).__name__}")
@@ -92,18 +79,9 @@ def load_existing_model():
             
     except Exception as e:
         print(f"❌ Error loading model: {e}")
-        
-        # Try alternative loading method
-        try:
-            print("   Trying alternative loading method...")
-            import pickle
-            with open("production_model.pkl", 'rb') as f:
-                model = pickle.load(f)
-            print(f"✅ Model loaded with pickle")
-            model_feature_count = 12
-        except Exception as e2:
-            print(f"❌ Alternative loading failed: {e2}")
-            return False
+        print(f"   This might be a NumPy version mismatch.")
+        print(f"   Current NumPy: {np.__version__}")
+        return False
     
     # Load scaler
     try:
@@ -119,10 +97,12 @@ def load_existing_model():
         if os.path.exists("features.pkl"):
             feature_names = joblib.load("features.pkl")
             print(f"✅ Features loaded from features.pkl")
-            print(f"   Features: {feature_names}")
             if isinstance(feature_names, list):
-                model_feature_count = len(feature_names)
-                print(f"   Updated feature count to: {model_feature_count}")
+                print(f"   Feature count: {len(feature_names)}")
+                print(f"   First 5 features: {feature_names[:5]}")
+                # Update feature count if needed
+                if model_feature_count == 0:
+                    model_feature_count = len(feature_names)
     except Exception as e:
         print(f"⚠️ Could not load feature names: {e}")
         # Create default 12 feature names
@@ -149,13 +129,14 @@ load_success = load_existing_model()
 
 if model:
     print(f"\n📊 Model Configuration:")
-    print(f"   Status: ONLINE")
+    print(f"   Status: ✅ ONLINE")
     print(f"   Features expected: {model_feature_count}")
-    print(f"   Scaler: {'Loaded' if scaler else 'Not loaded'}")
+    print(f"   Scaler: {'✅ Loaded' if scaler else '❌ Not loaded'}")
+    print(f"   NumPy version: {np.__version__}")
 else:
     print(f"\n📊 Model Configuration:")
-    print(f"   Status: OFFLINE - Model failed to load")
-    print(f"   Check NumPy version compatibility")
+    print(f"   Status: ❌ OFFLINE")
+    print(f"   NumPy version: {np.__version__}")
 
 # ============================================
 # REQUEST MODELS
@@ -177,8 +158,8 @@ class ChillerInput(BaseModel):
     day_of_year: int = Field(..., ge=1, le=366, description="Day of the year (1-365)")
     
     # Optional optimization parameters
-    current_chw_setpoint_c: Optional[float] = Field(8.0, ge=5, le=10)
-    current_limit_pct: Optional[float] = Field(100, ge=50, le=100)
+    current_chw_setpoint_c: Optional[float] = Field(8.0, ge=5, le=10, description="Current CHW setpoint (°C)")
+    current_limit_pct: Optional[float] = Field(100, ge=50, le=100, description="Current limit percentage")
 
 class PredictionResponse(BaseModel):
     status: str
@@ -204,42 +185,58 @@ class OptimizeResponse(BaseModel):
     summary: Dict[str, str]
 
 # ============================================
-# PREDICTION FUNCTION
+# FEATURE PREPARATION FUNCTION
 # ============================================
 
-def prepare_features(input_data: ChillerInput) -> np.ndarray:
-    """Prepare features in the correct order for the model"""
+def prepare_features_for_model(input_data: ChillerInput) -> np.ndarray:
+    """
+    Prepare features in the order expected by the model
+    Uses feature_names from features.pkl if available
+    """
+    
+    # Create dictionary of all possible features
+    feature_dict = {
+        'total_building_load_rt': input_data.total_building_load_rt,
+        'avg_chilled_water_rate_lps': input_data.avg_chilled_water_rate_lps,
+        'avg_cooling_water_temp_c': input_data.avg_cooling_water_temp_c,
+        'avg_outside_temp_f': input_data.avg_outside_temp_f,
+        'avg_dew_point_f': input_data.avg_dew_point_f,
+        'avg_humidity_pct': input_data.avg_humidity_pct,
+        'avg_wind_speed_mph': input_data.avg_wind_speed_mph,
+        'avg_pressure_in': input_data.avg_pressure_in,
+        'hour': input_data.hour,
+        'day_of_week': input_data.day_of_week,
+        'month': input_data.month,
+        'day_of_year': input_data.day_of_year,
+        # Alternative names that might be in the model
+        'load': input_data.total_building_load_rt,
+        'chilled_water_flow': input_data.avg_chilled_water_rate_lps,
+        'outside_temp': input_data.avg_outside_temp_f,
+        'humidity': input_data.avg_humidity_pct,
+    }
     
-    # Create feature array based on feature_names from features.pkl
+    # If we have feature names from features.pkl, use them
     if feature_names and isinstance(feature_names, list):
-        # Build features in the order specified by features.pkl
-        feature_dict = {
-            'total_building_load_rt': input_data.total_building_load_rt,
-            'avg_chilled_water_rate_lps': input_data.avg_chilled_water_rate_lps,
-            'avg_cooling_water_temp_c': input_data.avg_cooling_water_temp_c,
-            'avg_outside_temp_f': input_data.avg_outside_temp_f,
-            'avg_dew_point_f': input_data.avg_dew_point_f,
-            'avg_humidity_pct': input_data.avg_humidity_pct,
-            'avg_wind_speed_mph': input_data.avg_wind_speed_mph,
-            'avg_pressure_in': input_data.avg_pressure_in,
-            'hour': input_data.hour,
-            'day_of_week': input_data.day_of_week,
-            'month': input_data.month,
-            'day_of_year': input_data.day_of_year
-        }
-        
-        # Build array in the order of feature_names
         features_list = []
         for f_name in feature_names:
             if f_name in feature_dict:
                 features_list.append(feature_dict[f_name])
             else:
-                # If feature name not found, use 0
-                print(f"   ⚠️ Feature '{f_name}' not found, using 0")
-                features_list.append(0.0)
+                # Try to find alternative
+                found = False
+                for key in feature_dict:
+                    if f_name.lower() in key.lower() or key.lower() in f_name.lower():
+                        features_list.append(feature_dict[key])
+                        print(f"   Mapped '{f_name}' → '{key}'")
+                        found = True
+                        break
+                if not found:
+                    # Default value if feature not found
+                    print(f"   ⚠️ Feature '{f_name}' not found, using 0")
+                    features_list.append(0.0)
         
         features = np.array([features_list])
-        print(f"   Using {len(features_list)} features from features.pkl")
+        print(f"   Prepared {len(features_list)} features from features.pkl")
         
     else:
         # Default: use all 12 features in standard order
@@ -257,7 +254,7 @@ def prepare_features(input_data: ChillerInput) -> np.ndarray:
             input_data.month,
             input_data.day_of_year
         ]])
-        print(f"   Using default 12 features")
+        print(f"   Prepared default 12 features")
     
     # Apply scaler if available
     if scaler is not None:
@@ -270,12 +267,14 @@ def prepare_features(input_data: ChillerInput) -> np.ndarray:
     return features
 
 def predict_kw_per_tr(input_data: ChillerInput) -> float:
-    """Predict Combined_Kw_per_TR"""
+    """Predict Combined_Kw_per_TR using the loaded model"""
     if model is None:
         raise ValueError("Model not loaded")
     
-    features = prepare_features(input_data)
+    features = prepare_features_for_model(input_data)
     prediction = model.predict(features)[0]
+    
+    # Clip to realistic range
     prediction = np.clip(prediction, 0.4, 1.2)
     
     return float(prediction)
@@ -296,7 +295,8 @@ async def root():
             "loaded": model is not None,
             "features_expected": model_feature_count,
             "features_from_pkl": len(feature_names) if feature_names else 0,
-            "scaler_loaded": scaler is not None
+            "scaler_loaded": scaler is not None,
+            "numpy_version": np.__version__
         },
         "endpoints": {
             "/": "This information",
@@ -305,7 +305,8 @@ async def root():
             "/optimize": "POST - Get optimization recommendations"
         },
         "interpretation": {
-            "kw_per_tr": "Combined energy efficiency - LOWER is better",
+            "kw_per_tr": "Combined energy efficiency indicator - LOWER is better",
+            "typical_range": "0.45 - 1.0 kW/TR",
             "excellent": "< 0.55 kW/TR",
             "good": "0.55-0.65 kW/TR",
             "fair": "0.65-0.75 kW/TR",
@@ -327,10 +328,10 @@ async def health():
 
 @app.post("/predict", response_model=PredictionResponse)
 async def predict_endpoint(input_data: ChillerInput):
-    """Predict Combined_Kw_per_TR"""
+    """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 - check logs")
         
         kw_per_tr = predict_kw_per_tr(input_data)
         
@@ -350,12 +351,12 @@ 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 - check logs")
         
         # Current efficiency
         current_kw = predict_kw_per_tr(input_data)
         
-        # Test different CHW setpoints
+        # Test different CHW setpoints to find optimum
         current_sp = input_data.current_chw_setpoint_c or 8.0
         test_setpoints = [6.0, 6.5, 7.0, 7.5, 8.0, 8.5, 9.0, 9.5, 10.0]
         
@@ -387,7 +388,27 @@ async def optimize_endpoint(input_data: ChillerInput):
                 recommended_value=f"{best_sp:.1f}°C",
                 expected_savings=f"{savings_pct:.1f}%",
                 priority="HIGH" if savings_pct > 5 else "MEDIUM",
-                operator_action=f"Adjust CHW setpoint to {best_sp:.1f}°C"
+                operator_action=f"Adjust CHW setpoint from {current_sp:.1f}°C to {best_sp:.1f}°C on chiller controller"
+            ))
+        
+        # Load-based recommendations
+        if input_data.total_building_load_rt < 600:
+            recommendations.append(OptimizationRecommendation(
+                action="Chiller Sequencing",
+                current_value=f"{input_data.total_building_load_rt:.0f} RT",
+                recommended_value="Single chiller operation",
+                expected_savings="15-25% reduction in parasitic losses",
+                priority="HIGH",
+                operator_action="Consider operating only one chiller"
+            ))
+        elif input_data.total_building_load_rt > 1800:
+            recommendations.append(OptimizationRecommendation(
+                action="Chiller Staging",
+                current_value=f"{input_data.total_building_load_rt:.0f} RT",
+                recommended_value="Verify all chillers online",
+                expected_savings="Prevents overload conditions",
+                priority="HIGH",
+                operator_action="Check if all chillers are operating properly"
             ))
         
         # Efficiency rating
@@ -409,7 +430,8 @@ async def optimize_endpoint(input_data: ChillerInput):
             "optimal_efficiency": f"{best_kw:.3f} kW/TR",
             "potential_savings": f"{savings_pct:.1f}%",
             "efficiency_rating": rating,
-            "recommendation": message
+            "recommendation": message,
+            "load": f"{input_data.total_building_load_rt:.0f} RT"
         }
         
         return OptimizeResponse(