initial

.huggingface.yml

@@ -0,0 +1,2 @@
+sdk: streamlit
+app_file: streamlit_simulation/app.py

Hugging_face_app.zip → lightgbm_model/model/lightgbm_final_model.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2c15d038b5708a8b42682dcca58c3b94c9eeccd2352c2ba30beed6ed61585e84
-size 8060127
+oid sha256:52777b05bde0cc4665aac0d18993701769c84edaf0ffe9cb3b82049fd779b56d
+size 1534227

lightgbm_model/results/lightgbm_eval_result.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c08c03ffc33d679292809af3f37f2f5d10d971c2243a962d5de5bd8b1415a7f5
+size 76208

lightgbm_model/scripts/__init__.py

@@ -0,0 +1,2 @@
+# __init__.py
+

lightgbm_model/scripts/config_lightgbm.py

@@ -0,0 +1,36 @@
+# config.py
+import os
+
+# === Paths ===
+BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+DATA_PATH = os.path.join(BASE_DIR, "..", "data", "processed", "energy_consumption_aggregated_cleaned.csv")
+RESULTS_DIR = os.path.join(BASE_DIR, "results")
+MODEL_DIR = os.path.join(BASE_DIR, "model")
+
+# === Feature-Definition ===
+FEATURES = [
+    "hour_sin", "hour_cos",
+    "weekday_sin", "weekday_cos",
+    "rolling_mean_6h",
+    "month_sin", "month_cos",
+    "temperature_c",
+    "consumption_last_week",
+    "consumption_yesterday",
+    "consumption_last_hour"
+]
+TARGET = "consumption_MW"
+
+# === Hyperparameters fpr LightGBM ===
+LIGHTGBM_PARAMS = {
+    'learning_rate': 0.05,
+    'num_leaves': 15,
+    'max_depth': 5,
+    'lambda_l1': 1.0,
+    'lambda_l2': 0.0,
+    'min_split_gain': 0.0,
+    'n_estimators': 1000,
+    'objective': 'regression'}
+
+# === Early Stopping ===
+EARLY_STOPPING_ROUNDS = 50
+

lightgbm_model/scripts/eval/eval_lightgbm.py

