foxhunt/docs/archive/agents/AGENT_C5_FEATURE_INTEGRATION_PLAN.md

Agent C5: UnifiedFeatureExtractor Integration Plan

Executive Summary

Critical Bug: UnifiedFeatureExtractor is initialized (line 311) but NEVER CALLED - backtesting uses local 8-feature extractor instead of production 256-feature system.

Impact:

• Backtesting uses 8 simplified features (price return, MA, volatility, volume, time)
• Production ML models trained on 256 features from UnifiedFeatureExtractor
• FEATURE MISMATCH → Model predictions will be invalid in backtesting

Solution: Wire UnifiedFeatureExtractor throughout backtesting service

---

1. Current Architecture (BROKEN)

DBN Time-Bars → StrategyEngine → LOCAL 8-feature extractor → Trade Signals
                                  (MLFeatureExtractor)

                 UnifiedFeatureExtractor (initialized, NEVER USED)
                 └─ Arc at line 311
                 └─ 0 call sites

Problem Files:

1. ml_strategy_engine.rs (Lines 72-173): Local 8-feature extractor
2. strategy_engine.rs (Line 311): UnifiedFeatureExtractor initialized but unused
3. All strategy implementations use hardcoded parameters, not features

---

2. Target Architecture (FIXED)

DBN Time-Bars → StrategyEngine → UnifiedFeatureExtractor (256 features)
                                  └─ Alternative bars support
                                  └─ Technical indicators (RSI, MACD, etc.)
                                  └─ Microstructure features

                                  ↓
                              Strategy Execution (with full feature context)
                                  ↓
                              Trade Signals

---

3. Implementation Steps

Phase 1: Replace Local Feature Extractor (Lines 72-218, ml_strategy_engine.rs)

Current:

pub struct MLFeatureExtractor {
    pub lookback_periods: usize,
    price_history: Vec<f64>,
    volume_history: Vec<f64>,
}

impl MLFeatureExtractor {
    pub fn extract_features(&mut self, market_data: &MarketData) -> Vec<f64> {
        // 8 hardcoded features
        // ...
        features.iter().map(|&f| f.tanh()).collect()
    }
}

Fixed:

// DELETE MLFeatureExtractor entirely (Lines 72-173)
// USE UnifiedFeatureExtractor from ml::features::extraction

impl MLPoweredStrategy {
    pub fn new(name: String, lookback_periods: usize) -> Self {
        let min_confidence_threshold = 0.6;
        let strategy = Arc::new(SharedMLStrategy::new(lookback_periods, min_confidence_threshold));

        // NEW: Initialize UnifiedFeatureExtractor
        let feature_config = FeatureExtractionConfig::default();
        let feature_extractor = Arc::new(UnifiedFeatureExtractor::new(feature_config));

        Self {
            name,
            strategy,
            feature_extractor, // NEW: Store for use
            model_performance: HashMap::new(),
            confidence_based_sizing: true,
            min_confidence_threshold,
        }
    }

    // NEW: Extract features using UnifiedFeatureExtractor
    pub fn extract_features(&self, market_data: &MarketData) -> Result<Vec<f64>> {
        // Convert MarketData to OHLCVBar
        let bar = OHLCVBar {
            timestamp: market_data.timestamp,
            open: market_data.open.to_f64().unwrap_or(0.0),
            high: market_data.high.to_f64().unwrap_or(0.0),
            low: market_data.low.to_f64().unwrap_or(0.0),
            close: market_data.close.to_f64().unwrap_or(0.0),
            volume: market_data.volume.to_f64().unwrap_or(0.0),
        };

        // Use UnifiedFeatureExtractor (256 features)
        let features = self.feature_extractor.extract_features(&[bar])?;
        Ok(features[0].to_vec())
    }
}

Phase 2: Wire Features into Strategy Execution (Lines 308-388, ml_strategy_engine.rs)

Current (execute method):

fn execute(&self, market_data: &MarketData, _portfolio: &Portfolio, parameters: &HashMap<String, String>) -> Result<Vec<TradeSignal>> {
    // Simplified features WITHOUT updating history
    let features = [
        (price - 100.0) / 100.0,
        (volume - 1000.0) / 1000.0,
        0.0, 0.0, 0.0, 0.0, 0.0
    ];

    // Static DQN-like logic
    // ...
}

Fixed (execute method):

