Upload app.py

app.py

@@ -9,7 +9,6 @@ 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")
@@ -81,9 +80,7 @@ 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)
 
-    # 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)
+    df = pd.get_dummies(df, columns=["property_type", "region"], drop_first=False)
 
     expected_features = [
         'lag_30min', 'lag_1h', 'rolling_avg_1h', 'rolling_avg_2h',
@@ -99,21 +96,33 @@ def engineer(df):
 
     return df
 
-# Forecast ahead logic
+# Forecast ahead logic (5 steps, 30min intervals)
 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()
-        input_row = df_copy.iloc[[-1]][[col for col in df_copy.columns if col in model.feature_names_in_]]
+        # Ensure columns are aligned to model input
+        input_row = df_copy.iloc[[-1]][expected_features]
         y_pred = model.predict(input_row)[0]
-        df_copy.loc[df_copy.index[-1], "power_consumption_kwh"] = y_pred
-        # Append new row with updated timestamp (+30 minutes = 1800 seconds)
+
+        # 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
         new_row = df_copy.iloc[-1].copy()
         new_row["power_consumption_kwh"] = y_pred
-        new_row["timestamp"] = new_row["timestamp"] + 1800
+        new_row["timestamp"] = next_timestamp
+
+        # Append new row safely
         df_copy = pd.concat([df_copy, pd.DataFrame([new_row])], ignore_index=True)
-        forecasts.append({"timestamp": new_row["timestamp"], "forecast_kwh": y_pred})
+        forecasts.append({"timestamp": next_timestamp, "forecast_kwh": y_pred})
+
     return pd.DataFrame(forecasts)
 
 # UI Layout
@@ -129,7 +138,14 @@ 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:
-        latest_input = df_feat.iloc[[-1]][[col for col in df_feat.columns if col in model.feature_names_in_]]
+        # 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]]
+
         prediction = model.predict(latest_input)[0]
         actual = new_row["power_consumption_kwh"].values[0]
         mae = mean_absolute_error([actual], [prediction])
@@ -156,15 +172,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:
-                    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")
+                    preds = model.predict(regional[expected_features])
+                    st.write(f"**{region.title()} Region**: Avg Forecast: {np.mean(preds):.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[[col for col in filtered.columns if col in model.feature_names_in_]])
+                        preds = model.predict(filtered[expected_features])
                         st.write(f"{region.title()} / {ptype.title()}: {np.mean(preds):.2f} kWh")
 else:
     st.success("✅ All data processed.")