@@ -0,0 +1,107 @@
+# eval_model.py
+
+import os
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import pickle
+from sklearn.metrics import mean_absolute_error, mean_squared_error
+from lightgbm_model.scripts.config_lightgbm import RESULTS_DIR, MODEL_DIR, DATA_PATH
+from joblib import load
+
+# === Ergebnisse-Ordner vorbereiten ===
+os.makedirs(RESULTS_DIR, exist_ok=True)
+
+# === Modell und eval_result laden ===
+# Modell laden
+with open(os.path.join(MODEL_DIR, "lightgbm_final_model.pkl"), "rb") as f:
+    model = pickle.load(f)
+
+# Eval laden
+with open(os.path.join(RESULTS_DIR, "lightgbm_eval_result.pkl"), "rb") as f:
+    eval_result = pickle.load(f)
+X_train = pd.read_csv(os.path.join(RESULTS_DIR, "X_train.csv"))
+X_test = pd.read_csv(os.path.join(RESULTS_DIR, "X_test.csv"))
+y_test = pd.read_csv(os.path.join(RESULTS_DIR, "y_test.csv"))
+
+# === Lernkurve ===
+train_rmse = eval_result['training']['rmse']
+valid_rmse = eval_result['valid_1']['rmse']
+
+plt.figure(figsize=(10, 5))
+plt.plot(train_rmse, label='Train RMSE')
+plt.plot(valid_rmse, label='Valid RMSE')
+plt.axvline(model.best_iteration_, color='gray', linestyle='--', label='Best Iteration')
+plt.xlabel("Boosting Round")
+plt.ylabel("RMSE")
+plt.title("LightGBM Learning Curve")
+plt.legend()
+plt.tight_layout()
+plt.savefig(os.path.join(RESULTS_DIR, "lightgbm_learning_curve.png"))
+#plt.show()
+
+# === Metriken berechnen ===
+y_pred = model.predict(X_test)
+mae = mean_absolute_error(y_test, y_pred)
+rmse = np.sqrt(mean_squared_error(y_test, y_pred))
+mape = np.mean(np.abs((y_test.values.flatten() - y_pred) / np.where(y_test.values.flatten() == 0, 1e-10, y_test.values.flatten()))) * 100
+
+print(f"Test MAPE: {mape:.5f} %")
+print(f"Test MAE: {mae:.5f}")
+print(f"Test RMSE: {rmse:.5f}")
+
+# === Feature Importance ===
+feature_importance = pd.DataFrame({
+    "Feature": X_train.columns,
+    "Importance": model.feature_importances_
+}).sort_values(by="Importance", ascending=False)
+
+plt.figure(figsize=(10, 6))
+plt.barh(feature_importance["Feature"], feature_importance["Importance"])
+plt.xlabel("Feature Importance")
+plt.title("LightGBM Feature Importance")
+plt.gca().invert_yaxis()
+plt.tight_layout()
+plt.savefig(os.path.join(RESULTS_DIR, "lightgbm_feature_importance.png"))
+#plt.show()
+
+# === Vergleichsplots ===
+results_df = pd.DataFrame({
+    "True Consumption (MW)": y_test.values.flatten(),
+    "Predicted Consumption (MW)": y_pred
+})
+
+# Timestamps anhängen
+full_df = pd.read_csv(DATA_PATH)
+test_dates = full_df.iloc[int(len(full_df)*0.8):]["date"].reset_index(drop=True)
+results_df["Timestamp"] = pd.to_datetime(test_dates)
+
+# Voller Plot
+plt.figure(figsize=(15, 6))
+plt.plot(results_df["Timestamp"], results_df["True Consumption (MW)"], label="True", color="darkblue")
+plt.plot(results_df["Timestamp"], results_df["Predicted Consumption (MW)"], label="Predicted", color="red", linestyle="--")
+plt.title("Predicted vs True Consumption")
+plt.xlabel("Timestamp")
+plt.ylabel("Consumption (MW)")
+plt.legend()
+plt.tight_layout()
+plt.savefig(os.path.join(RESULTS_DIR, "lightgbm_comparison_plot.png"))
+#plt.show()
+
+# Subset Plot
+subset = results_df.iloc[:len(results_df) // 10]
+plt.figure(figsize=(15, 6))
+plt.plot(subset["Timestamp"], subset["True Consumption (MW)"], label="True", color="darkblue")
+plt.plot(subset["Timestamp"], subset["Predicted Consumption (MW)"], label="Predicted", color="red", linestyle="--")
+plt.title("Predicted vs True (First decile)")
+plt.xlabel("Timestamp")
+plt.ylabel("Consumption (MW)")
+plt.legend()
+plt.tight_layout()
+plt.savefig(os.path.join(RESULTS_DIR, "lightgbm_prediction_with_timestamp.png"))
+#plt.show()
+
+
+# === Ens message ===
+print("\nEvaluation completed.")
+print(f"All Plots stored in:\n→ {RESULTS_DIR}")

lightgbm_model/scripts/train/train_lightgbm.py

@@ -0,0 +1,78 @@
+# train_lightgbm.py
+
+import os
+import pickle
+import pandas as pd
+import numpy as np
+import lightgbm as lgb
+from lightgbm import LGBMRegressor, early_stopping, record_evaluation
+
+from lightgbm_model.scripts.config_lightgbm import (
+    DATA_PATH,
+    FEATURES,
+    TARGET,
+    LIGHTGBM_PARAMS,
+    EARLY_STOPPING_ROUNDS,
+    RESULTS_DIR,
+    MODEL_DIR
+)
+
+# === Load Data ===
+df = pd.read_csv(DATA_PATH)
+
+# Drop date (used later for plots only)
+df = df.drop(columns=["date"], errors="ignore")
+
+# === Time-based Split (70% train, 10% valid, 20% test) ===
+train_size = int(len(df) * 0.7)
+valid_size = int(len(df) * 0.1)
+df_train = df.iloc[:train_size]
+df_valid = df.iloc[train_size:train_size + valid_size]
+df_test = df.iloc[train_size + valid_size:]
+
+X_train, y_train = df_train[FEATURES], df_train[TARGET]
+X_valid, y_valid = df_valid[FEATURES], df_valid[TARGET]
+X_test, y_test = df_test[FEATURES], df_test[TARGET]
+
+
+# === Init LightGBM model ===
+eval_result = {}
+
+model = LGBMRegressor(
+    **LIGHTGBM_PARAMS,
+    verbosity=-1
+)
+
+model.fit(
+    X_train,
+    y_train,
+    eval_set=[(X_train, y_train), (X_valid, y_valid)],
+    eval_metric="rmse",
+    callbacks=[
+        early_stopping(EARLY_STOPPING_ROUNDS),
+        record_evaluation(eval_result)
+    ]
+)
+
+# === Save model ===
+os.makedirs(MODEL_DIR, exist_ok=True)
+model_path = os.path.join(MODEL_DIR, "lightgbm_final_model.pkl")
+
+with open(model_path, "wb") as f:
+    pickle.dump(model, f)
+
+# === Save evaluation results ===
+os.makedirs(RESULTS_DIR, exist_ok=True)
+eval_result_path = os.path.join(RESULTS_DIR, "lightgbm_eval_result.pkl")
+
+with open(eval_result_path, "wb") as f:
+    pickle.dump(eval_result, f)
+
+print(f"Model saved to: {model_path}")
+print(f"Eval results saved to: {eval_result_path}")
+
+# === Save data for evaluation ===
+X_train.to_csv(os.path.join(RESULTS_DIR, "X_train.csv"), index=False)
+X_test.to_csv(os.path.join(RESULTS_DIR, "X_test.csv"), index=False)
+y_test.to_csv(os.path.join(RESULTS_DIR, "y_test.csv"), index=False)
+

requirements.txt

@@ -0,0 +1,31 @@
+# =============================
+# Requirements for Energy Prediction Project
+# =============================
+
+# Python 3.11 environment recommended since moments dont work with later versions
+
+# Moment Foundation Model (forecasting backbone)
+momentfm @ git+https://github.com/moment-timeseries-foundation-model/moment.git@37a8bde4eb3dd340bebc9b54a3b893bcba62cd4f
+
+# === Core Python stack ===
+numpy==1.25.2                 # Numerical operations
+pandas==2.2.2                 # Data manipulation and analysis
+matplotlib==3.10.0           # Plotting and visualizations
+
+# === Machine Learning ===
+scikit-learn==1.6.1          # Evaluation metrics and preprocessing utilities
+torch==2.6.0          # PyTorch with CUDA 12.4 (GPU support)
+torchvision==0.21.0+cu124    # Optional (can support visual tasks, not critical here)
+torchaudio==2.6.0+cu124      # Optional (comes with torch install, can stay)
+
+# === Utilities ===
+tqdm==4.67.1                 # Progress bars
+ipywidgets>=8.0              # Enables tqdm progress bars in Jupyter/Colab
+pprintpp==0.4.0              # Prettier print formatting for nested dicts (used for model output check)
+
+# === lightgbm ===
+lightgbm==4.3.0     # Boosted Trees for tabular modeling (used for baseline and feature selection)
+
+# === Streamlit App ===
+streamlit>=1.30.0
+plotly>=5.0.0

setup.py

@@ -0,0 +1,7 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="energy_prediction",
+    version="0.1",
+    packages=find_packages(),
+)

