Update core/train_eval.py

core/train_eval.py

@@ -1,70 +1,180 @@
-def preprocess_data(df, features, target, window_size=30, horizon=1):
+# core/train_eval.py
+import numpy as np
+import pandas as pd
+import torch
+from torch import nn, optim
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score, explained_variance_score
+from torch.utils.data import DataLoader, TensorDataset
+from torchsummary import summary
+from core.data import preprocess_data
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+def mean_absolute_percentage_error(y_true, y_pred):
+    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 np.mean(np.abs((y_true[non_zero] - y_pred[non_zero]) / y_true[non_zero])) * 100
+
+def directional_accuracy(y_true, y_pred):
+    true_diff = np.diff(y_true)
+    pred_diff = np.diff(y_pred)
+    return np.mean(np.sign(true_diff) == np.sign(pred_diff)) if len(true_diff) > 0 else np.nan
+
+def mase(y_true, y_pred, y_train):
+    mae_val = mean_absolute_error(y_true, y_pred)
+    naive_mae = mean_absolute_error(y_train[1:], y_train[:-1]) if len(y_train) > 1 else np.nan
+    return mae_val / naive_mae if naive_mae != 0 else np.nan
+
+def train_and_evaluate(
+    df,
+    features,
+    target,
+    model_cls,
+    horizon=1,
+    hidden=64,
+    layers=1,
+    epochs=50,
+    lr=0.001,
+    beta1=0.9,
+    beta2=0.999,
+    weight_decay=0.01,
+    dropout=0.2,
+    window=30,
+    test_split=0.2,
+    device="cuda" if torch.cuda.is_available() else "cpu",
+    verbose=True
+):
+    result = {}
     try:
-        # Validate features
-        available_columns = df.columns.tolist()
-        valid_features = [f for f in features if f in available_columns]
-        if not valid_features:
-            raise ValueError(f"No valid features found. Available: {available_columns}, Requested: {features}")
-        if target not in available_columns:
-            raise ValueError(f"Target {target} not in DataFrame columns: {available_columns}")
-        
-        data_df = df[valid_features].copy()
-        logging.debug(f"Initial features: {valid_features}, Shape: {data_df.shape}")
-
-        # Protect critical features
-        critical_features = [target, 'Volume', 'rsi_14', 'macdh_12_26_9', 'adx_14']
-        for feat in critical_features:
-            if feat in df.columns and feat not in data_df.columns:
-                data_df[feat] = df[feat]
-        
-        # Feature importance with RandomForest
-        if len(data_df) > 100:
-            X = data_df.drop([target], axis=1, errors='ignore')
-            y = data_df[target]
-            rf = RandomForestRegressor(n_estimators=100, random_state=42)
-            rf.fit(X, y)
-            importance = pd.Series(rf.feature_importances_, index=X.columns)
-            top_features = importance.sort_values(ascending=False).index[:10].tolist()
-            if target not in top_features:
-                top_features.append(target)
-            for feat in critical_features:
-                if feat in df.columns and feat not in top_features:
-                    top_features.append(feat)
-            data_df = data_df[top_features]
-            logging.info(f"Selected top features by RandomForest: {top_features}")
-
-        # Remove highly correlated features
-        corr_matrix = data_df.corr().abs()
-        upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
-        to_drop = [column for column in upper.columns if column not in critical_features and any(upper[column] > 0.85)]
-        data_df.drop(to_drop, axis=1, inplace=True)
-        logging.info(f"Dropped correlated features: {to_drop}")
-        
-        # PCA with 95% variance
-        updated_features = data_df.columns.tolist()
-        if len(updated_features) > 10:
-            pca = PCA(n_components=0.95)
-            data_df = pd.DataFrame(pca.fit_transform(data_df), columns=[f'pca_{i}' for i in range(pca.n_components_)])
-            logging.info(f"Applied PCA: {pca.n_components_} components, explained variance: {sum(pca.explained_variance_ratio_):.2f}")
-        
-        data = data_df.values.astype(float)
-        scaler = StandardScaler()
-        scaled = scaler.fit_transform(data)
-        target_idx = updated_features.index(target) if target in updated_features else -1
-        if target_idx == -1:
-            raise ValueError("Target not in features after preprocessing.")
-        
-        X, y = [], []
-        for i in range(len(scaled) - window_size - horizon + 1):
-            X.append(scaled[i:i + window_size])
-            y.append(scaled[i + window_size:i + window_size + horizon, target_idx])
-        X = np.array(X)
-        y = np.array(y)
-        if X.shape[0] == 0 or y.shape[0] == 0:
-            raise ValueError(f"Insufficient data: len={len(scaled)}, window={window_size}, horizon={horizon}")
-        
-        logging.info(f"Preprocessed data: X.shape={X.shape}, y.shape={y.shape}, Features: {updated_features}")
-        return X, y, scaler, updated_features, target_idx
+        X, y, scaler = preprocess_data(df, features, target, window, horizon)
+        if X is None:
+            raise ValueError("Preprocessing failed.")
+        target_idx = features.index(target)
+
+        split = int(len(X) * (1 - test_split))
+        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:]
+
+        if len(X_train) == 0 or len(X_test) == 0:
+            result["metrics"] = {k: 0.0 for k in ["R2", "ExplainedVariance", "MDA", "RMSE", "MAE", "MAPE", "MASE"]}
+            result["forecast"] = []
+            result["actual"] = []
+            result["latest_prediction"] = []
+            result["train_loss"] = []
+            result["val_loss"] = []
+            return result
+
+        train_loader = DataLoader(TensorDataset(torch.tensor(X_train, dtype=torch.float32), torch.tensor(y_train, dtype=torch.float32)), batch_size=32, shuffle=True)
+        val_loader = DataLoader(TensorDataset(torch.tensor(X_val, dtype=torch.float32), torch.tensor(y_val, dtype=torch.float32)), batch_size=32, shuffle=False)
+        test_loader = DataLoader(TensorDataset(torch.tensor(X_test, dtype=torch.float32), torch.tensor(y_test, dtype=torch.float32)), batch_size=32, shuffle=False)
+
+        input_dim = X_train.shape[2]
+        model = model_cls(input_size=input_dim, hidden_size=hidden, num_layers=layers, output_size=horizon, dropout=dropout).to(device)
+        result["model_summary"] = str(summary(model, (window, input_dim)))
+
+        optimizer = optim.AdamW(model.parameters(), lr=lr, betas=(beta1, beta2), weight_decay=weight_decay)
+        scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=5, verbose=verbose)
+        loss_fn = nn.MSELoss()
+
+        train_losses = []
+        val_losses = []
+        best_val_loss = float('inf')
+        patience = 10
+        counter = 0
+        best_model_state = None
+
+        for epoch in range(epochs):
+            model.train()
+            epoch_loss = 0.0
+            for xb, yb in train_loader:
+                xb, yb = xb.to(device), yb.to(device)
+                optimizer.zero_grad()
+                out = model(xb)
+                loss = loss_fn(out, yb)
+                loss.backward()
+                optimizer.step()
+                epoch_loss += loss.item()
+            train_losses.append(epoch_loss / len(train_loader))
+
+            model.eval()
+            val_loss = 0.0
+            with torch.no_grad():
+                for xb, yb in val_loader:
+                    xb, yb = xb.to(device), yb.to(device)
+                    out = model(xb)
+                    loss = loss_fn(out, yb)
+                    val_loss += loss.item()
+            if len(val_loader) > 0:
+                val_loss /= len(val_loader)
+            val_losses.append(val_loss)
+            scheduler.step(val_loss)
+
+            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}")
+
+            if val_loss < best_val_loss:
+                best_val_loss = val_loss
+                counter = 0
+                best_model_state = model.state_dict()
+            else:
+                counter += 1
+                if counter >= patience:
+                    print(f"Early stopping at epoch {epoch+1}")
+                    break
+
+        if best_model_state:
+            model.load_state_dict(best_model_state)
+
+        result["train_loss"] = train_losses
+        result["val_loss"] = val_losses
+
+        model.eval()
+        preds, targets = [], []
+        with torch.no_grad():
+            for xb, yb in test_loader:
+                xb = xb.to(device)
+                out = model(xb).cpu().numpy()
+                preds.append(out)
+                targets.append(yb.numpy())
+
+        preds = np.concatenate(preds, axis=0)
+        targets = np.concatenate(targets, axis=0)
+
+        def inverse_y(values):
+            dummy = np.zeros((values.shape[0], len(features)))
+            dummy[:, target_idx] = values.flatten()
+            return scaler.inverse_transform(dummy)[:, target_idx]
+
+        preds_inv = inverse_y(preds)
+        targets_inv = inverse_y(targets)
+        y_train_inv = inverse_y(y_train.flatten())
+
+        result["metrics"] = {
+            "R2": r2_score(targets_inv, preds_inv),
+            "ExplainedVariance": explained_variance_score(targets_inv, preds_inv),
+            "MDA": directional_accuracy(targets_inv, preds_inv),
+            "RMSE": np.sqrt(mean_squared_error(targets_inv, preds_inv)),
+            "MAE": mean_absolute_error(targets_inv, preds_inv),
+            "MAPE": mean_absolute_percentage_error(targets_inv, preds_inv),
+            "MASE": mase(targets_inv, preds_inv, y_train_inv)
+        }
+
+        result["forecast"] = preds_inv
+        result["actual"] = targets_inv
+
+        latest_window = df[features].tail(window).values
+        latest_scaled = scaler.transform(latest_window)
+        latest_input = torch.tensor(latest_scaled.reshape(1, window, -1), dtype=torch.float32).to(device)
+        with torch.no_grad():
+            future_pred = model(latest_input).cpu().numpy().flatten()
+        result["latest_prediction"] = inverse_y(future_pred).tolist()
+
+        return result
     except Exception as e:
-        logging.error(f"Preprocessing error: {e}")
-        raise
+        logging.error(f"Train eval error: {e}")
+        return {}