fn execute(&self, market_data: &MarketData, _portfolio: &Portfolio, parameters: &HashMap<String, String>) -> Result<Vec<TradeSignal>> {
    let mut signals = Vec::new();

    // Extract 256 features using UnifiedFeatureExtractor
    let features = self.extract_features(market_data)?;

    // Use shared ML strategy for prediction (async in sync context - use block_on)
    let runtime = tokio::runtime::Runtime::new()?;
    let predictions = runtime.block_on(async {
        let price = market_data.close.to_f64().unwrap_or(0.0);
        let volume = market_data.volume.to_f64().unwrap_or(0.0);
        let timestamp = market_data.timestamp;
        self.strategy.get_ensemble_prediction(price, volume, timestamp).await
    })?;

    // Calculate ensemble vote
    if let Some((ensemble_prediction, ensemble_confidence)) = self.calculate_ensemble_vote(&predictions) {
        let min_confidence = parameters.get("min_confidence")
            .and_then(|s| s.parse::<f64>().ok())
            .unwrap_or(self.min_confidence_threshold);

        if ensemble_confidence >= min_confidence {
            // Generate signals based on ML prediction
            if ensemble_prediction > 0.6 {
                signals.push(TradeSignal {
                    symbol: market_data.symbol.clone(),
                    side: TradeSide::Buy,
                    quantity: self.compute_position_size(ensemble_confidence),
                    strength: Decimal::try_from(ensemble_confidence).unwrap_or(Decimal::ONE / Decimal::from(2)),
                    reason: format!("ML ensemble prediction: {:.3} (confidence: {:.3})", ensemble_prediction, ensemble_confidence),
                    features: Some(self.features_to_map(&features)), // NEW: Include features
                    news_events: None,
                });
            } else if ensemble_prediction < 0.4 {
                signals.push(TradeSignal {
                    symbol: market_data.symbol.clone(),
                    side: TradeSide::Sell,
                    quantity: self.compute_position_size(ensemble_confidence),
                    strength: Decimal::try_from(ensemble_confidence).unwrap_or(Decimal::ONE / Decimal::from(2)),
                    reason: format!("ML ensemble prediction: {:.3} (confidence: {:.3})", ensemble_prediction, ensemble_confidence),
                    features: Some(self.features_to_map(&features)), // NEW: Include features
                    news_events: None,
                });
            }
        }
    }

    Ok(signals)
}

// NEW: Helper to convert features to HashMap
fn features_to_map(&self, features: &[f64]) -> HashMap<String, f64> {
    let mut map = HashMap::new();
    for (i, &val) in features.iter().enumerate() {
        map.insert(format!("feature_{}", i), val);
    }
    map
}

// NEW: Confidence-based position sizing
fn compute_position_size(&self, confidence: f64) -> Decimal {
    if self.confidence_based_sizing {
        Decimal::try_from(confidence * 1000.0).unwrap_or(Decimal::from(100))
    } else {
        Decimal::from(100)
    }
}

Phase 3: Fix ML Prediction Feedback Loop (Lines 473-486, ml_strategy_engine.rs)

