Update core/train_eval.py

core/train_eval.py

@@ -3,7 +3,7 @@ import pandas as pd
 import torch
 from torch import nn, optim
 from sklearn.preprocessing import StandardScaler
-from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score, explained_variance_score
 from torch.utils.data import DataLoader, TensorDataset
 import matplotlib.pyplot as plt
 import os
@@ -26,6 +26,27 @@ def mean_absolute_percentage_error(y_true, y_pred):
     return np.mean(np.abs((y_true[non_zero] - y_pred[non_zero]) / y_true[non_zero])) * 100
 
 
+def mean_absolute_scaled_error(y_true, y_pred, y_train):
+    """Calculate MASE, using naive forecast as denominator."""
+    y_true, y_pred = np.array(y_true), np.array(y_pred)
+    errors = np.abs(y_true - y_pred)
+    # Naive forecast: use previous value as prediction
+    naive_errors = np.abs(y_train[1:] - y_train[:-1])
+    mean_naive_error = np.mean(naive_errors) if len(naive_errors) > 0 else 1.0
+    return np.mean(errors) / mean_naive_error if mean_naive_error != 0 else np.nan
+
+
+def mean_directional_accuracy(y_true, y_pred):
+    """Calculate MDA: percentage of correct direction predictions."""
+    y_true, y_pred = np.array(y_true), np.array(y_pred)
+    if len(y_true) < 2:
+        return np.nan
+    true_diff = np.sign(y_true[1:] - y_true[:-1])
+    pred_diff = np.sign(y_pred[1:] - y_pred[:-1])
+    correct = np.sum(true_diff == pred_diff)
+    return (correct / (len(y_true) - 1)) * 100
+
+
 def train_and_evaluate(
     df,
     future_df,
@@ -85,7 +106,7 @@ def train_and_evaluate(
     patience = 5
     counter = 0
     best_model_state = None
-    last_lr = lr  # Track learning rate for manual logging
+    last_lr = lr
 
     model.train()
     for epoch in range(epochs):
@@ -111,7 +132,6 @@ def train_and_evaluate(
         val_loss /= len(val_loader)
         val_losses.append(val_loss)
 
-        # Step scheduler and manually log learning rate changes
         scheduler.step(val_loss)
         current_lr = optimizer.param_groups[0]['lr']
         if current_lr != last_lr and verbose:
@@ -161,12 +181,18 @@ def train_and_evaluate(
     mae = mean_absolute_error(targets_inv, preds_inv)
     r2 = r2_score(targets_inv, preds_inv)
     mape = mean_absolute_percentage_error(targets_inv, preds_inv)
+    evs = explained_variance_score(targets_inv, preds_inv)
+    mase = mean_absolute_scaled_error(targets_inv, preds_inv, original_values[:len(original_values)-horizon])
+    mda = mean_directional_accuracy(targets_inv, preds_inv)
 
     result["metrics"] = {
         "R2": round(r2, 4),
+        "Explained Variance": round(evs, 4),
+        "MDA (%)": round(mda, 4) if not np.isnan(mda) else None,
         "RMSE": round(rmse, 4),
         "MAE": round(mae, 4),
-        "MAPE": round(mape, 4) if not np.isnan(mape) else None
+        "MAPE (%)": round(mape, 4) if not np.isnan(mape) else None,
+        "MASE": round(mase, 4) if not np.isnan(mase) else None
     }
 
     result["forecast"] = preds_inv
@@ -183,7 +209,6 @@ def train_and_evaluate(
 
     result["latest_prediction"] = future_pred_inv[0].tolist()
 
-    # Include actual future values if available
     if not future_df.empty:
         result["future_actuals"] = future_df['value'].values.tolist()[:horizon]