streamlit_simulation/__init__.py

@@ -0,0 +1,2 @@
+# __init__.py
+

streamlit_simulation/app.py

@@ -0,0 +1,535 @@
+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
+
+
+# ============================== 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 = os.path.join(CHECKPOINT_DIR, "model_final.pth")
+    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():
+    df = pd.read_csv(DATA_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():
+    """Creates layout containers for plot and info sections."""
+    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)
+

streamlit_simulation/config_streamlit.py

@@ -0,0 +1,26 @@
+# config_streamlit
+import os
+
+# Base directory → points to the project root
+BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+
+# Model paths
+MODEL_PATH_LIGHTGBM = os.path.join(BASE_DIR, "lightgbm_model", "model", "lightgbm_final_model.pkl")
+MODEL_PATH_TRANSFORMER = os.path.join(BASE_DIR, "transformer_model", "model", "checkpoints", "model_final.pth")
+
+# Data path
+DATA_PATH = os.path.join(BASE_DIR, "data", "processed", "energy_consumption_aggregated_cleaned.csv")
+
+# Color palette for Streamlit layout
+TEXT_COLOR = "#004080"         # Primary text color (clean dark blue)
+HEADER_COLOR = "#002855"       # Accent color for headings
+ACCENT_COLOR = "#9bb2cc"       # For borders, highlights, etc.
+BUTTON_BG = "#dee7f0"          # Background color for buttons
+BUTTON_HOVER_BG = "#cbd9e6"    # Hover color for buttons
+BG_COLOR = "#ffffff"           # Page background
+INPUT_BG = "#f2f6fa"           # Background for select boxes, inputs
+PROGRESS_COLOR = "#0077B6"     # Progress bar color
+PLOT_COLOR = "white"           # Plot background color
+
+# Constants
+TRAIN_RATIO = 0.7  # Train/test split ratio used by both models

