import streamlit as st import os import traceback st.set_page_config( page_title="SolarIQ · PV Forecast", layout="wide", page_icon="S", initial_sidebar_state="collapsed" ) st.markdown(""" """, unsafe_allow_html=True) BASE_DIR = os.path.dirname(os.path.abspath(__file__)) MODELS = { "2025-26 Model": "2025_26_model", "2024 Model": "2024_model", "2023 Model": "2023_model", "2016-17 Model": "2016_17_model", } def get_folder_path(model_key): rel = MODELS[model_key] abs_path = os.path.join(BASE_DIR, rel) return abs_path if os.path.isdir(abs_path) else os.path.join(os.getcwd(), rel) @st.cache_resource(max_entries=4) def load_assets(folder_path): import torch import torch.nn as nn import torch.nn.functional as F import joblib import json class TFTBranch(nn.Module): def __init__(self, input_dim, hidden_dim, num_horizons): super().__init__() self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers=2, batch_first=True, dropout=0.2) self.attention = nn.MultiheadAttention(embed_dim=hidden_dim, num_heads=4, batch_first=True, dropout=0.2) self.dropout = nn.Dropout(0.2) self.fc = nn.Linear(hidden_dim, num_horizons) def forward(self, x): lstm_out, _ = self.lstm(x) lstm_out = self.dropout(lstm_out) attn_out, attn_weights = self.attention(lstm_out, lstm_out, lstm_out) attn_out = self.dropout(attn_out) return self.fc(attn_out[:, -1, :]), attn_weights class NBEATSBlock(nn.Module): def __init__(self, input_size, theta_size, hidden_size): super().__init__() self.fc1 = nn.Linear(input_size, hidden_size) self.fc2 = nn.Linear(hidden_size, hidden_size) self.fc3 = nn.Linear(hidden_size, hidden_size) self.fc4 = nn.Linear(hidden_size, hidden_size) self.dropout = nn.Dropout(0.2) self.theta_layer = nn.Linear(hidden_size, theta_size) self.backcast_layer = nn.Linear(theta_size, input_size) self.forecast_layer = nn.Linear(theta_size, theta_size) def forward(self, x): h = self.dropout(F.relu(self.fc1(x))) h = self.dropout(F.relu(self.fc2(h))) h = self.dropout(F.relu(self.fc3(h))) h = self.dropout(F.relu(self.fc4(h))) theta = self.theta_layer(h) return self.backcast_layer(theta), self.forecast_layer(theta), theta class NBEATSBranch(nn.Module): def __init__(self, seq_len, num_horizons, hidden_size=128): super().__init__() self.trend_block = NBEATSBlock(seq_len, num_horizons, hidden_size) self.seasonality_block = NBEATSBlock(seq_len, num_horizons, hidden_size) def forward(self, x): x_flat = x[:, :, 0] backcast_t, forecast_t, _ = self.trend_block(x_flat) _, forecast_s, _ = self.seasonality_block(x_flat - backcast_t) return forecast_t + forecast_s, forecast_t, forecast_s class HybridFusionModel(nn.Module): def __init__(self, input_dim, seq_len, hidden_dim, num_horizons): super().__init__() self.tft = TFTBranch(input_dim, hidden_dim, num_horizons) self.nbeats = NBEATSBranch(seq_len, num_horizons, hidden_dim) self.attention_fusion = nn.Sequential( nn.Linear(num_horizons * 2, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, 2), nn.Softmax(dim=-1) ) def forward(self, x): tft_out, tft_attn = self.tft(x) nbeats_out, nbeats_trend, nbeats_season = self.nbeats(x) weights = self.attention_fusion(torch.cat([tft_out, nbeats_out], dim=-1)) w_tft = weights[:, 0].unsqueeze(1) w_nbeats = weights[:, 1].unsqueeze(1) return (tft_out * w_tft) + (nbeats_out * w_nbeats), tft_attn, nbeats_trend, nbeats_season try: with open(os.path.join(folder_path, "config.json")) as f: config = json.load(f) scaler = joblib.load(os.path.join(folder_path, "scaler.pkl")) model_path = os.path.join(folder_path, "pytorch_model.bin") model = HybridFusionModel( config.get("input_dim", 12), config.get("seq_len", 144), config.get("hidden_dim", 64), config.get("num_horizons", 5) ) try: state_dict = torch.load(model_path, map_location="cpu", weights_only=True) except Exception: state_dict = torch.load(model_path, map_location="cpu", weights_only=False) model.load_state_dict(state_dict, strict=False) model.eval() return model, scaler, config, None except Exception: return None, None, None, traceback.format_exc() def get_all_feature_names(model_key): folder_path = get_folder_path(model_key) try: import json with open(os.path.join(folder_path, "config.json")) as f: cfg = json.load(f) input_dim = cfg.get("input_dim", 12) return cfg.get("numeric_cols", [f"Feature_{i}" for i in range(input_dim)]) except Exception: return [f"Feature_{i}" for i in range(12)] def build_full_input_row(user_inputs, all_feature_names): row = {feat: 0.0 for feat in all_feature_names} name_matched = 0 for feat, val in user_inputs.items(): if feat in row: row[feat] = val name_matched += 1 if name_matched == 0: user_vals = list(user_inputs.values()) for i, feat in enumerate(all_feature_names[:len(user_vals)]): row[feat] = user_vals[i] return row, name_matched def build_temporal_sequence(scaled_row, seq_len, user_inputs): import numpy as np ghi = user_inputs.get("101_DKA_WeatherStation_Global_Horizontal_Radiation", 0.0) pv = user_inputs.get("241_DKA_Totals_PV_Active_Power", 0.0) temp = user_inputs.get("101_DKA_WeatherStation_Weather_Temperature_Celsius", 25.0) hum = user_inputs.get("101_DKA_WeatherStation_Weather_Relative_Humidity", 50.0) wspd = user_inputs.get("101_DKA_WeatherStation_Wind_Speed", 0.0) ghi_norm = min(ghi / 1400.0, 1.0) pv_norm = min(pv / 5000.0, 1.0) temp_norm = (temp + 10.0) / 65.0 hum_norm = hum / 100.0 wspd_norm = min(wspd / 25.0, 1.0) seq = np.tile(scaled_row, (seq_len, 1)).copy() t = np.linspace(0, 1, seq_len) morning_ramp = np.clip(ghi_norm * np.sin(np.pi * t) * 0.35, 0, 0.35) temp_drift = temp_norm * np.linspace(0, 0.12, seq_len) cloud_ripple = hum_norm * 0.08 * np.sin(2 * np.pi * t * 3 + ghi_norm * np.pi) wind_effect = wspd_norm * 0.05 * np.sin(2 * np.pi * t * 7 + pv_norm * 0.5) baseline_shift = pv_norm * np.linspace(0, 0.15, seq_len) radiation_signal = morning_ramp + cloud_ripple + wind_effect power_signal = baseline_shift + temp_drift num_features = seq.shape[1] for i in range(num_features): if i % 3 == 0: seq[:, i] += radiation_signal elif i % 3 == 1: seq[:, i] += power_signal else: seq[:, i] += (radiation_signal + power_signal) * 0.5 return seq def compute_physics_adjusted_forecast(raw_forecast, user_inputs): import numpy as np ghi = user_inputs.get("101_DKA_WeatherStation_Global_Horizontal_Radiation", 0.0) dhi = user_inputs.get("101_DKA_WeatherStation_Diffuse_Horizontal_Radiation", 0.0) temp = user_inputs.get("101_DKA_WeatherStation_Weather_Temperature_Celsius", 25.0) hum = user_inputs.get("101_DKA_WeatherStation_Weather_Relative_Humidity", 50.0) wspd = user_inputs.get("101_DKA_WeatherStation_Wind_Speed", 0.0) pv_now = user_inputs.get("241_DKA_Totals_PV_Active_Power", 0.0) bess = user_inputs.get("239_DKA_Totals_BESS_State_of_Charge", 50.0) rain = user_inputs.get("101_DKA_WeatherStation_Rainfall", 0.0) irradiance_factor = ghi / 850.0 diffuse_ratio = dhi / (ghi + 1e-6) temp_derating = 1.0 - max(0.0, (temp - 25.0) * 0.004) humidity_loss = 1.0 - (hum / 100.0) * 0.03 wind_cooling = 1.0 + min(wspd / 15.0, 0.3) * 0.02 rain_loss = 1.0 - min(rain / 10.0, 0.5) * 0.15 bess_boost = 1.0 + (bess / 100.0) * 0.05 current_efficiency = ( irradiance_factor * temp_derating * humidity_loss * wind_cooling * rain_loss * bess_boost ) current_efficiency = max(0.0, min(current_efficiency, 2.5)) horizon_decay = np.array([1.0, 0.97, 0.93, 0.88, 0.82]) horizon_decay = horizon_decay[:len(raw_forecast)] irradiance_decay = np.array([1.0, 0.94, 0.85, 0.74, 0.62]) irradiance_decay = irradiance_decay[:len(raw_forecast)] diffuse_correction = 1.0 - diffuse_ratio * 0.15 adjusted = ( raw_forecast[:len(horizon_decay)] * current_efficiency * horizon_decay * (irradiance_decay * (1 - diffuse_ratio) + diffuse_correction * diffuse_ratio) ) if pv_now > 0: anchor_weight = np.linspace(0.40, 0.05, len(adjusted)) adjusted = adjusted * (1 - anchor_weight) + pv_now * anchor_weight * current_efficiency adjusted = np.clip(adjusted, 0.0, 5000.0) return adjusted def run_inference(selected_model, user_inputs): import torch import numpy as np import pandas as pd folder_path = get_folder_path(selected_model) model, scaler, config, error = load_assets(folder_path) if error: return None, None, None, None, error seq_len_cfg = config.get("seq_len", 144) all_feature_names = get_all_feature_names(selected_model) full_row, name_matched = build_full_input_row(user_inputs, all_feature_names) input_df = pd.DataFrame([full_row]) scaled_data = scaler.transform(input_df) input_seq = build_temporal_sequence(scaled_data, seq_len_cfg, user_inputs) input_tensor = torch.tensor(input_seq, dtype=torch.float32).unsqueeze(0) with torch.no_grad(): preds, _, _, _ = model(input_tensor) raw_forecast = preds.detach().cpu().numpy().flatten() adjusted_forecast = compute_physics_adjusted_forecast(raw_forecast, user_inputs) return adjusted_forecast, config, seq_len_cfg, name_matched, None def main(): st.markdown("""

SolarIQ

PV Power Forecast Platform

Forecast

History

Analytics

Settings

TFT + N-BEATS

Live

""", unsafe_allow_html=True) left_col, right_col = st.columns([1, 1.75], gap="large") with left_col: st.markdown("""

Input Parameters

Live Sync

""", unsafe_allow_html=True) st.markdown('

Temporal Model

', unsafe_allow_html=True) selected_model = st.selectbox("Active Model", list(MODELS.keys()), label_visibility="collapsed") st.markdown('

Timestamp

', unsafe_allow_html=True) col_date, col_time = st.columns(2) with col_date: input_date = st.date_input("Date", label_visibility="visible") with col_time: input_time = st.time_input("Time", label_visibility="visible") st.markdown('

Solar Radiation

', unsafe_allow_html=True) col_a, col_b = st.columns(2) with col_a: ghi_val = st.number_input("Global Horizontal (W/m2)", min_value=0.0, max_value=1400.0, value=850.0, format="%.1f") with col_b: dhi_val = st.number_input("Diffuse Horizontal (W/m2)", min_value=0.0, max_value=800.0, value=120.0, format="%.1f") st.markdown('

Ambient Conditions

', unsafe_allow_html=True) col_c, col_d = st.columns(2) with col_c: temp_val = st.number_input("Temperature (C)", min_value=-10.0, max_value=55.0, value=31.2, format="%.1f") with col_d: hum_val = st.number_input("Rel. Humidity (%)", min_value=0.0, max_value=100.0, value=38.5, format="%.1f") st.markdown('

Wind and Precipitation

', unsafe_allow_html=True) col_e, col_f, col_g = st.columns(3) with col_e: wspd_val = st.number_input("Wind Speed (m/s)", min_value=0.0, max_value=25.0, value=3.5, format="%.1f") with col_f: wdir_val = st.number_input("Direction (deg)", min_value=0.0, max_value=360.0, value=51.0, format="%.1f") with col_g: rain_val = st.number_input("Rainfall (mm)", min_value=0.0, max_value=50.0, value=0.0, format="%.1f") st.markdown('

Plant State

', unsafe_allow_html=True) col_h, col_i = st.columns(2) with col_h: bess_val = st.number_input("Battery SoC (%)", min_value=0.0, max_value=100.0, value=72.0, format="%.1f") with col_i: pv_val = st.number_input("PV Active Power (kW)", min_value=0.0, max_value=5000.0, value=152.0, format="%.1f") user_inputs = { "101_DKA_WeatherStation_Global_Horizontal_Radiation": ghi_val, "101_DKA_WeatherStation_Diffuse_Horizontal_Radiation": dhi_val, "101_DKA_WeatherStation_Weather_Temperature_Celsius": temp_val, "101_DKA_WeatherStation_Weather_Relative_Humidity": hum_val, "101_DKA_WeatherStation_Wind_Speed": wspd_val, "101_DKA_WeatherStation_Wind_Direction": wdir_val, "101_DKA_WeatherStation_Rainfall": rain_val, "239_DKA_Totals_BESS_State_of_Charge": bess_val, "241_DKA_Totals_PV_Active_Power": pv_val, } st.markdown("

", unsafe_allow_html=True) st.markdown("""

Model ready · TFT + N-BEATS hybrid · Updates on every change

""", unsafe_allow_html=True) with right_col: st.markdown("""

Forecast Results

5 Horizons Auto-updating

""", unsafe_allow_html=True) try: with st.spinner("Computing forecast..."): forecast, config, seq_len_cfg, name_matched, error = run_inference(selected_model, user_inputs) if error: st.error("Failed to load model assets.") st.code(error) else: import plotly.graph_objects as go if name_matched == 0: st.markdown( '

Feature names unmatched — using positional assignment for input mapping.

', unsafe_allow_html=True ) horizon_labels = ["30 Min", "2 Hrs", "6 Hrs", "12 Hrs", "24 Hrs"] horizon_labels = horizon_labels[:len(forecast)] vals = forecast[:len(horizon_labels)] cards_html = '

' for i, (lbl, val) in enumerate(zip(horizon_labels, vals)): prime = "prime" if i == 0 else "" if i == 0: delta_cls, delta_txt = "nu", "Nearest horizon" elif val >= vals[i - 1]: pct = abs((val - vals[i - 1]) / (vals[i - 1] + 1e-6) * 100) delta_cls, delta_txt = "up", f"+ {pct:.1f}%" else: pct = abs((val - vals[i - 1]) / (vals[i - 1] + 1e-6) * 100) delta_cls, delta_txt = "dn", f"- {pct:.1f}%" cards_html += f"""

{lbl}

{val:.1f}kW

{delta_txt}

""" cards_html += "

" st.markdown(cards_html, unsafe_allow_html=True) st.markdown('

Forecast Trend

', unsafe_allow_html=True) now_labels = ["Now"] + [f"+{lbl}" for lbl in horizon_labels] chart_vals = [float(vals[0])] + [float(v) for v in vals] fig = go.Figure() fig.add_trace(go.Scatter( x=now_labels, y=chart_vals, fill='tozeroy', fillcolor='rgba(60,140,20,0.07)', line=dict(color='rgba(0,0,0,0)'), showlegend=False, hoverinfo='skip' )) fig.add_trace(go.Scatter( x=now_labels, y=[max(chart_vals) * 1.10] * len(now_labels), fill='tonexty', fillcolor='rgba(60,140,20,0.022)', line=dict(color='rgba(0,0,0,0)'), showlegend=False, hoverinfo='skip' )) fig.add_trace(go.Scatter( x=now_labels, y=chart_vals, mode='lines+markers', name='Forecast', line=dict(color='#3A8A20', width=2.8, shape='spline', smoothing=0.85), marker=dict( size=[15] + [9] * len(vals), color=['#3A8A20'] + ['#FFFFFF'] * len(vals), line=dict(color='#3A8A20', width=2.2), ), hovertemplate='%{x}
%{y:.2f} kW' )) fig.update_layout( template='plotly_white', paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)', margin=dict(l=10, r=10, t=14, b=10), height=265, showlegend=False, hovermode='x unified', font=dict(family='DM Sans, sans-serif', color='#7A9860'), xaxis=dict( showgrid=False, zeroline=False, tickfont=dict(family='DM Sans', size=11, color='#7A9860'), linecolor='rgba(100,160,60,0.14)', showline=True ), yaxis=dict( showgrid=True, gridcolor='rgba(100,160,60,0.10)', zeroline=False, tickfont=dict(family='JetBrains Mono', size=10, color='#7A9860'), title_text='kW', title_font=dict(size=11, color='#7A9860', family='DM Sans'), tickformat='.0f' ) ) st.plotly_chart(fig, use_container_width=True, config={'displayModeBar': False}) st.markdown(f"""

Architecture

TFT + N-BEATS

Active Inputs

{name_matched if name_matched > 0 else len(user_inputs)} Features

Lookback Window

{seq_len_cfg} steps

""", unsafe_allow_html=True) st.markdown("

", unsafe_allow_html=True) with st.expander("Technical Model Configuration"): st.json(config) except Exception: st.error("Error during inference:") st.code(traceback.format_exc()) st.markdown("""

SolarIQ · Hybrid Fusion Model · TFT + N-BEATS · Renewable Energy AI

""", unsafe_allow_html=True) if __name__ == "__main__": main() else: main()