Current (validate but DON'T apply predictions):

for (i, data_point) in market_data.into_iter().enumerate() {
    let predictions = ml_strategy.get_ensemble_prediction(&data_point).await?;

    if let Some((ensemble_prediction, ensemble_confidence)) = ml_strategy.calculate_ensemble_vote(&predictions) {
        // Validate predictions BUT DON'T GENERATE TRADES
        if let Some(prev_price) = previous_price {
            ml_strategy.validate_predictions(&predictions, actual_return).await;
        }
    }

    // NO TRADE GENERATION HERE!
}

Fixed (actually use predictions):

for (i, data_point) in market_data.into_iter().enumerate() {
    // Extract features
    let features = ml_strategy.extract_features(&data_point)?;

    // Get ML predictions
    let predictions = ml_strategy.get_ensemble_prediction(&data_point).await?;

    if let Some((ensemble_prediction, ensemble_confidence)) = ml_strategy.calculate_ensemble_vote(&predictions) {
        // NEW: Generate trade signals based on ML predictions
        let mut parameters = HashMap::new();
        parameters.insert("min_confidence".to_string(), "0.6".to_string());

        let signals = ml_strategy.execute(&data_point, &Portfolio::default(), &parameters)?;

        // Execute signals and track trades
        for signal in signals {
            let trade = execute_signal(&signal, &data_point)?;
            trades.push(trade);
        }

        // Validate predictions against actual outcome
        if let Some(prev_price) = previous_price {
            let current_price = data_point.close.to_f64().unwrap_or(prev_price);
            let actual_return = (current_price - prev_price) / prev_price;
            ml_strategy.validate_predictions(&predictions, actual_return).await;
        }
    }

    previous_price = Some(data_point.close.to_f64().unwrap_or(0.0));
}

Phase 4: Alternative Bars Support (Future Wave B Integration)

Preparation (add to struct):

pub struct MLPoweredStrategy {
    name: String,
    strategy: Arc<SharedMLStrategy>,
    feature_extractor: Arc<UnifiedFeatureExtractor>, // NEW
    // Alternative bar samplers (Wave B)
    tick_bar_sampler: Option<TickBarSampler>,
    volume_bar_sampler: Option<VolumeBarSampler>,
    dollar_bar_sampler: Option<DollarBarSampler>,
    model_performance: HashMap<String, MLModelPerformance>,
    confidence_based_sizing: bool,
    min_confidence_threshold: f64,
}

// NEW: Alternative bar configuration
pub fn with_alternative_bars(mut self, bar_type: AlternativeBarType) -> Self {
    match bar_type {
        AlternativeBarType::Tick(threshold) => {
            self.tick_bar_sampler = Some(TickBarSampler::new(threshold));
        }
        AlternativeBarType::Volume(threshold) => {
            self.volume_bar_sampler = Some(VolumeBarSampler::new(threshold));
        }
        AlternativeBarType::Dollar(threshold) => {
            self.dollar_bar_sampler = Some(DollarBarSampler::new(threshold));
        }
    }
    self
}

---

4. Testing Strategy

Unit Tests (ml_strategy_engine.rs)

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_feature_extraction_uses_unified_extractor() {
        let strategy = MLPoweredStrategy::new("test".to_string(), 20);

        let market_data = MarketData {
            symbol: "ES.FUT".to_string(),
            timestamp: chrono::Utc::now(),
            open: Decimal::from(4500),
            high: Decimal::from(4510),
            low: Decimal::from(4495),
            close: Decimal::from(4505),
            volume: Decimal::from(10000),
            timeframe: TimeFrame::Minute(1),
        };

        let features = strategy.extract_features(&market_data).unwrap();

        // Verify 256 features (not 8)
        assert_eq!(features.len(), 256, "Should use UnifiedFeatureExtractor (256 features)");

        // Verify no NaN/Inf
        for (i, &val) in features.iter().enumerate() {
            assert!(val.is_finite(), "Feature {} is not finite: {}", i, val);
        }
    }

    #[tokio::test]
    async fn test_ml_predictions_generate_trades() {
        let mut strategy = MLPoweredStrategy::new("test".to_string(), 20);

        // Create synthetic data
        let data: Vec<MarketData> = (0..100).map(|i| {
            MarketData {
                symbol: "ES.FUT".to_string(),
                timestamp: chrono::Utc::now() + chrono::Duration::hours(i),
                open: Decimal::from(4500 + i),
                high: Decimal::from(4510 + i),
                low: Decimal::from(4495 + i),
                close: Decimal::from(4505 + i),
                volume: Decimal::from(10000),
                timeframe: TimeFrame::Minute(1),
            }
        }).collect();

        let mut trades = Vec::new();

        for data_point in data {
            let predictions = strategy.get_ensemble_prediction(&data_point).await.unwrap();

            if let Some((pred, conf)) = strategy.calculate_ensemble_vote(&predictions) {
                let mut params = HashMap::new();
                params.insert("min_confidence".to_string(), "0.5".to_string());

                let signals = strategy.execute(&data_point, &Portfolio::default(), &params).unwrap();
                trades.extend(signals);
            }
        }

        // Verify trades were generated
        assert!(!trades.is_empty(), "ML predictions should generate trades");
    }
}

Integration Tests (backtesting_service/tests/)