transformer_model/results/evaluation_metrics.json

@@ -0,0 +1 @@
+{"RMSE": 3933.5735661100834, "MAPE": 2.3222167044878006, "R2": 0.97211754322052}

transformer_model/results/training_metrics.json

@@ -0,0 +1 @@
+{"train_losses": [0.17907951894225974, 0.11743136870736444, 0.10286305829986463, 0.095653260748457, 0.09064765630698786, 0.08855325479177233, 0.08623282216515275, 0.08489166740133372, 0.08422152720884994], "test_mses": [0.07641124725341797, 0.050424233078956604, 0.03807574138045311, 0.032122015953063965, 0.026808083057403564, 0.02273257076740265, 0.02027367614209652, 0.018922727555036545, 0.017820490524172783], "test_maes": [0.1691250056028366, 0.1388522833585739, 0.12234506011009216, 0.11616843193769455, 0.10695459693670273, 0.09815964102745056, 0.09287288039922714, 0.0910905972123146, 0.0890081524848938]}

transformer_model/scripts/__init__.py

@@ -0,0 +1,2 @@
+# __init__.py
+

transformer_model/scripts/config_transformer.py

@@ -0,0 +1,31 @@
+# config.py
+import os
+
+# Base Directory
+BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+
+# Data paths
+DATA_PATH = os.path.join(BASE_DIR, "..", "data", "processed", "energy_consumption_aggregated_cleaned.csv")
+
+# Other  paths
+CHECKPOINT_DIR = os.path.join(BASE_DIR, "model", "checkpoints")
+RESULTS_DIR = os.path.join(BASE_DIR, "results")
+
+
+# ========== Model Settings ==========
+SEQ_LEN = 512               # Input sequence length (number of time steps the model sees)
+FORECAST_HORIZON = 1        # Number of future steps the model should predict
+HEAD_DROPOUT = 0.1          # Dropout in the head to prevent overfitting
+WEIGHT_DECAY = 0.0          # L2 regularization (0 means off)
+
+# ========== Training Settings ==========
+MAX_EPOCHS = 9              # Optimal number of epochs based on performance curve
+BATCH_SIZE = 32             # Batch size for training and evaluation
+LEARNING_RATE = 1e-4        # Base learning rate
+MAX_LR = 1e-4               # Max LR for OneCycleLR scheduler
+GRAD_CLIP = 5.0             # Gradient clipping threshold
+
+# ========== Freezing Strategy ==========
+FREEZE_ENCODER = True
+FREEZE_EMBEDDER = True
+FREEZE_HEAD = False         #just unfreeze the last forecasting head for finetuning

transformer_model/scripts/evaluation/__init__.py

@@ -0,0 +1 @@
+# __init__

transformer_model/scripts/evaluation/evaluate.py

