tryout

streamlit_simulation/app.py

@@ -251,8 +251,8 @@ def render_simulation_view(timestamp, prediction, actual, progress, fig, paused=
 
         st.metric("Prediction", f"{prediction:,.0f} MW" if prediction is not None else "–")
         st.metric("Actual", f"{actual:,.0f} MW" if actual is not None else "–")
-        st.caption("Simulation Progress")
-        st.progress(progress)
+        #st.caption("Simulation Progress")
+        #st.progress(progress)
 
         if len(st.session_state.true_vals) > 1:
             true_arr = np.array(st.session_state.true_vals)

streamlit_simulation/app_backup_hug.py

@@ -0,0 +1,546 @@
+import sys
+import os
+import streamlit as st
+import pickle
+import pandas as pd
+import time
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+import warnings
+import torch
+
+from config_streamlit import (MODEL_PATH_LIGHTGBM, DATA_PATH, TRAIN_RATIO,
+                             TEXT_COLOR, HEADER_COLOR, ACCENT_COLOR,
+                             BUTTON_BG, BUTTON_HOVER_BG, BG_COLOR,
+                             INPUT_BG, PROGRESS_COLOR, PLOT_COLOR
+                             )
+from lightgbm_model.scripts.config_lightgbm import FEATURES
+from transformer_model.scripts.utils.informer_dataset_class import InformerDataset
+from transformer_model.scripts.training.load_basis_model import load_moment_model
+from transformer_model.scripts.config_transformer import CHECKPOINT_DIR, FORECAST_HORIZON, SEQ_LEN
+from sklearn.preprocessing import StandardScaler
+
+from huggingface_hub import hf_hub_download
+
+
+# ============================== Layout ==============================
+
+# Streamlit & warnings config
+warnings.filterwarnings("ignore", category=FutureWarning)
+st.set_page_config(page_title="Electricity Consumption Forecast", layout="wide")
+
+#CSS part
+st.markdown(f"""
+    <style>
+        body, .block-container {{
+            background-color: {BG_COLOR} !important;
+        }}
+
+        html, body, [class*="css"] {{
+            color: {TEXT_COLOR} !important;
+            font-family: 'sans-serif';
+        }}
+
+        h1, h2, h3, h4, h5, h6 {{
+            color: {HEADER_COLOR} !important;
+        }}
+
+        .stButton > button {{
+            background-color: {BUTTON_BG};
+            color: {TEXT_COLOR};
+            border: 1px solid {ACCENT_COLOR};
+        }}
+
+        .stButton > button:hover {{
+            background-color: {BUTTON_HOVER_BG};
+        }}
+
+        .stSelectbox div[data-baseweb="select"],
+        .stDateInput input {{
+            background-color: {INPUT_BG} !important;
+            color: {TEXT_COLOR} !important;
+        }}
+
+        [data-testid="stMetricLabel"],
+        [data-testid="stMetricValue"] {{
+            color: {TEXT_COLOR} !important;
+        }}
+
+        .stMarkdown p {{
+            color: {TEXT_COLOR} !important;
+        }}
+
+        .stDataFrame tbody tr td {{
+            color: {TEXT_COLOR} !important;
+        }}
+
+        .stProgress > div > div {{
+            background-color: {PROGRESS_COLOR} !important;
+        }}
+
+        /* Alle Label-Texte für Inputs/Sliders */
+        label {{
+            color: {TEXT_COLOR} !important;
+        }}
+
+        /* Text in selectbox-Optionsfeldern */
+        .stSelectbox label, .stSelectbox div {{
+            color: {TEXT_COLOR} !important;
+        }}
+
+        /* DateInput angleichen an Selectbox */
+        .stDateInput input {{
+            background-color: #f2f6fa !important;
+            color: {TEXT_COLOR} !important;
+            border: none !important;
+            border-radius: 5px !important;
+        }}
+        
+    </style>
+""", unsafe_allow_html=True)
+
+st.title("Electricity Consumption Forecast: Hourly Simulation")
+st.write("Welcome to the simulation interface!")
+
+# ============================== Session State Init ==============================
+def init_session_state():
+    defaults = {
+        "is_running": False,
+        "start_index": 0,
+        "true_vals": [],
+        "pred_vals": [],
+        "true_timestamps": [],
+        "pred_timestamps": [],
+        "last_fig": None,
+        "valid_pos": 0
+    }
+    for key, value in defaults.items():
+        if key not in st.session_state:
+            st.session_state[key] = value
+
+init_session_state()
+
+# ============================== Loaders ==============================
+
+@st.cache_data
+def load_lightgbm_model():
+    with open(MODEL_PATH_LIGHTGBM, "rb") as f:
+        return pickle.load(f)
+
+@st.cache_resource
+def load_transformer_model_and_dataset():
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # Load model
+    model = load_moment_model()
+    checkpoint_path = hf_hub_download(
+    repo_id="dlaj/energy-forecasting-files",
+    filename="transformer_model/model_final.pth",
+    repo_type="dataset"
+    )
+    model.load_state_dict(torch.load(checkpoint_path, map_location=device))
+    model.to(device)
+    model.eval()
+
+    # Datasets
+    train_dataset = InformerDataset(data_split="train", forecast_horizon=FORECAST_HORIZON, random_seed=13)
+    test_dataset = InformerDataset(data_split="test", forecast_horizon=FORECAST_HORIZON, random_seed=13)
+    test_dataset.scaler = train_dataset.scaler
+
+    return model, test_dataset, device
+
+@st.cache_data
+def load_data():
+    csv_path = hf_hub_download(
+        repo_id="dlaj/energy-forecasting-files",
+        filename="data/processed/energy_consumption_aggregated_cleaned.csv",
+        repo_type="dataset"
+    )
+    df = pd.read_csv(csv_path, parse_dates=["date"])
+    return df
+
+
+# ============================== Utility Functions ==============================
+
+def predict_transformer_step(model, dataset, idx, device):
+    """Performs a single prediction step with the transformer model."""
+    timeseries, _, input_mask = dataset[idx]
+    timeseries = torch.tensor(timeseries, dtype=torch.float32).unsqueeze(0).to(device)
+    input_mask = torch.tensor(input_mask, dtype=torch.bool).unsqueeze(0).to(device)
+
+    with torch.no_grad():
+        output = model(x_enc=timeseries, input_mask=input_mask)
+
+    pred = output.forecast[:, 0, :].cpu().numpy().flatten()
+
+    # Rückskalieren
+    dummy = np.zeros((len(pred), dataset.n_channels))
+    dummy[:, 0] = pred
+    pred_original = dataset.scaler.inverse_transform(dummy)[:, 0]
+
+    return float(pred_original[0])
+
+
+def init_simulation_layout():
+    col1, spacer, col2 = st.columns([3, 0.2, 1])
+    plot_title = col1.empty()
+    plot_container = col1.empty()
+    x_axis_label = col1.empty()
+    info_container = col2.empty()
+    return plot_title, plot_container, x_axis_label, info_container
+
+
+
+def create_prediction_plot(pred_timestamps, pred_vals, true_timestamps, true_vals, window_hours, y_min=None, y_max=None):
+    """Generates the matplotlib figure for plotting prediction vs. actual."""
+    fig, ax = plt.subplots(figsize=(8, 5), constrained_layout=True, facecolor=PLOT_COLOR)
+    ax.set_facecolor(PLOT_COLOR)
+
+    ax.plot(pred_timestamps[-window_hours:], pred_vals[-window_hours:], label="Prediction", color="#EF233C", linestyle="--")
+    if true_vals:
+        ax.plot(true_timestamps[-window_hours:], true_vals[-window_hours:], label="Actual", color="#0077B6")
+
+    ax.set_ylabel("Consumption (MW)", fontsize=8, color=TEXT_COLOR)
+    ax.legend(
+    fontsize=8,
+    loc="upper left",
+    bbox_to_anchor=(0, 0.95),
+    facecolor= INPUT_BG,    # INPUT_BG
+    edgecolor= ACCENT_COLOR,    # ACCENT_COLOR
+    labelcolor= TEXT_COLOR    # TEXT_COLOR
+    )
+    ax.yaxis.grid(True, linestyle=':', linewidth=0.5, alpha=0.7)
+    ax.set_ylim(y_min, y_max)
+    ax.xaxis.set_major_locator(mdates.DayLocator(interval=1))
+    ax.xaxis.set_major_formatter(mdates.DateFormatter("%m-%d"))
+    ax.tick_params(axis="x", labelrotation=0, labelsize=5, colors=TEXT_COLOR)
+    ax.tick_params(axis="y", labelsize=5, colors=TEXT_COLOR)
+    #fig.patch.set_facecolor('#e6ecf0')  # outer area
+
+    for spine in ax.spines.values():
+        spine.set_visible(False)
+
+    st.session_state.last_fig = fig
+    return fig
+
+
+def render_simulation_view(timestamp, prediction, actual, progress, fig, paused=False):
+    """Displays the simulation plot and metrics in the UI."""
+    title = "Actual vs. Prediction (Paused)" if paused else "Actual vs. Prediction"
+    plot_title.markdown(
+        f"<div style='text-align: center; font-size: 20pt; font-weight: bold; color: {TEXT_COLOR}; margin-bottom: -0.7rem; margin-top: 0rem;'>"
+        f"{title}</div>",
+        unsafe_allow_html=True
+    )
+    plot_container.pyplot(fig)
+
+    st.markdown("<div style='margin-bottom: 0.5rem;'></div>", unsafe_allow_html=True)
+    x_axis_label.markdown(
+        f"<div style='text-align: center; font-size: 14pt; color: {TEXT_COLOR}; margin-top: -0.5rem;'>"
+        f"Time</div>",
+        unsafe_allow_html=True
+    )
+
+    with info_container.container():
+        st.markdown("<div style='margin-top: 5rem;'></div>", unsafe_allow_html=True)
+        st.markdown(
+            f"<span style='font-size: 24px; font-weight: 600; color: {HEADER_COLOR} !important;'>Time: {timestamp}</span>",
+            unsafe_allow_html=True
+        )
+
+        st.metric("Prediction", f"{prediction:,.0f} MW" if prediction is not None else "–")
+        st.metric("Actual", f"{actual:,.0f} MW" if actual is not None else "–")
+        st.caption("Simulation Progress")
+        st.progress(progress)
+
+        if len(st.session_state.true_vals) > 1:
+            true_arr = np.array(st.session_state.true_vals)
+            pred_arr = np.array(st.session_state.pred_vals[:-1])
+
+            min_len = min(len(true_arr), len(pred_arr)) #just start if there are 2 actual values
+            if min_len >= 1:
+                errors = np.abs(true_arr[:min_len] - pred_arr[:min_len])
+                mape = np.mean(errors / np.where(true_arr[:min_len] == 0, 1e-10, true_arr[:min_len])) * 100
+                mae = np.mean(errors)
+                max_error = np.max(errors)
+
+                st.divider()
+                st.markdown(
+                    f"<span style='font-size: 24px; font-weight: 600; color: {HEADER_COLOR} !important;'>Interim Metrics</span>",
+                    unsafe_allow_html=True
+                )
+                st.metric("MAPE (so far)", f"{mape:.2f} %")
+                st.metric("MAE (so far)", f"{mae:,.0f} MW")
+                st.metric("Max Error", f"{max_error:,.0f} MW")
+
+
+
+# ============================== Data Preparation ==============================
+
+df_full = load_data()
+
+# Split Train/Test
+train_size = int(len(df_full) * TRAIN_RATIO)
+test_df_raw = df_full.iloc[train_size:].reset_index(drop=True)
+
+# Start at first full hour (00:00)
+first_full_day_index = test_df_raw[test_df_raw["date"].dt.time == pd.Timestamp("00:00:00").time()].index[0]
+test_df_full = test_df_raw.iloc[first_full_day_index:].reset_index(drop=True)
+
+# Select simulation window via date picker
+min_date = test_df_full["date"].min().date()
+max_date = test_df_full["date"].max().date()
+
+# ============================== UI Controls ==============================
+
+st.markdown("### Simulation Settings")
+col1, col2 = st.columns([1, 1])
+
+with col1:
+    st.markdown("**General Settings**")
+    model_choice = st.selectbox("Choose prediction model", ["LightGBM", "Transformer Model (moments)"])
+    if model_choice == "Transformer Model(moments)":
+        st.caption("⚠️ Note: Transformer model runs slower without GPU. (Use Speed = 10)")
+    window_days = st.selectbox("Display window (days)", options=[3, 5, 7], index=0)
+    window_hours = window_days * 24
+    speed = st.slider("Speed", 1, 10, 5)
+
+with col2:
+    st.markdown(f"**Date Range** (from {min_date} to {max_date})")
+    start_date = st.date_input("Start Date", value=min_date, min_value=min_date, max_value=max_date)
+    end_date = st.date_input("End Date", value=max_date, min_value=min_date, max_value=max_date)
+    
+
+# ============================== Data Preparation (filtered) ==============================
+
+# final filtered date window
+test_df_filtered = test_df_full[
+    (test_df_full["date"].dt.date >= start_date) &
+    (test_df_full["date"].dt.date <= end_date)
+].reset_index(drop=True)
+
+# For progression bar
+total_steps_ui = len(test_df_filtered)
+
+# ============================== Buttons ==============================
+
+st.markdown("### Start Simulation")
+col1, col2, col3 = st.columns([1, 1, 14])
+with col1:
+    play_pause_text = "▶️ Start" if not st.session_state.is_running else "⏸️ Pause"
+    if st.button(play_pause_text):
+        st.session_state.is_running = not st.session_state.is_running
+        st.rerun()
+with col2:
+    reset_button = st.button("🔄 Reset")
+
+# Reset logic
+if reset_button:
+    st.session_state.start_index = 0
+    st.session_state.pred_vals = []
+    st.session_state.true_vals = []
+    st.session_state.pred_timestamps = []
+    st.session_state.true_timestamps = []
+    st.session_state.last_fig = None
+    st.session_state.is_running = False
+    st.session_state.valid_pos = 0
+    st.rerun()
+
+# Auto-reset on critical parameter change while running
+if st.session_state.is_running and (
+    start_date != st.session_state.get("last_start_date") or
+    end_date != st.session_state.get("last_end_date") or
+    model_choice != st.session_state.get("last_model_choice")
+):
+    st.session_state.start_index = 0
+    st.session_state.pred_vals = []
+    st.session_state.true_vals = []
+    st.session_state.pred_timestamps = []
+    st.session_state.true_timestamps = []
+    st.session_state.last_fig = None
+    st.session_state.valid_pos = 0
+    st.rerun()
+
+# Track current selections for change detection
+st.session_state.last_start_date = start_date
+st.session_state.last_end_date = end_date
+st.session_state.last_model_choice = model_choice
+
+
+# ============================== Paused Mode ==============================
+
+if not st.session_state.is_running and st.session_state.last_fig is not None:
+    st.write("Simulation paused...")
+    plot_title, plot_container, x_axis_label, info_container = init_simulation_layout()
+
+    timestamp = st.session_state.pred_timestamps[-1] if st.session_state.pred_timestamps else "–"
+    prediction = st.session_state.pred_vals[-1] if st.session_state.pred_vals else None
+    actual = st.session_state.true_vals[-1] if st.session_state.true_vals else None
+    progress = st.session_state.start_index / total_steps_ui
+
+    render_simulation_view(timestamp, prediction, actual, progress, st.session_state.last_fig, paused=True)
+
+
+# ============================== initialize values ==============================
+
+#if lightGbm use testdata from above
+if model_choice == "LightGBM":
+        test_df = test_df_filtered.copy()
+
+#Shared state references for storing predictions and ground truths
+
+true_vals = st.session_state.true_vals
+pred_vals = st.session_state.pred_vals
+true_timestamps = st.session_state.true_timestamps
+pred_timestamps = st.session_state.pred_timestamps
+
+# ============================== LightGBM Simulation ==============================
+
+if model_choice == "LightGBM" and st.session_state.is_running:
+    model = load_lightgbm_model()
+    st.write("Simulation started...")
+    st.markdown('<div id="simulation"></div>', unsafe_allow_html=True)
+
+    plot_title, plot_container, x_axis_label, info_container = init_simulation_layout()
+
+    for i in range(st.session_state.start_index, len(test_df)):
+        if not st.session_state.is_running:
+            break
+
+        current = test_df.iloc[i]
+        timestamp = current["date"]
+        features = current[FEATURES].values.reshape(1, -1)
+        prediction = model.predict(features)[0]
+
+        pred_vals.append(prediction)
+        pred_timestamps.append(timestamp)
+
+        if i >= 1:
+            prev_actual = test_df.iloc[i - 1]["consumption_MW"]
+            prev_time = test_df.iloc[i - 1]["date"]
+            true_vals.append(prev_actual)
+            true_timestamps.append(prev_time)
+
+        fig = create_prediction_plot(
+            pred_timestamps, pred_vals,
+            true_timestamps, true_vals,
+            window_hours,
+            y_min= test_df_filtered["consumption_MW"].min() - 2000,
+            y_max= test_df_filtered["consumption_MW"].max() + 2000
+        )
+
+        render_simulation_view(timestamp, prediction, prev_actual if i >= 1 else None, i / len(test_df), fig)
+
+        plt.close(fig)  # Speicher freigeben
+
+        st.session_state.start_index = i + 1
+        time.sleep(1 / (speed + 1e-9))
+
+    st.success("Simulation completed!")
+
+
+
+# ============================== Transformer Simulation ==============================
+
+if model_choice == "Transformer Model(moments)":
+    if st.session_state.is_running:
+        st.write("Simulation started (Transformer)...")
+        st.markdown('<div id="simulation"></div>', unsafe_allow_html=True)
+
+        plot_title, plot_container, x_axis_label, info_container = init_simulation_layout()
+
+        # Zugriff auf Modell, Dataset, Device
+        model, test_dataset, device = load_transformer_model_and_dataset()
+        data = test_dataset.data  # bereits skaliert
+        scaler = test_dataset.scaler
+        n_channels = test_dataset.n_channels
+
+        test_start_idx = len(InformerDataset(data_split="train", forecast_horizon=FORECAST_HORIZON)) + SEQ_LEN
+        base_timestamp = pd.read_csv(DATA_PATH, parse_dates=["date"])["date"].iloc[test_start_idx] #get original timestamp for later, cause not in dataset anymore
+
+        # Schritt 1: Finde Index, ab dem Stunde = 00:00 ist
+        offset = 0
+        while (base_timestamp + pd.Timedelta(hours=offset)).time() != pd.Timestamp("00:00:00").time():
+            offset += 1
+        
+        # Neuer Startindex in der Simulation
+        start_index = offset
+
+        # Session-State bei Bedarf initial setzen
+        if "start_index" not in st.session_state or st.session_state.start_index == 0:
+            st.session_state.start_index = start_index
+
+
+        # Vorbereiten: Liste der gültigen i-Werte im gewünschten Zeitraum
+        valid_indices = []
+        for i in range(start_index, len(test_dataset)):
+            timestamp = base_timestamp + pd.Timedelta(hours=i)
+            if start_date <= timestamp.date() <= end_date:
+                valid_indices.append(i)
+
+        # Fortschrittsanzeige
+        total_steps = len(valid_indices)
+
+        # Aktueller Fortschritt in der Liste (nicht: globaler Dataset-Index!)
+        if "valid_pos" not in st.session_state:
+            st.session_state.valid_pos = 0
+
+        # Hauptschleife: Nur noch über gültige Indizes iterieren
+        for relative_idx, i in enumerate(valid_indices[st.session_state.valid_pos:]):
+
+        #for i in range(st.session_state.start_index, len(test_dataset)):
+            if not st.session_state.is_running:
+                break
+
+            current_pred = predict_transformer_step(model, test_dataset, i, device)
+            current_time = base_timestamp + pd.Timedelta(hours=i)
+
+            pred_vals.append(current_pred)
+            pred_timestamps.append(current_time)
+
+            if i >= 1:
+                prev_actual = test_dataset[i - 1][1][0, 0]  # erster Forecast-Wert der letzten Zeile
+                # Rückskalieren
+                dummy_actual = np.zeros((1, n_channels))
+                dummy_actual[:, 0] = prev_actual
+                actual_val = scaler.inverse_transform(dummy_actual)[0, 0]
+
+                true_time = current_time - pd.Timedelta(hours=1)
+
+                if true_time >= pd.to_datetime(start_date):
+                    true_vals.append(actual_val)
+                    true_timestamps.append(true_time)
+
+            # Plot erzeugen
+            fig = create_prediction_plot(
+                pred_timestamps, pred_vals,
+                true_timestamps, true_vals,
+                window_hours,
+                y_min= test_df_filtered["consumption_MW"].min() - 2000,
+                y_max= test_df_filtered["consumption_MW"].max() + 2000
+            )
+            if len(pred_vals) >= 2 and len(true_vals) >= 1:
+                render_simulation_view(current_time, current_pred, actual_val if i >= 1 else None, st.session_state.valid_pos / total_steps, fig)
+
+            plt.close(fig)  # Speicher freigeben
+
+            st.session_state.valid_pos += 1
+            time.sleep(1 / (speed + 1e-9))
+
+        st.success("Simulation completed!")
+
+
+# ============================== Scroll Sync ==============================
+
+st.markdown("""
+    <script>
+    window.addEventListener("message", (event) => {
+        if (event.data.type === "save_scroll") {
+            const pyScroll = event.data.scrollY;
+            window.parent.postMessage({type: "streamlit:setComponentValue", value: pyScroll}, "*");
+        }
+    });
+    </script>
+""", unsafe_allow_html=True)
+