Update core/train_eval.py

core/train_eval.py

@@ -17,6 +17,15 @@ def create_sequences(data, window_size, horizon=1):
     return np.array(X), np.array(y)
 
 
+def mean_absolute_percentage_error(y_true, y_pred):
+    """Calculate MAPE, avoiding division by zero."""
+    y_true, y_pred = np.array(y_true), np.array(y_pred)
+    non_zero = np.abs(y_true) > 0
+    if np.sum(non_zero) == 0:
+        return np.nan  # Return NaN if all true values are zero
+    return np.mean(np.abs((y_true[non_zero] - y_pred[non_zero]) / y_true[non_zero])) * 100
+
+
 def train_and_evaluate(
     df,
     model_cls,
@@ -25,6 +34,10 @@ def train_and_evaluate(
     layers=1,
     epochs=50,
     lr=0.001,
+    beta1=0.9,  # Added
+    beta2=0.999,  # Added
+    weight_decay=0.01,  # Added
+    dropout=0.2,  # Added
     window=30,
     test_split=0.2,
     device="cuda" if torch.cuda.is_available() else "cpu",
@@ -32,19 +45,15 @@ def train_and_evaluate(
 ):
     result = {}
 
-    # Step 1: Keep original values for inverse mapping
     original_values = df['value'].values.astype(np.float32)
-
-    # Step 2: Normalize data
     scaler = StandardScaler()
     scaled_data = scaler.fit_transform(original_values.reshape(-1, 1))
     X, y = create_sequences(scaled_data, window, horizon)
 
     print(f"X shape: {X.shape}, y shape: {y.shape}")
 
-    # Step 3: Split into train, validation, and test
     split = int(len(X) * (1 - test_split))
-    val_split = int(split * 0.9)  # 90% train, 10% validation
+    val_split = int(split * 0.9)
     X_train, X_val, X_test = X[:val_split], X[val_split:split], X[split:]
     y_train, y_val, y_test = y[:val_split], y[val_split:split], y[split:]
 
@@ -63,10 +72,9 @@ def train_and_evaluate(
     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)
 
-    # Step 4: Model
     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).to(device)
-    optimizer = torch.optim.AdamW(model.parameters(), lr=lr, betas=(0.9, 0.999), weight_decay=0.01)
+    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()
 
     train_losses = []
@@ -78,7 +86,6 @@ def train_and_evaluate(
 
     model.train()
     for epoch in range(epochs):
-        # Training
         epoch_loss = 0.0
         for xb, yb in train_loader:
             xb, yb = xb.to(device), yb.to(device)
@@ -90,7 +97,6 @@ def train_and_evaluate(
             epoch_loss += loss.item()
         train_losses.append(epoch_loss / len(train_loader))
 
-        # Validation
         model.eval()
         val_loss = 0.0
         with torch.no_grad():
@@ -105,7 +111,6 @@ def train_and_evaluate(
         if verbose and (epoch + 1) % 10 == 0:
             print(f"Epoch {epoch+1}/{epochs} - Train Loss: {train_losses[-1]:.4f}, Val Loss: {val_losses[-1]:.4f}")
 
-        # Early stopping
         if val_loss < best_val_loss:
             best_val_loss = val_loss
             counter = 0
@@ -122,7 +127,6 @@ def train_and_evaluate(
     result["train_loss"] = train_losses
     result["val_loss"] = val_losses
 
-    # Step 5: Evaluate
     model.eval()
     preds, targets = [], []
     with torch.no_grad():
@@ -137,7 +141,6 @@ def train_and_evaluate(
 
     print(f"Preds shape: {preds.shape}, Targets shape: {targets.shape}")
 
-    # Reshape for inverse transform
     preds_reshaped = preds.reshape(-1, 1)
     targets_reshaped = targets.reshape(-1, 1)
     preds_inv = scaler.inverse_transform(preds_reshaped).reshape(preds.shape)
@@ -147,18 +150,19 @@ def train_and_evaluate(
     rmse = np.sqrt(mse)
     mae = mean_absolute_error(targets_inv, preds_inv)
     r2 = r2_score(targets_inv, preds_inv)
+    mape = mean_absolute_percentage_error(targets_inv, preds_inv)
 
     result["metrics"] = {
         "R2": round(r2, 4),
         "RMSE": round(rmse, 4),
-        "MAE": round(mae, 4)
+        "MAE": round(mae, 4),
+        "MAPE": round(mape, 4) if not np.isnan(mape) else None
     }
 
     result["forecast"] = preds_inv
     result["actual"] = targets_inv
     result["predicted"] = result["forecast"]
 
-    # Step 6: Predict the next value(s)
     latest_window = scaled_data[-window:].reshape(1, window, 1)
     latest_input = torch.tensor(latest_window, dtype=torch.float32).to(device)