@@ -0,0 +1,124 @@
+# evaluate.py
+
+import os
+import json
+import torch
+import logging
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+from sklearn.metrics import mean_squared_error, r2_score
+
+from transformer_model.scripts.config_transformer import BASE_DIR, RESULTS_DIR, CHECKPOINT_DIR, DATA_PATH, FORECAST_HORIZON, SEQ_LEN
+from transformer_model.scripts.training.load_basis_model import load_moment_model
+from transformer_model.scripts.utils.informer_dataset_class import InformerDataset
+from momentfm.utils.utils import control_randomness
+from transformer_model.scripts.utils.check_device import check_device
+
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+def evaluate():
+    control_randomness(seed=13)
+    # Set device
+    device, backend, scaler = check_device()
+    logging.info(f"Evaluation is running on: {backend} ({device})")
+
+    # Load final model
+    model = load_moment_model()
+    checkpoint_path = os.path.join(CHECKPOINT_DIR, "model_final.pth")
+    model.load_state_dict(torch.load(checkpoint_path, map_location=device))
+    model.to(device)  
+    model.eval()
+    logging.info(f"Loaded final model from: {checkpoint_path}")
+
+    # Recreate training dataset to get the fitted scaler
+    train_dataset = InformerDataset(
+        data_split="train",
+        random_seed=13,
+        forecast_horizon=FORECAST_HORIZON
+    )
+
+    # Use its scaler in the test dataset
+    test_dataset = InformerDataset(
+        data_split="test",
+        random_seed=13,
+        forecast_horizon=FORECAST_HORIZON
+    )
+
+    test_dataset.scaler = train_dataset.scaler
+
+    test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle=False)
+
+    trues, preds = [], []
+
+    with torch.no_grad():
+        for timeseries, forecast, input_mask in tqdm(test_loader, desc="Evaluating on test set"):
+            timeseries = timeseries.float().to(device)
+            forecast = forecast.float().to(device)
+            input_mask = input_mask.to(device)  # <- wichtig!
+
+            output = model(x_enc=timeseries, input_mask=input_mask)
+
+            trues.append(forecast.cpu().numpy())
+            preds.append(output.forecast.cpu().numpy())
+
+
+    trues = np.concatenate(trues, axis=0)
+    preds = np.concatenate(preds, axis=0)
+
+    # Extract only first feature (consumption)
+    true_values = trues[:, 0, :]
+    pred_values = preds[:, 0, :]
+
+    # Inverse normalization
+    n_features = test_dataset.n_channels
+    true_reshaped = np.column_stack([true_values.flatten()] + [np.zeros_like(true_values.flatten())] * (n_features - 1))
+    pred_reshaped = np.column_stack([pred_values.flatten()] + [np.zeros_like(pred_values.flatten())] * (n_features - 1))
+
+    true_original = test_dataset.scaler.inverse_transform(true_reshaped)[:, 0]
+    pred_original = test_dataset.scaler.inverse_transform(pred_reshaped)[:, 0]
+
+
+    # Build timestamp index, since date got cutted out in informerdataset we need original dataset and use the index of the beginning of testdata to get the date
+    csv_path = os.path.join(DATA_PATH) 
+    df = pd.read_csv(csv_path, parse_dates=["date"])
+
+    train_len = len(train_dataset)
+    test_start_idx = train_len + SEQ_LEN
+    start_timestamp = df["date"].iloc[test_start_idx]
+    logging.info(f"[DEBUG] timestamp: {start_timestamp}")
+
+    timestamps = [start_timestamp + pd.Timedelta(hours=i) for i in range(len(true_original))]
+
+    df = pd.DataFrame({
+        "Timestamp": timestamps,
+        "True Consumption (MW)": true_original,
+        "Predicted Consumption (MW)": pred_original
+    })
+
+    # Save results to CSV
+    os.makedirs(RESULTS_DIR, exist_ok=True)
+    results_path = os.path.join(RESULTS_DIR, "test_results.csv")
+    df.to_csv(results_path, index=False)
+    logging.info(f"Saved prediction results to: {results_path}")
+
+    # Evaluation metrics
+    mse = mean_squared_error(df["True Consumption (MW)"], df["Predicted Consumption (MW)"])
+    rmse = np.sqrt(mse)
+    mape = np.mean(np.abs((df["True Consumption (MW)"] - df["Predicted Consumption (MW)"]) / df["True Consumption (MW)"])) * 100
+    r2 = r2_score(df["True Consumption (MW)"], df["Predicted Consumption (MW)"])
+
+    # Save metrics to JSON
+    metrics = {"RMSE": float(rmse), "MAPE": float(mape), "R2": float(r2)}
+    metrics_path = os.path.join(RESULTS_DIR, "evaluation_metrics.json")
+    with open(metrics_path, "w") as f:
+        json.dump(metrics, f)
+
+    logging.info(f"Saved evaluation metrics to: {metrics_path}")
+    logging.info(f"RMSE: {rmse:.3f} | MAPE: {mape:.2f}% | R²: {r2:.3f}")
+
+if __name__ == "__main__":
+    evaluate()

transformer_model/scripts/evaluation/plot_metrics.py

