Update core/train_eval.py

core/train_eval.py

@@ -30,7 +30,6 @@ 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
@@ -62,6 +61,7 @@ def train_and_evaluate(
     dropout=0.2,
     window=30,
     test_split=0.2,
+    scheduler_factor=0.5,
     device="cuda" if torch.cuda.is_available() else "cpu",
     verbose=True
 ):
@@ -83,6 +83,7 @@ def train_and_evaluate(
     print(f"X_val shape: {X_val.shape}, y_val shape: {y_val.shape}")
     print(f"X_test shape: {X_test.shape}, y_test shape: {y_test.shape}")
 
+    batch_size = 32
     X_train_tensor = torch.tensor(X_train, dtype=torch.float32)
     y_train_tensor = torch.tensor(y_train, dtype=torch.float32)
     X_val_tensor = torch.tensor(X_val, dtype=torch.float32)
@@ -90,15 +91,15 @@ def train_and_evaluate(
     X_test_tensor = torch.tensor(X_test, dtype=torch.float32)
     y_test_tensor = torch.tensor(y_test, dtype=torch.float32)
 
-    train_loader = DataLoader(TensorDataset(X_train_tensor, y_train_tensor), batch_size=32, shuffle=True)
-    val_loader = DataLoader(TensorDataset(X_val_tensor, y_val_tensor), batch_size=32, shuffle=False)
-    test_loader = DataLoader(TensorDataset(X_test_tensor, y_test_tensor), batch_size=32, shuffle=False)
+    train_loader = DataLoader(TensorDataset(X_train_tensor, y_train_tensor), batch_size=batch_size, shuffle=True)
+    val_loader = DataLoader(TensorDataset(X_val_tensor, y_val_tensor), batch_size=batch_size, shuffle=False)
+    test_loader = DataLoader(TensorDataset(X_test_tensor, y_test_tensor), batch_size=batch_size, shuffle=False)
 
     input_dim = X_train.shape[2] if X_train.ndim == 3 else 1
     model = model_cls(input_size=input_dim, hidden_size=hidden, num_layers=layers, output_size=horizon, dropout=dropout).to(device)
     optimizer = torch.optim.AdamW(model.parameters(), lr=lr, betas=(beta1, beta2), weight_decay=weight_decay)
     loss_fn = nn.MSELoss()
-    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', patience=5, factor=0.5, threshold=1e-4)
+    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', patience=5, factor=scheduler_factor, threshold=1e-4)
 
     train_losses = []
     val_losses = []
@@ -186,13 +187,13 @@ def train_and_evaluate(
     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,
-        "MASE": round(mase, 4) if not np.isnan(mase) else None
+        "R² (%)": round(r2 * 100, 2),
+        "Explained Variance (%)": round(evs * 100, 2),
+        "MDA (%)": round(mda, 2) if not np.isnan(mda) else None,
+        "RMSE": round(rmse, 2),
+        "MAE": round(mae, 2),
+        "MAPE (%)": round(mape, 2) if not np.isnan(mape) else None,
+        "MASE": round(mase, 2) if not np.isnan(mase) else None
     }
 
     result["forecast"] = preds_inv
@@ -212,4 +213,14 @@ def train_and_evaluate(
     if not future_df.empty:
         result["future_actuals"] = future_df['value'].values.tolist()[:horizon]
 
+    result["architecture"] = {
+        "model_name": model_cls.__name__,
+        "num_layers": layers,
+        "hidden_units": hidden,
+        "dropout": dropout,
+        "batch_size": batch_size,
+        "input_size": input_dim,
+        "output_size": horizon
+    }
+
     return result