strategy-workflow（策略工作流程）

Strategy Workflow

Comprehensive strategy development workflow for quantitative trading, from hypothesis to validated production deployment.

Overview

This skill provides a complete framework for developing, testing, and validating trading strategies. It supports:

• Hypothesis-driven strategy development
• Multi-GPU backtesting on Vast.ai
• Bayesian hyperparameter optimization with Optuna
• Walk-forward validation and out-of-sample testing
• Automated tearsheet generation

Entry Points

Control Plane (Swarm Orchestration)

Always-on watchdog loops that manage hardware utilization and self-healing:

bash scripts/start_swarm_watchdogs.sh

For local environments, set explicit paths:

VENV_PATH=/path/to/.venv/bin/activate \
RESULTS_ROOT=/path/to/backtests \
STATE_ROOT=/path/to/backtests/state \
LOGS_ROOT=/path/to/backtests/logs \
bash scripts/start_swarm_watchdogs.sh

Work Plane (Parallel Execution)

Unified wrapper that starts control plane and launches parallel work:

scripts/backtest-optimize --parallel

Multi-GPU, multi-symbol execution:

cd WORKFLOW && ./launch_parallel.sh

Single-Symbol Pipeline

For focused optimization on a single asset:

scripts/backtest-optimize --single --symbol SYMBOL --engine native --prescreen 50000 --paths 1000 --by-regime

Strategy Development

1. Hypothesis Formulation

Define your strategy hypothesis in measurable terms:

• What market inefficiency are you exploiting?
• What is the expected holding period?
• What are the entry/exit conditions?
• What is the target risk-adjusted return?

2. Feature Selection

Identify relevant features for signal generation:

• Price-based (OHLCV, returns, volatility)
• Technical indicators (EMA, RSI, Bollinger Bands)
• Multi-timeframe features (MTF resampling)
• Volume analysis (PVSRA, VWAP)
• Market microstructure (order flow, spread)

3. Signal Generation

Convert features into actionable signals:

• Directional bias (trend following, mean reversion)
• Entry conditions (threshold crossings, pattern recognition)
• Exit conditions (take-profit, stop-loss, trailing stops)
• Position sizing rules

4. Position Sizing

Implement risk-aware position sizing:

• Fixed fractional
• Kelly criterion
• Volatility-adjusted
• Regime-dependent scaling

Backtesting

Pre-Flight Validation

MANDATORY before every optimization run:

python validation.py --check-all --data-path DATA_PATH --symbol SYMBOL

Validation checks:

• Data >= 90 days with no gaps/NaN
• Min trades >= 30 for statistical significance
• MTF resampling implemented correctly
• No look-ahead bias

Multi-GPU Execution on Vast.ai

Deploy to cloud GPU instances for large-scale parameter sweeps:

# Copy workflow files
scp -P PORT workflow_files root@HOST:/root/WORKFLOW/

# Run optimization
ssh -p PORT root@HOST "cd /root/WORKFLOW && python optimize_strategy.py \
  --data-path /root/data --symbol SYMBOL --mode aggressive \
  --prescreen 5000 --paths 200 --engine gpu"

Prescreening with Vectorized Backtests

Phase 0: GPU-accelerated parameter screening:

• Generate N random parameter combinations
• Batch evaluate on GPU
• Filter by minimum trades (30+)
• Return top K by Sharpe ratio

Performance baseline (RTX 5090, 730d lookback, 250k combos): ~4s per mode.

Full Backtests with NautilusTrader

Phase 1: Event-driven backtesting for top candidates:

• High-fidelity simulation with realistic execution
• Slippage and commission modeling
• Multi-asset portfolio backtests

Parameter Optimization

Optuna for Hyperparameter Search

Phase 2: Bayesian optimization with warm-start from prescreening:

import optuna

study = optuna.create_study(
    direction="maximize",
    sampler=optuna.samplers.TPESampler(seed=42),
    pruner=optuna.pruners.MedianPruner()
)

study.optimize(objective, n_trials=1000)

Grid Search vs Bayesian Optimization

Pruning Strategies

• MedianPruner: Prune if worse than median of completed trials
• PercentilePruner: Prune bottom X% of trials
• HyperbandPruner: Multi-fidelity optimization
• SuccessiveHalvingPruner: Aggressive early stopping

Distributed Optimization

For large-scale runs, use persistent storage:

# JournalStorage for multi-process
storage = optuna.storages.JournalStorage(
    optuna.storages.JournalFileStorage("journal.log")
)

# RDBStorage for distributed clusters
storage = optuna.storages.RDBStorage("postgresql://...")

Walk-Forward Validation

Rolling Window Validation

Slide the training/test window through time:

[Train 1][Test 1]
    [Train 2][Test 2]
        [Train 3][Test 3]

Parameters:

• train_window: Training period length
• test_window: Out-of-sample test length
• step_size: Window advancement increment

Anchored Walk-Forward

Expand training window while sliding test window:

[Train 1      ][Test 1]
[Train 1 + 2      ][Test 2]
[Train 1 + 2 + 3      ][Test 3]

Use when historical regime diversity improves model robustness.

Epoch Selection Criteria

Intelligent selection of training periods:

• Regime-aware: Match training regimes to expected deployment conditions
• Volatility-adjusted: Include both high and low volatility periods
• Event-inclusive: Ensure major market events are represented
• Recency-weighted: Emphasize recent data while maintaining diversity

Out-of-Sample Testing

Final validation phase:

• Hold out 20-30% of data for final OOS test
• No parameter tuning on OOS data
• Monte Carlo stress testing
• Regime-conditional performance analysis

SLOs and Guardrails

Utilization Targets

• CPU utilization target: >= 70%
• GPU utilization target: >= 70%
• No silent GPU fallback for GPU sweeps

Hardware Watchdog Hooks

Enforced by:

• hooks/hardware_capacity_watchdog.py
• scripts/process_auditor.py

Capacity Monitoring

Control plane loops monitor:

• Worker health and liveness
• Progress artifact freshness
• Resource utilization
• Job queue depth

Self-healing actions:

• Automatic worker restart on crash
• Fill lanes for underutilized resources
• Cooldown guardrails to prevent thrashing

Tearsheet Generation

Generate QuantStats-style performance reports:

scripts/generate-tearsheet STRATEGY_NAME \
  --trades /path/to/trades.csv \
  --capital 10000 \
  --output ./tearsheets

See tearsheet-generator skill for detailed visualization options.

Multi-Provider Orchestration

PAL MCP Integration

Attach PAL as an MCP server for research/consensus across multiple model providers:

• Config template: config/mcp/pal.mcp.json.example
• Docs: docs/reference/PAL_MCP_INTEGRATION.md
• Providers: OpenRouter, OpenAI, Anthropic, xAI, local models

Resources

Documentation

• VectorBT Documentation
• NautilusTrader Docs
• Optuna Documentation
• QuantStats

Project References

• config/workflow_defaults.yaml - Default configuration
• config/model_policy.yaml - Model policy (advisory)
• docs/guides/SWARM_OPTIMIZATION_RUNBOOK.md - Detailed runbook
• hooks/pipeline-hooks.md - Hook contracts
• docs/reference/VECTORBT_GRAPH_INGEST.md - VectorBT PRO integration

Results Structure

Backtests/optimizations/{SYMBOL}/{MODE}/
  best_sharpe/
    config.json      # Best Sharpe configuration
    metrics.json     # Performance metrics
  best_returns/
  lowest_drawdown/
  best_winrate/
  all_trials.json    # All Optuna trials
  phase0_top500.json # Prescreening results