@@ -0,0 +1,77 @@
+# plot_metrics.py
+
+import os
+import json
+import pandas as pd
+import matplotlib.pyplot as plt
+from transformer_model.scripts.config_transformer import RESULTS_DIR
+
+# === Plot 1: Training Metrics ===
+
+# Load training metrics
+training_metrics_path = os.path.join(RESULTS_DIR, "training_metrics.json")
+with open(training_metrics_path, "r") as f:
+    metrics = json.load(f)
+
+train_losses = metrics["train_losses"]
+test_mses = metrics["test_mses"]
+test_maes = metrics["test_maes"]
+
+plt.figure(figsize=(10, 6))
+plt.plot(range(1, len(train_losses) + 1), train_losses, label="Train Loss", color="blue")
+plt.plot(range(1, len(test_mses) + 1), test_mses, label="Test MSE", color="red")
+plt.plot(range(1, len(test_maes) + 1), test_maes, label="Test MAE", color="green")
+plt.xlabel("Epoch")
+plt.ylabel("Loss / Metric")
+plt.title("Training Loss vs Test Metrics")
+plt.legend()
+plt.grid(True)
+
+plot_path = os.path.join(RESULTS_DIR, "training_plot.png")
+plt.savefig(plot_path)
+print(f"[Saved] Training metrics plot: {plot_path}")
+plt.show()
+
+
+# === Plot 2: Predictions vs Ground Truth (Full Range) ===
+
+# Load comparison results
+comparison_path = os.path.join(RESULTS_DIR, "test_results.csv")
+df_comparison = pd.read_csv(comparison_path, parse_dates=["Timestamp"])
+
+plt.figure(figsize=(15, 6))
+plt.plot(df_comparison["Timestamp"], df_comparison["True Consumption (MW)"], label="True", color="darkblue")
+plt.plot(df_comparison["Timestamp"], df_comparison["Predicted Consumption (MW)"], label="Predicted", color="red", linestyle="--")
+plt.title("Energy Consumption: Predictions vs Ground Truth")
+plt.xlabel("Time")
+plt.ylabel("Consumption (MW)")
+plt.legend()
+plt.grid(True)
+plt.tight_layout()
+
+plot_path = os.path.join(RESULTS_DIR, "comparison_plot_full.png")
+plt.savefig(plot_path)
+print(f"[Saved] Full range comparison plot: {plot_path}")
+plt.show()
+
+
+# === Plot 3: Predictions vs Ground Truth (First Month) ===
+
+first_month_start = df_comparison["Timestamp"].min()
+first_month_end = first_month_start + pd.Timedelta(days=25)
+df_first_month = df_comparison[(df_comparison["Timestamp"] >= first_month_start) & (df_comparison["Timestamp"] <= first_month_end)]
+
+plt.figure(figsize=(15, 6))
+plt.plot(df_first_month["Timestamp"], df_first_month["True Consumption (MW)"], label="True", color="darkblue")
+plt.plot(df_first_month["Timestamp"], df_first_month["Predicted Consumption (MW)"], label="Predicted", color="red", linestyle="--")
+plt.title("Energy Consumption (First Month): Predictions vs Ground Truth")
+plt.xlabel("Time")
+plt.ylabel("Consumption (MW)")
+plt.legend()
+plt.grid(True)
+plt.tight_layout()
+
+plot_path = os.path.join(RESULTS_DIR, "comparison_plot_1month.png")
+plt.savefig(plot_path)
+print(f"[Saved] 1-Month comparison plot: {plot_path}")
+plt.show()

transformer_model/scripts/training/__init__.py

@@ -0,0 +1 @@
+# __init__

transformer_model/scripts/training/load_basis_model.py

