Upload app.py

app.py

@@ -9,6 +9,7 @@ import streamlit as st
 from streamlit_autorefresh import st_autorefresh
 from sklearn.metrics import mean_absolute_error
 import plotly.express as px
+import plotly.graph_objects as go
 
 # Auto-refresh every 5 seconds
 st_autorefresh(interval=5000, key="refresh")
@@ -80,7 +81,9 @@ def engineer(df):
     df["hour_sin"] = np.sin(2 * np.pi * df["hour_of_day"] / 24)
     df["hour_cos"] = np.cos(2 * np.pi * df["hour_of_day"] / 24)
 
-    df = pd.get_dummies(df, columns=["property_type", "region"], drop_first=False)
+    # Only one-hot encode if columns exist
+    if "property_type" in df.columns and "region" in df.columns:
+        df = pd.get_dummies(df, columns=["property_type", "region"], drop_first=False)
 
     expected_features = [
         'lag_30min', 'lag_1h', 'rolling_avg_1h', 'rolling_avg_2h',
@@ -96,33 +99,21 @@ def engineer(df):
 
     return df
 
-# Forecast ahead logic (5 steps, 30min intervals)
+# Forecast ahead logic
 def forecast_next(df, model, steps=5):
     forecasts = []
     df_copy = df.copy()
-    expected_features = model.feature_names_in_.tolist()
-
     for i in range(steps):
         df_copy = engineer(df_copy).dropna()
-        # Ensure columns are aligned to model input
-        input_row = df_copy.iloc[[-1]][expected_features]
+        input_row = df_copy.iloc[[-1]][[col for col in df_copy.columns if col in model.feature_names_in_]]
         y_pred = model.predict(input_row)[0]
-
-        # Update the last row's power consumption with prediction
-        df_copy.at[df_copy.index[-1], "power_consumption_kwh"] = y_pred
-
-        # Prepare the next timestamp: add 1800 seconds (30 mins)
-        next_timestamp = df_copy.iloc[-1]["timestamp"] + 1800
-
-        # Prepare new row: copy last row features but update timestamp and power consumption
+        df_copy.loc[df_copy.index[-1], "power_consumption_kwh"] = y_pred
+        # Append new row with updated timestamp (+30 minutes = 1800 seconds)
         new_row = df_copy.iloc[-1].copy()
         new_row["power_consumption_kwh"] = y_pred
-        new_row["timestamp"] = next_timestamp
-
-        # Append new row safely
+        new_row["timestamp"] = new_row["timestamp"] + 1800
         df_copy = pd.concat([df_copy, pd.DataFrame([new_row])], ignore_index=True)
-        forecasts.append({"timestamp": next_timestamp, "forecast_kwh": y_pred})
-
+        forecasts.append({"timestamp": new_row["timestamp"], "forecast_kwh": y_pred})
     return pd.DataFrame(forecasts)
 
 # UI Layout
@@ -138,14 +129,7 @@ if not new_row.empty:
     st.session_state.history = pd.concat([st.session_state.history, new_row], ignore_index=True)
     df_feat = engineer(st.session_state.history).dropna()
     if not df_feat.empty:
-        # Align features exactly to what model expects
-        expected_features = model.feature_names_in_.tolist()
-        for col in expected_features:
-            if col not in df_feat.columns:
-                df_feat[col] = 0
-
-        latest_input = df_feat[expected_features].iloc[[-1]]
-
+        latest_input = df_feat.iloc[[-1]][[col for col in df_feat.columns if col in model.feature_names_in_]]
         prediction = model.predict(latest_input)[0]
         actual = new_row["power_consumption_kwh"].values[0]
         mae = mean_absolute_error([actual], [prediction])
@@ -172,15 +156,15 @@ if not new_row.empty:
             for region in ["east", "west", "north", "south"]:
                 regional = df_feat[df_feat[f"region_{region}"] == 1]
                 if not regional.empty:
-                    preds = model.predict(regional[expected_features])
-                    st.write(f"**{region.title()} Region**: Avg Forecast: {np.mean(preds):.3f} kWh")
+                    pred = model.predict(regional[[col for col in regional.columns if col in model.feature_names_in_]])
+                    st.write(f"**{region.title()} Region**: Avg Forecast: {np.mean(pred):.3f} kWh")
 
             st.subheader("🏠 Property Type Forecast")
             for region in ["east", "west", "north", "south"]:
                 for ptype in ["commercial", "residential"]:
                     filtered = df_feat[(df_feat[f"region_{region}"] == 1) & (df_feat[f"property_type_{ptype}"] == 1)]
                     if not filtered.empty:
-                        preds = model.predict(filtered[expected_features])
+                        preds = model.predict(filtered[[col for col in filtered.columns if col in model.feature_names_in_]])
                         st.write(f"{region.title()} / {ptype.title()}: {np.mean(preds):.2f} kWh")
 else:
     st.success("✅ All data processed.")