Upload app.py

app.py

@@ -1,3 +1,4 @@
+
 import os
 import time
 import pandas as pd
@@ -6,6 +7,9 @@ import joblib
 import requests
 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")
@@ -62,12 +66,12 @@ def get_next_row():
 
 # Feature engineering
 def engineer(df):
-    # Handle timestamp
     if pd.api.types.is_numeric_dtype(df["timestamp"]):
         df["datetime"] = pd.to_datetime(df["timestamp"], unit="s")
     else:
         df["datetime"] = pd.to_datetime(df["timestamp"])
 
+    df = df.sort_values("datetime")
     df["hour_of_day"] = df["datetime"].dt.hour
     df["lag_30min"] = df["power_consumption_kwh"].shift(1)
     df["lag_1h"] = df["power_consumption_kwh"].shift(2)
@@ -77,17 +81,11 @@ 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)
 
-    # One-hot encode property_type and region
     df = pd.get_dummies(df, columns=["property_type", "region"], drop_first=False)
 
-    
-
-    # Ensure all expected features exist
     expected_features = [
-        'lag_30min', 'lag_1h',
-        'rolling_avg_1h', 'rolling_avg_2h',
-        'hour_of_day', 'is_weekend',
-        'hour_sin', 'hour_cos',
+        'lag_30min', 'lag_1h', 'rolling_avg_1h', 'rolling_avg_2h',
+        'hour_of_day', 'is_weekend', 'hour_sin', 'hour_cos',
         'temperature_c', 'ev_owner', 'solar_installed',
         'property_type_commercial', 'property_type_residential',
         'region_north', 'region_south', 'region_east', 'region_west'
@@ -99,37 +97,68 @@ def engineer(df):
 
     return df
 
-# UI layout
-st.title("⚡ Gridflux: Live Smart-Meter Forecast")
-
-placeholder_chart = st.empty()
-placeholder_metric = st.empty()
-
+# Forecast ahead logic
+def forecast_next(df, model, steps=5):
+    forecasts = []
+    df_copy = df.copy()
+    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_]]
+        y_pred = model.predict(input_row)[0]
+        df_copy.loc[df_copy.index[-1], "power_consumption_kwh"] = y_pred
+        df_copy = df_copy.append({**df_copy.iloc[-1], "power_consumption_kwh": y_pred, "timestamp": df_copy.iloc[-1].timestamp + 1800}, ignore_index=True)
+        forecasts.append({"timestamp": df_copy.iloc[-1].timestamp, "forecast_kwh": y_pred})
+    return pd.DataFrame(forecasts)
+
+# UI Layout
+st.set_page_config(layout="wide")
+st.title("⚡ Gridflux: Real-Time Smart Meter Dashboard")
+
+# Layout structure
+col1, col2 = st.columns([2, 1])
+
+# Data ingestion and prediction
 new_row = get_next_row()
-
 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]][[
-            'lag_30min', 'lag_1h',
-            'rolling_avg_1h', 'rolling_avg_2h',
-            'hour_of_day', 'is_weekend',
-            'hour_sin', 'hour_cos',
-            'temperature_c', 'ev_owner', 'solar_installed',
-            'property_type_commercial', 'property_type_residential',
-            'region_north', 'region_south', 'region_east', 'region_west'
-        ]]
-
+        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]
-
-        # Show outputs
-        chart_df = st.session_state.history.copy()
-        chart_df["datetime"] = pd.to_datetime(chart_df["timestamp"])
-        chart_df.set_index("datetime", inplace=True)
-
-        placeholder_chart.line_chart(chart_df["power_consumption_kwh"])
-        placeholder_metric.metric("🔮 Predicted Power Usage (kWh)", f"{prediction:.3f}")
+        actual = new_row["power_consumption_kwh"].values[0]
+        mae = mean_absolute_error([actual], [prediction])
+
+        with col1:
+            st.subheader("📊 Real-Time Power Usage")
+            chart_df = st.session_state.history.copy()
+            chart_df["datetime"] = pd.to_datetime(chart_df["timestamp"])
+            chart_df.set_index("datetime", inplace=True)
+            st.line_chart(chart_df["power_consumption_kwh"], use_container_width=True)
+
+            st.subheader("🔮 Forecast (Next 2.5 Hours)")
+            future_df = forecast_next(df_feat, model, steps=5)
+            future_df["datetime"] = pd.to_datetime(future_df["timestamp"])
+            fig = px.line(future_df, x="datetime", y="forecast_kwh", title="Forecasted Power Usage (Next 2.5h)")
+            st.plotly_chart(fig, use_container_width=True)
+
+        with col2:
+            st.metric("🔮 Predicted Power Usage (kWh)", f"{prediction:.3f}")
+            st.metric("✅ Actual Power Usage (kWh)", f"{actual:.3f}")
+            st.metric("📏 MAE", f"{mae:.3f}")
+
+            st.subheader("🌍 Region-Wise Forecast")
+            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")
+
+            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_]])
+                        st.write(f"{region.title()} / {ptype.title()}: {np.mean(preds):.2f} kWh")
 else:
     st.success("✅ All data processed.")