@@ -0,0 +1,67 @@
+# load_basis_model.py
+# Load and initialize the base MOMENT model before finetuning
+
+import torch
+import logging
+from momentfm import MOMENTPipeline
+from transformer_model.scripts.config_transformer import (
+    FORECAST_HORIZON,
+    FREEZE_ENCODER,
+    FREEZE_EMBEDDER,
+    FREEZE_HEAD,
+    WEIGHT_DECAY,
+    HEAD_DROPOUT,
+    SEQ_LEN
+)
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+
+
+def load_moment_model():
+    """
+    Loads and configures the MOMENT model for forecasting.
+    """
+    logging.info("Loading MOMENT model...")
+    model = MOMENTPipeline.from_pretrained(
+        "AutonLab/MOMENT-1-large",
+        model_kwargs={
+            'task_name': 'forecasting',
+            'forecast_horizon': FORECAST_HORIZON,  # default = 1
+            'head_dropout': HEAD_DROPOUT,          # default = 0.1
+            'weight_decay': WEIGHT_DECAY,          # default = 0.0
+            'freeze_encoder': FREEZE_ENCODER,      # default = True
+            'freeze_embedder': FREEZE_EMBEDDER,    # default = True
+            'freeze_head': FREEZE_HEAD             # default = False
+        }
+    )
+
+    model.init()
+    logging.info("Model initialized successfully.")
+    return model
+
+
+def print_trainable_params(model):
+    """
+    Logs all trainable (unfrozen) parameters of the model.
+    """
+    logging.info("Unfrozen parameters:")
+    for name, param in model.named_parameters():
+        if param.requires_grad:
+            logging.info(f"  {name}")
+
+
+def test_dummy_forward(model):
+    """
+    Performs a dummy forward pass to verify the model runs without error.
+    """
+    logging.info("Running dummy forward pass with random tensors to see if model is running.")
+    dummy_x = torch.randn(16, 1, SEQ_LEN)
+    output = model(x_enc=dummy_x)
+    logging.info("Dummy forward pass successful.")
+
+
+if __name__ == "__main__":
+    model = load_moment_model()
+    print_trainable_params(model)
+    test_dummy_forward(model)

transformer_model/scripts/training/train.py

