update pretrained model

app.py

@@ -32,8 +32,9 @@ def plot_raw_data(df):
         fig.tight_layout()
         return fig
 
-def forecast_interface(file, model_type, is_multivariate, horizon, neurons, epochs, batch_size, future_horizon):
+def forecast_interface(file, model_type, is_multivariate, horizon, lag, neurons, epochs, batch_size, future_horizon):
     df, _ = load_and_process_data(file.name, is_multivariate == "Multivariate")
+    print(df.head())
     raw_plot = plot_raw_data(df)
 
     if model_type in ["LSTM", "BiLSTM", "GRU"]:
@@ -42,6 +43,7 @@ def forecast_interface(file, model_type, is_multivariate, horizon, neurons, epoc
             model_type,
             is_multivariate == "Multivariate",
             horizon,
+            lag,
             neurons,
             epochs,
             batch_size,
@@ -71,11 +73,12 @@ with gr.Blocks() as demo:
         is_multivariate = gr.Radio(["Univariate", "Multivariate"], value="Univariate", label="📊 Data Type")
 
     with gr.Row():
-        horizon = gr.Slider(10, 10000, value=300, label="📏 Forecast Horizon")
-        future_horizon = gr.Slider(0, 10000, value=0, label="🔮 Future Horizon (Steps Ahead)")
+        horizon = gr.Slider(10, 10000, value=300, step=100, label="📏 Forecast Horizon")
+        lag = gr.Slider(1, 1000, value=10, step=10, label="⏳ Lag (Input Length)")
+        future_horizon = gr.Slider(0, 10000, value=0, step=100, label="🔮 Future Horizon (Steps Ahead)")
 
     with gr.Row():
-        neurons = gr.Slider(10, 12400, value=64, label="🧠 Neurons (Only for LSTM)")
+        neurons = gr.Slider(10, 12400, value=64, step=8, label="🧠 Neurons (Only for LSTM)")
         epochs = gr.Slider(10, 10000, value=100, label="🔁 Epochs")
         batch_size = gr.Slider(8, 2048, value=32, step=8, label="📦 Batch Size")
 
@@ -88,7 +91,7 @@ with gr.Blocks() as demo:
 
     run_btn.click(
         forecast_interface,
-        inputs=[file, model_type, is_multivariate, horizon, neurons, epochs, batch_size, future_horizon],
+        inputs=[file, model_type, is_multivariate, horizon, lag, neurons, epochs, batch_size, future_horizon],
         outputs=[raw_plot, output_plot, metrics_out, export_csv]
     )
 

models/custom_models.py

@@ -10,12 +10,12 @@ from tensorflow.keras.layers import LSTM, Bidirectional, GRU, Dense
 from tensorflow.keras.callbacks import EarlyStopping
 
 def prepare_data(df, lag=10):
-    values = df.values.astype('float32')
+    values = df.values.astype("float32")
     X, y = [], []
 
     for i in range(len(values) - lag):
-        X.append(values[i:i+lag])
-        y.append(values[i+lag, 0])  # always predict first column (target)
+        X.append(values[i : i + lag])
+        y.append(values[i + lag, 0])  # always predict first column (target)
 
     return np.array(X), np.array(y), values
 
@@ -30,9 +30,11 @@ def scale_data(X, y):
 
     return X_scaled, y_scaled, scaler_X, scaler_y
 
+
 def invert_prediction(scaler, pred):
     return scaler.inverse_transform(pred.reshape(-1, 1)).flatten()
 
+
 def create_model(input_shape, model_type, neurons):
     model = Sequential()
     if model_type == "LSTM":
@@ -43,13 +45,24 @@ def create_model(input_shape, model_type, neurons):
         model.add(GRU(neurons, input_shape=input_shape))
     else:
         raise ValueError(f"Unsupported model type: {model_type}")
-    
+
     model.add(Dense(1))
     model.compile(loss="mse", optimizer="adam")
     return model
 
-def run_forecast(df, model_type, is_multivariate, horizon, neurons, epochs, batch_size, future_horizon=0):
-    lag = 10
+
+def run_forecast(
+    df,
+    model_type,
+    is_multivariate,
+    horizon,
+    lag,
+    neurons,
+    epochs,
+    batch_size,
+    future_horizon=0,
+):
+    # lag = 10
     X, y, raw_values = prepare_data(df, lag=lag)
 
     train_size = len(X) - horizon
@@ -63,12 +76,13 @@ def run_forecast(df, model_type, is_multivariate, horizon, neurons, epochs, batc
 
     early_stop = EarlyStopping(monitor="loss", patience=10, restore_best_weights=True)
     model.fit(
-        X_train, y_train,
+        X_train,
+        y_train,
         epochs=epochs,
         batch_size=batch_size,
         verbose=1,
         shuffle=False,
-        callbacks=[early_stop]
+        callbacks=[early_stop],
     )
 
     y_train_pred = model.predict(X_train)
@@ -99,10 +113,7 @@ def run_forecast(df, model_type, is_multivariate, horizon, neurons, epochs, batc
     metrics = f"Test RMSE: {rmse:.3f}, Test R2: {r2:.3f}"
 
     # CSV export
-    export_df = pd.DataFrame({
-        "Test_Actual": y_test,
-        "Test_Predicted": y_test_pred
-    })
+    export_df = pd.DataFrame({"Test_Actual": y_test, "Test_Predicted": y_test_pred})
     export_path = os.path.join(tempfile.gettempdir(), "forecast_result.csv")
     export_df.to_csv(export_path, index=False)
 
@@ -111,7 +122,12 @@ def run_forecast(df, model_type, is_multivariate, horizon, neurons, epochs, batc
     plt.plot(y_test, label="Test Actual")
     plt.plot(y_test_pred, label="Test Predicted", linestyle="--")
     if future_pred:
-        plt.plot(range(len(y_test), len(y_test) + future_horizon), future_pred, label="Future Forecast", linestyle="-.")
+        plt.plot(
+            range(len(y_test), len(y_test) + future_horizon),
+            future_pred,
+            label="Future Forecast",
+            linestyle="-.",
+        )
     plt.title("Forecast Result")
     plt.xlabel("Time Step")
     plt.ylabel("Value")

models/darts_models.py

@@ -1,4 +1,5 @@
-# models/darts_models.py
+import os
+import tempfile
 import pandas as pd
 import matplotlib.pyplot as plt
 
@@ -8,10 +9,9 @@ from darts.models import (
     NBEATSModel,
     TFTModel,
     TCNModel,
-    BlockRNNModel
+    BlockRNNModel,
 )
 from darts.metrics import rmse, r2_score
-from darts.utils.timeseries_generation import datetime_attribute_timeseries
 from darts.dataprocessing.transformers import Scaler
 
 MODEL_MAP = {
@@ -22,21 +22,37 @@ MODEL_MAP = {
     "BlockRNN": BlockRNNModel,
 }
 
-def run_darts_forecast(df, model_name, is_multivariate, horizon, epochs, batch_size):
-    series = TimeSeries.from_dataframe(df)
+
+def run_darts_forecast(
+    df, model_name, is_multivariate, horizon, epochs, batch_size, future_horizon=0
+):
+    df.columns = df.columns.str.strip()  # strip spaces/BOMs
+    print(df.columns)
+    if "datetime" in df.columns:
+        df["datetime"] = pd.to_datetime(df["datetime"])
+        series = TimeSeries.from_dataframe(df, time_col="datetime")
+    elif isinstance(df.index, pd.DatetimeIndex):
+        series = TimeSeries.from_dataframe(df)
+    else:
+        raise ValueError(
+            f"DataFrame must have a 'datetime' column or a DatetimeIndex. Columns are: {df.columns}"
+        )
     series = series.astype("float32")
 
+    # Use only the first column if univariate
     if not is_multivariate and series.width > 1:
         series = series[:, 0]
 
     scaler = Scaler()
     series_scaled = scaler.fit_transform(series)
 
-    train, val = series_scaled[:-horizon], series_scaled[-horizon:]
+    lag = 30
+    train_size = len(series_scaled) - horizon
+    train, test = series_scaled[:train_size], series_scaled[train_size:]
 
     model_cls = MODEL_MAP[model_name]
     model = model_cls(
-        input_chunk_length=30,
+        input_chunk_length=lag,
         output_chunk_length=horizon,
         n_epochs=epochs,
         batch_size=batch_size,
@@ -45,21 +61,55 @@ def run_darts_forecast(df, model_name, is_multivariate, horizon, epochs, batch_s
     )
 
     model.fit(train, verbose=False)
-    forecast = model.predict(horizon)
 
-    # Invert scale
-    pred = scaler.inverse_transform(forecast)
-    actual = scaler.inverse_transform(val)
+    # Predict on test horizon
+    test_pred = model.predict(n=horizon)
+    test_actual = test
+
+    # Forecast future values
+    future_pred = None
+    if future_horizon > 0:
+        last_series = series_scaled[-lag:]
+        future_pred = model.predict(n=future_horizon, series=last_series)
+
+    # Invert scaling
+    test_pred_inv = scaler.inverse_transform(test_pred)
+    test_actual_inv = scaler.inverse_transform(test_actual)
+
+    if future_pred:
+        future_pred_inv = scaler.inverse_transform(future_pred)
+        future_vals = future_pred_inv.values().flatten()
+    else:
+        future_vals = []
+
+    # Calculate metrics
+    rmse_val = rmse(test_actual_inv, test_pred_inv)
+    r2_val = r2_score(test_actual_inv, test_pred_inv)
+    metrics = f"Test RMSE: {rmse_val:.3f}, Test R2: {r2_val:.3f}"
+
+    # Export CSV
+    export_df = pd.DataFrame(
+        {
+            "Test_Actual": test_actual_inv.values().flatten(),
+            "Test_Predicted": test_pred_inv.values().flatten(),
+        }
+    )
+    export_path = os.path.join(tempfile.gettempdir(), "darts_forecast_result.csv")
+    export_df.to_csv(export_path, index=False)
 
     # Plot
-    fig = plt.figure()
-    actual.plot(label="Actual")
-    pred.plot(label="Forecast", linestyle="--")
-    plt.title(f"{model_name} Forecast")
+    fig = plt.figure(figsize=(12, 6))
+    test_actual_inv.plot(label="Test Actual")
+    test_pred_inv.plot(label="Test Predicted", linestyle="--")
+    if future_pred:
+        future_pred_inv.plot(label="Future Forecast", linestyle="-.")
+    plt.title(f"{model_name} Forecast Result")
     plt.legend()
 
-    rmse_val = rmse(actual, pred)
-    r2_val = r2_score(actual, pred)
-    metrics = f"RMSE: {rmse_val:.3f}, R2: {r2_val:.3f}"
-
-    return pred.values().flatten(), fig, metrics
+    return (
+        test_pred_inv.values().flatten(),  # test predictions
+        future_vals,  # future forecast
+        fig,  # matplotlib figure
+        metrics,  # metrics string
+        export_path,  # CSV file path
+    )

utils/preprocessing.py

@@ -22,3 +22,4 @@ def load_and_process_data(file_path, is_multivariate):
         df = df[[numeric_cols[0]]]
 
     return df, df.shape[1]
+