cilipep/ai-agent-with-tslab/walk-forward-optimization

from sklearn.preprocessing import StandardScaler
# Create dataset with external scaler
scaler = StandardScaler()
scaler.fit(train_data)  # Fit ONLY on training data
train_scaled = scaler.transform(train_data)
val_scaled = scaler.transform(val_data)  # Transform with fitted scaler
test_scaled = scaler.transform(test_data)

for fold in range(n_folds):
    # Split into train/val/test
    full_train_indices = list(range(0, train_end - window))
    val_split = int(len(full_train_indices) * 0.85)
    train_indices = full_train_indices[:val_split]
    val_indices = full_train_indices[val_split:]
    
    # Train models
    models = []
    for seed in seeds:
        model = build_model(config)
        model = train(model, train_ds, val_ds, config)  # Early stop on val
        models.append(model)

def find_best_threshold(model, val_ds, df, config, start_idx):
    best_threshold = 0.5
    best_return = -float("inf")
    
    for threshold in [0.3, 0.35, 0.4, 0.45, 0.5]:
        result = run_backtest(model, val_ds, df, config, 
                            threshold=threshold, start_idx=start_idx)
        if result["n_trades"] > 0 and result["total_return_pct"] > best_return:
            best_return = result["total_return_pct"]
            best_threshold = threshold
    
    return best_threshold

def find_best_weights(models, val_ds, df, config, start_idx):
    best_weights = [1.0 / len(models)] * len(models)
    best_return = -float("inf")
    
    # Grid search
    steps = [0.1, 0.2, 0.3, 0.4, 0.5]
    for combo in product(steps, repeat=len(models)):
        if abs(sum(combo) - 1.0) > 0.01:
            continue  # Weights must sum to 1
        
        ensemble = Ensemble(models, list(combo))
        result = run_backtest(ensemble, val_ds, df, config, 
                            threshold=0.5, start_idx=start_idx)
        
        if result["n_trades"] > 0 and result["total_return_pct"] > best_return:
            best_return = result["total_return_pct"]
            best_weights = list(combo)
    
    return best_weights

# Use optimized weights and threshold on test set
ensemble = Ensemble(models, best_weights)
result = run_backtest(ensemble, test_ds, df, config, 
                    threshold=best_threshold, start_idx=test_start)

{
  "fold": 1,
  "weights": [0.4, 0.1, 0.5],
  "threshold": 0.3,
  "return_pct": 2.61,
  "drawdown_pct": -2.96,
  "win_rate_pct": 35.8,
  "profit_factor": 1.16
}