@@ -0,0 +1,202 @@
+# train.py
+
+import os
+import json
+import time
+import logging
+import numpy as np
+import torch
+from tqdm import tqdm
+from sklearn.metrics import mean_squared_error, mean_absolute_error
+
+from transformer_model.scripts.config_transformer import (
+    BASE_DIR,
+    MAX_EPOCHS,
+    BATCH_SIZE,
+    LEARNING_RATE,
+    MAX_LR,
+    GRAD_CLIP,
+    FORECAST_HORIZON,
+    CHECKPOINT_DIR,
+    RESULTS_DIR
+)
+
+from transformer_model.scripts.training.load_basis_model import load_moment_model
+from transformer_model.scripts.utils.create_dataloaders import create_dataloaders
+from transformer_model.scripts.utils.check_device import check_device
+from momentfm.utils.utils import control_randomness
+
+
+# === Setup logging ===
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+
+def train():
+    # Start timing
+    start_time = time.time()
+
+    # Setup device (CUDA / DirectML / CPU) and AMP scaler
+    device, backend, scaler = check_device()
+
+    # Load base model
+    model = load_moment_model().to(device)
+
+    # Set random seeds for reproducibility
+    control_randomness(seed=13)
+
+    # Setup loss function and optimizer
+    criterion = torch.nn.MSELoss().to(device)
+    optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)
+
+    # Load data
+    train_loader, test_loader = create_dataloaders()
+
+    # Setup learning rate scheduler (OneCycle policy)
+    total_steps = len(train_loader) * MAX_EPOCHS
+    scheduler = torch.optim.lr_scheduler.OneCycleLR(
+        optimizer,
+        max_lr=MAX_LR,
+        total_steps=total_steps,
+        pct_start=0.3
+    )
+
+    # Ensure output folders exist
+    os.makedirs(CHECKPOINT_DIR, exist_ok=True)
+    os.makedirs(RESULTS_DIR, exist_ok=True)
+
+    # Store metrics
+    train_losses, test_mses, test_maes = [], [], []
+
+    best_mae = float("inf")
+    best_epoch = None
+    no_improve_epochs = 0
+    patience = 5  
+
+    for epoch in range(MAX_EPOCHS):
+        model.train()
+        epoch_losses = []
+
+        for timeseries, forecast, input_mask in tqdm(train_loader, desc=f"Epoch {epoch}"):
+            timeseries = timeseries.float().to(device)
+            input_mask = input_mask.to(device)
+            forecast = forecast.float().to(device)
+
+            # Zero gradients
+            optimizer.zero_grad(set_to_none=True)
+
+            # Forward pass (with AMP if enabled)
+            if scaler:
+                with torch.amp.autocast(device_type="cuda"):
+                    output = model(x_enc=timeseries, input_mask=input_mask)
+                    loss = criterion(output.forecast, forecast)
+            else:
+                output = model(x_enc=timeseries, input_mask=input_mask)
+                loss = criterion(output.forecast, forecast)
+
+            # Backward pass + optimization
+            if scaler:
+                scaler.scale(loss).backward()
+                scaler.unscale_(optimizer)
+                torch.nn.utils.clip_grad_norm_(model.parameters(), GRAD_CLIP)
+                scaler.step(optimizer)
+                scaler.update()
+            else:
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(model.parameters(), GRAD_CLIP)
+                optimizer.step()
+
+            epoch_losses.append(loss.item())
+
+        average_train_loss = np.mean(epoch_losses)
+        train_losses.append(average_train_loss)
+        logging.info(f"Epoch {epoch}: Train Loss = {average_train_loss:.4f}")
+
+        # === Evaluation ===
+        model.eval()
+        trues, preds = [], []
+
+        with torch.no_grad():
+            for timeseries, forecast, input_mask in test_loader:
+                timeseries = timeseries.float().to(device)
+                input_mask = input_mask.to(device)
+                forecast = forecast.float().to(device)
+
+                if scaler:
+                    with torch.amp.autocast(device_type="cuda"):
+                        output = model(x_enc=timeseries, input_mask=input_mask)
+                else:
+                    output = model(x_enc=timeseries, input_mask=input_mask)
+
+                trues.append(forecast.detach().cpu().numpy())
+                preds.append(output.forecast.detach().cpu().numpy())
+
+        trues = np.concatenate(trues, axis=0)
+        preds = np.concatenate(preds, axis=0)
+
+
+        # Reshape for sklearn metrics
+        trues_2d = trues.reshape(trues.shape[0], -1)
+        preds_2d = preds.reshape(preds.shape[0], -1)
+
+        mse = mean_squared_error(trues_2d, preds_2d)
+        mae = mean_absolute_error(trues_2d, preds_2d)
+
+        test_mses.append(mse)
+        test_maes.append(mae)
+        logging.info(f"Epoch {epoch}: Test MSE = {mse:.4f}, MAE = {mae:.4f}")
+
+        # === Early Stopping Check ===
+        if mae < best_mae:
+            best_mae = mae
+            best_epoch = epoch
+            no_improve_epochs = 0
+
+            # Save best model
+            best_model_path = os.path.join(CHECKPOINT_DIR, "best_model.pth")
+            torch.save(model.state_dict(), best_model_path)
+            logging.info(f"New best model saved to: {best_model_path} (MAE: {best_mae:.4f})")
+        else:
+            no_improve_epochs += 1
+            logging.info(f"No improvement in MAE for {no_improve_epochs} epoch(s).")
+
+            if no_improve_epochs >= patience:
+                logging.info("Early stopping triggered.")
+                break
+
+        # Save checkpoint
+        checkpoint_path = os.path.join(CHECKPOINT_DIR, f"model_epoch_{epoch}.pth")
+        torch.save(model.state_dict(), checkpoint_path)
+
+        scheduler.step()
+
+    logging.info(f"Best model was at epoch {best_epoch} with MAE: {best_mae:.4f}")
+
+    # Save final model
+    final_model_path = os.path.join(CHECKPOINT_DIR, "model_final.pth")
+    torch.save(model.state_dict(), final_model_path)
+    logging.info(f"Final model saved to: {final_model_path}")
+    logging.info(f"Final Test MSE: {test_mses[-1]:.4f}, MAE: {test_maes[-1]:.4f}")
+
+    # Save training metrics
+    metrics = {
+        "train_losses": [float(x) for x in train_losses],
+        "test_mses": [float(x) for x in test_mses],
+        "test_maes": [float(x) for x in test_maes]
+    }
+
+    metrics_path = os.path.join(RESULTS_DIR, "training_metrics.json")
+    with open(metrics_path, "w") as f:
+        json.dump(metrics, f)
+    logging.info(f"Training metrics saved to: {metrics_path}")
+
+    # Done
+    elapsed = time.time() - start_time
+    logging.info(f"Training complete in {elapsed / 60:.2f} minutes.")
+
+
+# === Entry Point ===
+if __name__ == "__main__":
+    try:
+        train()
+    except Exception as e:
+        logging.error(f"Training failed: {e}")

transformer_model/scripts/utils/__init__.py

@@ -0,0 +1 @@
+# __init__