Update core/train_eval.py

core/train_eval.py

@@ -1,5 +1,4 @@
 # core/train_eval.py
-
 import numpy as np
 import pandas as pd
 import torch
@@ -164,8 +163,9 @@ def train_and_evaluate(
         selected_features = select_features(
             df, features, target, selector_method, importance_threshold
         )
+        logging.info(f"Selected features: {selected_features}")
 
-        # --- FIX: Properly unpack preprocess_data return (avoid tuple issue) ---
+        # --- MUST unpack preprocess_data properly (avoid tuple misuse) ---
         (
             X,
             y,
@@ -177,14 +177,24 @@ def train_and_evaluate(
             updated_feature_cols,
         ) = preprocess_data(df, selected_features, target, window, horizon)
 
+        X = np.asarray(X)
+        y = np.asarray(y)
+
+        if X.ndim != 3:
+            raise ValueError(f"Preprocessed X must be 3D (samples, window, features). Got shape: {X.shape}")
+        if y.ndim == 1:
+            # ensure y has shape (samples, horizon)
+            y = y.reshape(-1, horizon)
+
         if X.shape[0] < 10:
             return {"error": f"Insufficient data samples: {X.shape[0]}"}
 
-        # Train/test split
+        # Train/test split (simple slice to preserve time order)
         train_size = int((1 - test_split) * len(X))
         X_train, X_test = X[:train_size], X[train_size:]
         y_train, y_test = y[:train_size], y[train_size:]
 
+        # Build datasets (do NOT move to device here; move in training loop)
         train_dataset = TensorDataset(
             torch.tensor(X_train, dtype=torch.float32),
             torch.tensor(y_train, dtype=torch.float32),
@@ -209,6 +219,7 @@ def train_and_evaluate(
             try:
                 output = StringIO()
                 sys.stdout = output
+                # summary expects (channels, seq_len) for some models, here we show (seq_len, features)
                 summary(model, input_size=(window, input_size))
                 sys.stdout = sys.__stdout__
                 logging.debug(output.getvalue())
@@ -233,21 +244,25 @@ def train_and_evaluate(
             model.train()
             running_loss = 0.0
             for batch_X, batch_y in train_loader:
-                batch_X, batch_y = batch_X.to(device), batch_y.to(device)
+                batch_X = batch_X.to(device)
+                batch_y = batch_y.to(device)
                 optimizer.zero_grad()
                 outputs = model(batch_X)
                 loss = criterion(outputs, batch_y)
                 loss.backward()
                 optimizer.step()
                 running_loss += loss.item() * batch_X.size(0)
+
             epoch_train_loss = running_loss / len(train_loader.dataset)
             train_losses.append(epoch_train_loss)
 
+            # validation
             model.eval()
             running_val = 0.0
             with torch.no_grad():
                 for batch_X, batch_y in test_loader:
-                    batch_X, batch_y = batch_X.to(device), batch_y.to(device)
+                    batch_X = batch_X.to(device)
+                    batch_y = batch_y.to(device)
                     outputs = model(batch_X)
                     v_loss = criterion(outputs, batch_y)
                     running_val += v_loss.item() * batch_X.size(0)
@@ -257,40 +272,47 @@ def train_and_evaluate(
             if scheduler:
                 scheduler.step(epoch_val_loss)
 
+            logging.debug(f"Epoch {epoch+1}/{epochs} train={epoch_train_loss:.6f} val={epoch_val_loss:.6f}")
+
         # ---------------- Evaluation ----------------
         model.eval()
         with torch.no_grad():
-            y_pred_scaled = model(torch.tensor(X_test, dtype=torch.float32).to(device)).cpu().numpy()
+            X_test_tensor = torch.tensor(X_test, dtype=torch.float32).to(device)
+            y_pred_scaled = model(X_test_tensor).cpu().numpy()
+
         y_test_unscaled = target_scaler.inverse_transform(y_test.reshape(-1, horizon)).flatten()
         y_pred_unscaled = target_scaler.inverse_transform(y_pred_scaled.reshape(-1, horizon)).flatten()
 
         precision, recall = compute_precision_recall(y_test_unscaled, y_pred_unscaled)
 
         metrics = {
-            "R2": r2_score(y_test_unscaled, y_pred_unscaled),
-            "MAPE": mean_absolute_percentage_error(y_test_unscaled, y_pred_unscaled),
-            "RMSE": np.sqrt(mean_squared_error(y_test_unscaled, y_pred_unscaled)),
-            "MAE": mean_absolute_error(y_test_unscaled, y_pred_unscaled),
-            "DirAcc": directional_accuracy(y_test_unscaled, y_pred_unscaled),
-            "MASE": mase(
-                y_test_unscaled,
-                y_pred_unscaled,
-                target_scaler.inverse_transform(y_train.reshape(-1, horizon)).flatten(),
+            "R2": float(r2_score(y_test_unscaled, y_pred_unscaled)),
+            "MAPE": float(mean_absolute_percentage_error(y_test_unscaled, y_pred_unscaled)),
+            "RMSE": float(np.sqrt(mean_squared_error(y_test_unscaled, y_pred_unscaled))),
+            "MAE": float(mean_absolute_error(y_test_unscaled, y_pred_unscaled)),
+            "DirAcc": float(directional_accuracy(y_test_unscaled, y_pred_unscaled)),
+            "MASE": float(
+                mase(
+                    y_test_unscaled,
+                    y_pred_unscaled,
+                    target_scaler.inverse_transform(y_train.reshape(-1, horizon)).flatten(),
+                )
             ),
-            "Volatility": compute_volatility(y_pred_unscaled),
-            "Sharpe": compute_sharpe_ratio(y_pred_unscaled),
-            "Precision": precision,
-            "Recall": recall,
+            "Volatility": float(compute_volatility(y_pred_unscaled)),
+            "Sharpe": float(compute_sharpe_ratio(y_pred_unscaled)),
+            "Precision": float(np.nan if np.isnan(precision) else precision),
+            "Recall": float(np.nan if np.isnan(recall) else recall),
         }
 
+        # Latest prediction (use last window from original X)
         latest_data = torch.tensor(X[-1:], dtype=torch.float32).to(device)
         with torch.no_grad():
-            latest_prediction = model(latest_data).cpu().numpy()
+            latest_prediction_scaled = model(latest_data).cpu().numpy()
             latest_prediction = target_scaler.inverse_transform(
-                latest_prediction.reshape(-1, horizon)
+                latest_prediction_scaled.reshape(-1, horizon)
             ).flatten()
 
-        return {
+        result = {
             "model": model,
             "train_loss": train_losses,
             "val_loss": val_losses,
@@ -305,8 +327,13 @@ def train_and_evaluate(
                 "dropout": dropout,
                 "window": window,
             },
+            "scalers": {"feature_scaler": feature_scaler, "target_scaler": target_scaler},
+            "features": updated_feature_cols,
         }
 
+        logging.info("Training and evaluation completed successfully")
+        return result
+
     except Exception as e:
         logging.error(f"Error in train_and_evaluate: {str(e)}")
-        return {"error": str(e)}
+        return {"error": str(e)}