#[tokio::test]
async fn test_ml_backtest_with_unified_features() {
    // Load real DBN data
    let dbn_source = DbnDataSource::new(...).await.unwrap();
    let bars = dbn_source.load_ohlcv_bars("ES.FUT").await.unwrap();

    // Create ML strategy engine
    let config = BacktestingStrategyConfig::default();
    let storage = Arc::new(StorageManager::new(...));
    let mut engine = MLStrategyEngine::new(&config, storage).await.unwrap();

    // Execute backtest
    let context = BacktestContext {
        id: "test".to_string(),
        strategy_name: "ml_ensemble".to_string(),
        symbols: vec!["ES.FUT".to_string()],
        started_at: bars[0].timestamp.timestamp_nanos_opt().unwrap(),
        completed_at: Some(bars.last().unwrap().timestamp.timestamp_nanos_opt().unwrap()),
    };

    let (trades, model_perf) = engine.execute_ml_backtest(&context).await.unwrap();

    // Verify features were used
    assert!(!trades.is_empty(), "Should generate trades");

    // Verify model performance tracking
    assert!(!model_perf.is_empty(), "Should track model performance");

    // Verify features are 256-dimensional
    for trade in &trades {
        if let Some(features) = &trade.features {
            assert_eq!(features.len(), 256, "Trades should use 256 features");
        }
    }
}

---

5. Performance Expectations

Metric	Before (8 features)	After (256 features)	Target
Feature Extraction	2μs/bar	10-20μs/bar	<100μs
ML Prediction	N/A (broken)	200μs (DQN)	<1ms
Backtest Speed	5s (1K bars)	8-10s (1K bars)	<30s
Memory Usage	100MB	200-300MB	<1GB
Feature Accuracy	❌ 8 features	✅ 256 features	256

---

6. Validation Checklist

• UnifiedFeatureExtractor imported and used (not MLFeatureExtractor)
• Feature extraction produces 256-dimensional vectors
• ML predictions actually generate trade signals
• Trade signals include feature context
• Model performance tracked and validated
• Unit tests verify 256 features (not 8)
• Integration tests use real DBN data
• Performance metrics tracked (<100μs feature extraction)
• Alternative bars prepared (Wave B integration ready)
• Documentation updated

---

7. Files to Modify

1. services/backtesting_service/src/ml_strategy_engine.rs (PRIMARY)

   • DELETE: MLFeatureExtractor (Lines 72-173)
   • ADD: UnifiedFeatureExtractor integration
   • FIX: execute() method to use features
   • FIX: execute_ml_backtest() to generate trades

2. services/backtesting_service/src/strategy_engine.rs (SECONDARY)

   • VERIFY: UnifiedFeatureExtractor usage (line 311)
   • ADD: Feature extraction calls to strategies

3. services/backtesting_service/tests/ml_strategy_backtest_test.rs (NEW)

   • ADD: Feature extraction validation tests
   • ADD: 256-feature verification tests

---

8. Risk Mitigation

Risk 1: Performance degradation (256 features vs 8)

• Mitigation: Benchmark feature extraction (<100μs target)
• Fallback: Parallel feature extraction for multiple bars

Risk 2: Feature mismatch between training/backtesting

• Mitigation: Validate feature vectors match training data
• Test: Load saved model, run inference with backtesting features

Risk 3: Breaking existing backtests

• Mitigation: Keep local feature extractor as fallback (feature flag)
• Rollback: Revert to 8-feature extractor if issues arise

---

9. Success Criteria

✅ UnifiedFeatureExtractor called (not initialized-only) ✅ 256 features extracted per bar ✅ ML predictions generate actual trades ✅ Trade signals include feature context ✅ Model performance validated ✅ Tests pass (100%) ✅ Performance targets met (<100μs extraction) ✅ Documentation updated

---

10. Timeline

Phase 1 (2 hours): Replace local feature extractor Phase 2 (3 hours): Wire features into strategy execution Phase 3 (2 hours): Fix ML prediction feedback loop Phase 4 (1 hour): Testing and validation Total: 8 hours (1 day)

---

11. Next Steps (Post-Integration)

1. Wave B Integration: Alternative bars (tick, volume, dollar)
2. Wave C Integration: Fractional differentiation, meta-labeling
3. Feature Comparison: Benchmark 8-feature vs 256-feature backtest results
4. Production Deployment: Live trading with unified feature extraction

---

Agent C5 Status: 🟡 READY TO IMPLEMENT Blockers: None Dependencies: UnifiedFeatureExtractor (✅ complete, ml/src/features/extraction.rs) Timeline: 8 hours