update the darts models

.gitignore

@@ -3,4 +3,5 @@ models/__pycache__
 utils/__pycache__
 dataset/*
 figure/*
-result/*
+result/*
+.python-version

app.py

@@ -1,5 +1,6 @@
 # app.py
 import os
+import torch
 import gradio as gr
 import matplotlib.pyplot as plt
 from dotenv import load_dotenv
@@ -9,6 +10,8 @@ from models.darts_models import run_darts_forecast  # Darts-based models
 
 load_dotenv()
 
+has_gpu = torch.cuda.is_available()
+
 def plot_raw_data(df):
     if df.shape[1] == 1:
         fig = plt.figure(figsize=(12, 4))
@@ -32,9 +35,15 @@ def plot_raw_data(df):
         fig.tight_layout()
         return fig
 
-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())
+def forecast_interface(file, model_type, is_multivariate, horizon, lag, neurons, epochs, batch_size, future_horizon, device):
+    darts_models = ["Transformer", "N-BEATS", "TFT", "TCN", "BlockRNN"]
+    is_darts_model = model_type in darts_models
+
+    df, _ = load_and_process_data(
+        file.name,
+        is_multivariate == "Multivariate",
+        keep_datetime_column_for_darts=is_darts_model
+    )
     raw_plot = plot_raw_data(df)
 
     if model_type in ["LSTM", "BiLSTM", "GRU"]:
@@ -48,19 +57,21 @@ def forecast_interface(file, model_type, is_multivariate, horizon, lag, neurons,
             epochs,
             batch_size,
             future_horizon=future_horizon,
+            device=device
         )
         return raw_plot, fig, metrics, export_path
-
     else:
-        forecast, fig, metrics = run_darts_forecast(
+        forecast, fig, metrics, export_path = run_darts_forecast(
             df,
             model_type,
             is_multivariate == "Multivariate",
             horizon,
             epochs,
-            batch_size
+            batch_size,
+            future_horizon=future_horizon,
+            device=device
         )
-        return raw_plot, fig, metrics, None
+        return raw_plot, fig, metrics, export_path
 
 models = ["LSTM", "BiLSTM", "GRU", "Transformer", "N-BEATS", "TFT", "TCN", "BlockRNN"]
 
@@ -78,9 +89,16 @@ with gr.Blocks() as demo:
         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, step=8, label="🧠 Neurons (Only for LSTM)")
+        neurons = gr.Slider(10, 2048, value=32, 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")
+    
+    with gr.Row():
+        device_choice = gr.Radio(
+            choices=["CPU", "GPU"] if has_gpu else ["CPU"],
+            value="GPU" if has_gpu else "CPU",
+            label="⚙️ Device"
+        )
 
     run_btn = gr.Button("🚀 Run Forecast")
 
@@ -91,7 +109,7 @@ with gr.Blocks() as demo:
 
     run_btn.click(
         forecast_interface,
-        inputs=[file, model_type, is_multivariate, horizon, lag, neurons, epochs, batch_size, future_horizon],
+        inputs=[file, model_type, is_multivariate, horizon, lag, neurons, epochs, batch_size, future_horizon, device_choice],
         outputs=[raw_plot, output_plot, metrics_out, export_csv]
     )
 

dockerfile.gpu

@@ -1,15 +1,26 @@
-# Dockerfile.gpu
-FROM nvidia/cuda:12.2.0-runtime-ubuntu20.04
+# Use the Nvidia CUDA base image
+FROM nvidia/cuda:12.9.1-runtime-ubuntu24.04
 
+# Set the working directory to /app
 WORKDIR /app
 
+# Copy the current directory contents to the container at /app
 COPY . .
 
+# Install system dependencies
 RUN apt-get update && apt-get install -y \
-    python3-pip python3-dev git gcc g++ && \
-    pip3 install --upgrade pip && \
-    pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 && \
-    pip3 install -r requirements.txt
+    python3-venv python3-pip python3-dev git gcc g++ && \
+    # Create a virtual environment in the /app directory
+    python3 -m venv /app/venv && \
+    # Activate the virtual environment and upgrade pip
+    /app/venv/bin/pip install --upgrade pip && \
+    # Install PyTorch and other dependencies inside the virtual environment
+    /app/venv/bin/pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 && \
+    # Install the remaining dependencies from requirements.txt
+    /app/venv/bin/pip install -r requirements.txt
 
+# Expose the port 7860 (for your app)
 EXPOSE 7860
-CMD ["python3", "app.py"]
+
+# Use the virtual environment to run the app
+CMD ["/app/venv/bin/python3", "app.py"]

models/custom_model_bk.py

@@ -1,108 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-import pandas as pd
-from sklearn.metrics import r2_score, root_mean_squared_error
-from sklearn.preprocessing import MinMaxScaler
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import LSTM, Bidirectional, GRU, Dense
-from tensorflow.keras.callbacks import EarlyStopping
-import tempfile
-import os
-
-def prepare_data(df, lag=1):
-    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])
-    return np.array(X), np.array(y), values
-
-def scale_data(X, y):
-    scaler = MinMaxScaler(feature_range=(0, 1))
-    y = y.reshape(-1, 1)
-    scaled_X = scaler.fit_transform(X.reshape(-1, X.shape[-1])).reshape(X.shape)
-    scaled_y = scaler.transform(y)
-    return scaled_X, scaled_y, scaler
-
-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":
-        model.add(LSTM(neurons, input_shape=input_shape))
-    elif model_type == "BiLSTM":
-        model.add(Bidirectional(LSTM(neurons), input_shape=input_shape))
-    elif model_type == "GRU":
-        model.add(GRU(neurons, input_shape=input_shape))
-    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
-    X, y, raw_values = prepare_data(df, lag=lag)
-
-    train_size = len(X) - horizon
-    X_train, X_test = X[:train_size], X[train_size:]
-    y_train, y_test = y[:train_size], y[train_size:]
-
-    X_train, y_train, scaler = scale_data(X_train, y_train)
-    X_test, y_test, _ = scale_data(X_test, y_test)
-
-    X_train = X_train.reshape(X_train.shape[0], lag, X_train.shape[-1])
-    X_test = X_test.reshape(X_test.shape[0], lag, X_test.shape[-1])
-
-    model = create_model((lag, X_train.shape[-1]), model_type, neurons)
-
-    early_stop = EarlyStopping(monitor="loss", patience=10, restore_best_weights=True)
-    model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, verbose=1, shuffle=False, callbacks=[early_stop])
-
-    y_train_pred = model.predict(X_train)
-    y_test_pred = model.predict(X_test)
-
-    y_train_pred = invert_prediction(scaler, y_train_pred)
-    y_test_pred = invert_prediction(scaler, y_test_pred)
-    y_train = invert_prediction(scaler, y_train)
-    y_test = invert_prediction(scaler, y_test)
-
-    # Forecast future
-    future_pred = []
-    if future_horizon > 0:
-        last_input = X_test[-1]
-        for _ in range(future_horizon):
-            pred_scaled = model.predict(last_input.reshape(1, lag, -1))
-            pred = invert_prediction(scaler, pred_scaled)
-            future_pred.append(pred[0])
-
-            # slide window
-            next_input = np.roll(last_input, -1, axis=0)
-            next_input[-1] = pred_scaled
-            last_input = next_input
-
-    # Metrics
-    test_rmse = root_mean_squared_error(y_test, y_test_pred)
-    test_r2 = r2_score(y_test, y_test_pred)
-
-    metrics = f"Test RMSE: {test_rmse:.3f}, Test R2: {test_r2:.3f}"
-
-    # Export CSV
-    export_df = pd.DataFrame({
-        "Test_Actual": y_test.flatten(),
-        "Test_Predicted": y_test_pred.flatten()
-    })
-    export_path = os.path.join(tempfile.gettempdir(), "forecast_result.csv")
-    export_df.to_csv(export_path, index=False)
-
-    # Plot
-    fig = plt.figure(figsize=(12, 6))
-    plt.plot(y_test, label="Test Actual")
-    plt.plot(y_test_pred, label="Test Predicted", linestyle="dashed")
-    if future_horizon > 0:
-        plt.plot(range(len(y_test), len(y_test) + len(future_pred)), future_pred, label="Future Forecast", linestyle="dashdot")
-    plt.title("Forecast Result")
-    plt.xlabel("Time Step")
-    plt.ylabel("Value")
-    plt.legend()
-
-    return y_train_pred, y_test_pred, future_pred, fig, metrics, export_path

models/custom_models.py

@@ -1,5 +1,6 @@
 import numpy as np
 import pandas as pd
+import tensorflow as tf
 import os
 import tempfile
 import matplotlib.pyplot as plt
@@ -61,7 +62,13 @@ def run_forecast(
     epochs,
     batch_size,
     future_horizon=0,
+    device="CPU",
 ):
+    if device == "GPU":
+        physical_devices = tf.config.list_physical_devices('GPU')
+        if physical_devices:
+            tf.config.experimental.set_memory_growth(physical_devices[0], True)
+    
     # lag = 10
     X, y, raw_values = prepare_data(df, lag=lag)
 

models/darts_models.py

@@ -30,9 +30,9 @@ def run_darts_forecast(
     print(df.columns)
     if "datetime" in df.columns:
         df["datetime"] = pd.to_datetime(df["datetime"])
-        series = TimeSeries.from_dataframe(df, time_col="datetime")
+        series = TimeSeries.from_dataframe(df, time_col="datetime", fill_missing_dates=True, freq=None)
     elif isinstance(df.index, pd.DatetimeIndex):
-        series = TimeSeries.from_dataframe(df)
+        series = TimeSeries.from_dataframe(df, fill_missing_dates=True, freq=None)
     else:
         raise ValueError(
             f"DataFrame must have a 'datetime' column or a DatetimeIndex. Columns are: {df.columns}"
@@ -57,7 +57,7 @@ def run_darts_forecast(
         n_epochs=epochs,
         batch_size=batch_size,
         random_state=42,
-        pl_trainer_kwargs={"accelerator": "auto"},
+        pl_trainer_kwargs={"accelerator": device.lower()},
     )
 
     model.fit(train, verbose=False)

requirements.txt

@@ -7,4 +7,5 @@ keras
 gradio
 python-dotenv
 openpyxl
+torch
 u8darts[torch]

utils/preprocessing.py

@@ -1,7 +1,7 @@
 # utils/preprocessing.py
 import pandas as pd
 
-def load_and_process_data(file_path, is_multivariate):
+def load_and_process_data(file_path, is_multivariate, keep_datetime_column_for_darts=False):
     df = pd.read_csv(file_path)
 
     # Auto-detect time column
@@ -12,14 +12,19 @@ def load_and_process_data(file_path, is_multivariate):
             break
 
     if time_col:
+        df[time_col] = pd.to_datetime(df[time_col], errors="coerce")  # force datetime conversion
+        df = df.dropna(subset=[time_col])
         df.set_index(time_col, inplace=True)
 
     if not is_multivariate:
-        # Use only the first numeric column for univariate
-        numeric_cols = df.select_dtypes(include=['float64', 'int64']).columns
+        numeric_cols = df.select_dtypes(include=["float64", "int64"]).columns
         if len(numeric_cols) == 0:
             raise ValueError("No numeric column found for univariate forecast.")
-        df = df[[numeric_cols[0]]]
 
-    return df, df.shape[1]
+        if keep_datetime_column_for_darts:
+            # For Darts: keep full DataFrame with datetime index, but only 1 target column
+            df = df[[numeric_cols[0]]]  # still only one target column but keep datetime index
+        else:
+            df = df[[numeric_cols[0]]]  # just target column, no datetime needed
 
+    return df, df.shape[1]