popov/gogo2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
259ee9b14af8fbe5f03b51a13dedbc9185b3bea4
gogo2/docs/BASE_DATA_INPUT_USAGE_AUDIT.md
Dobromir Popov 7ddf98bf18 improved data structure
2025-10-31 00:44:08 +02:00

33 KiB
Raw Blame History

BaseDataInput Usage Audit

Executive Summary

Date: 2025-10-30
Status: ⚠️ Partial Adoption - Migration Needed

Key Findings

  1. ✅ BaseDataInput is the official standard defined in core/data_models.py
  2. ⚠️ Not all models use it - some use alternative implementations
  3. ⚠️ Legacy interface exists - ModelInputData in core/unified_model_data_interface.py
  4. ✅ Feature vector is well-defined - Fixed 7,850 dimensions
  5. ✅ Extensibility is supported - Can add features with proper planning

Current Adoption Status

✅ Models Using BaseDataInput Correctly

Component File Status Notes
StandardizedCNN NN/models/standardized_cnn.py ✅ Full Uses get_feature_vector(), expects 7,834 features
Orchestrator core/orchestrator.py ✅ Full Builds via data_provider.build_base_data_input()
UnifiedTrainingManager core/unified_training_manager_v2.py ✅ Full Converts to DQN state via get_feature_vector()
Dashboard web/clean_dashboard.py ✅ Full Creates BaseDataInput for predictions
StandardizedDataProvider core/standardized_data_provider.py ✅ Full Primary builder of BaseDataInput
DataProvider core/data_provider.py ✅ Full Has build_base_data_input() method

⚠️ Components Using Alternative Implementations

Component File Current Method Issue
RealtimeRLCOBTrader core/realtime_rl_cob_trader.py Custom _extract_features() Not using BaseDataInput
UnifiedModelDataInterface core/unified_model_data_interface.py ModelInputData class Legacy alternative interface
COBY Adapter COBY/integration/orchestrator_adapter.py MockBaseDataInput Temporary mock implementation
EnhancedRLTrainingAdapter core/enhanced_rl_training_adapter.py Fallback feature extraction Has fallback but should enforce BaseDataInput

❓ Models Not Yet Audited

These models need to be checked for BaseDataInput usage:

  • NN/models/enhanced_cnn.py - May use direct tensor input
  • NN/models/dqn_agent.py - May use custom state representation
  • NN/models/cob_rl_model.py - May use COB-specific features
  • NN/models/cnn_model.py - May use legacy feature extraction
  • NN/models/advanced_transformer_trading.py - May use custom input format

Alternative Implementations Found

1. ModelInputData (Legacy)

Location: core/unified_model_data_interface.py

Structure:

@dataclass
class ModelInputData:
    symbol: str
    timestamp: datetime
    current_price: float
    candles_1m: Optional[np.ndarray]
    candles_1s: Optional[np.ndarray]
    candles_5m: Optional[np.ndarray]
    technical_indicators: Optional[np.ndarray]
    order_book_features: Optional[np.ndarray]
    volume_profile: Optional[np.ndarray]
    volatility_regime: float
    trend_strength: float
    data_quality_score: float
    feature_count: int

Issues:

  • Different structure than BaseDataInput
  • No fixed feature size
  • No get_feature_vector() method
  • Creates inconsistency across models

Recommendation: 🔴 Deprecate and migrate to BaseDataInput

2. MockBaseDataInput (COBY Adapter)

Location: COBY/integration/orchestrator_adapter.py

Purpose: Temporary adapter to provide BaseDataInput interface for COBY data

Issues:

  • Mock implementation, not real BaseDataInput
  • Only provides get_feature_vector() method
  • Missing other BaseDataInput fields

Recommendation: 🟡 Replace with proper BaseDataInput construction

3. Custom Feature Extraction

Location: core/realtime_rl_cob_trader.py

Method: _extract_features(symbol, data)

Issues:

  • Bypasses BaseDataInput entirely
  • Custom feature engineering
  • Inconsistent with other models

Recommendation: 🔴 Migrate to BaseDataInput

Feature Vector Extensibility Analysis

Current Structure (7,850 features)

Component Features Extensible? Notes
OHLCV ETH (4 timeframes) 6,000 ⚠️ Limited Fixed 300 frames × 4 timeframes
OHLCV BTC (1s) 1,500 ⚠️ Limited Fixed 300 frames
COB Features 200 ✅ Yes Has padding space
Technical Indicators 100 ✅ Yes Has padding space
Last Predictions 45 ✅ Yes Can add more models
Position Info 5 ✅ Yes Can add more fields

Updated Feature Vector Breakdown

Standard Mode (7,850 features - Default)

Component Features Description
OHLCV ETH (4 timeframes) 6,000 300 frames × 4 timeframes × 5 values (OHLCV)
OHLCV BTC (1s) 1,500 300 frames × 5 values (OHLCV)
COB Features 200 Price buckets + MAs + heatmap aggregates
Technical Indicators 100 Calculated indicators
Last Predictions 45 Cross-model predictions
Position Info 5 Position state
TOTAL 7,850 Backward compatible

Enhanced Mode (10,850 features - With Candle TA)

Component Features Description
OHLCV ETH (4 timeframes) 18,000 300 frames × 4 timeframes × 15 values (OHLCV + 10 TA)
OHLCV BTC (1s) 4,500 300 frames × 15 values (OHLCV + 10 TA)
COB Features 200 Price buckets + MAs + heatmap aggregates
Technical Indicators 100 Calculated indicators
Last Predictions 45 Cross-model predictions
Position Info 5 Position state
TOTAL 22,850 With enhanced candle TA

Note: The enhanced mode actually produces 22,850 features, not 10,850. This is a significant increase and should be carefully evaluated.

Extension Strategies

Strategy 1: Use Existing Padding Space (No Model Retraining)

Available Space:

  • COB Features: ~30-50 features of padding
  • Technical Indicators: ~20-40 features of padding
  • Last Predictions: ~10-20 features of padding

Total Available: ~60-110 features

Best For: Small additions like sentiment scores, additional indicators

Example Implementation:

# Add sentiment to technical indicators (uses existing padding)
technical_indicators['twitter_sentiment'] = 0.65
technical_indicators['news_sentiment'] = 0.72
technical_indicators['fear_greed_index'] = 45.0

Strategy 2: Use Enhanced Candle TA Features (Requires Model Retraining)

Process:

  1. Enable include_candle_ta=True in get_feature_vector()
  2. Update model input layer to accept 22,850 features
  3. Retrain models with enhanced features
  4. Validate improved performance

Best For: Models that benefit from pattern recognition (CNN, Transformer)

Pros:

  • Rich pattern information
  • Relative sizing context
  • No manual feature engineering needed

Cons:

  • 3x increase in feature count
  • Longer training time
  • More memory usage

Strategy 3: Selective TA Features (Balanced Approach)

Process:

  1. Extract only most important TA features
  2. Add to existing padding space
  3. Minimal model architecture changes

Example:

# Add top 5 TA features per candle to technical indicators
for bar in ohlcv_1m[-10:]:  # Last 10 candles
    technical_indicators[f'candle_{i}_bullish'] = 1.0 if bar.is_bullish else 0.0
    technical_indicators[f'candle_{i}_body_ratio'] = bar.get_body_to_range_ratio()
    technical_indicators[f'candle_{i}_pattern'] = encode_pattern(bar.get_candle_pattern())

Best For: Quick wins without major retraining

Strategy 4: Increase FIXED_FEATURE_SIZE (Custom Additions)

Process:

  1. Increase FIXED_FEATURE_SIZE constant
  2. Add new feature extraction logic
  3. Retrain all models with new feature size
  4. Update model architectures if needed

Best For: Major additions like new data sources, multi-symbol support

Strategy 5: Feature Compression (Advanced)

Process:

  1. Use dimensionality reduction (PCA, autoencoders)
  2. Compress existing features to make room
  3. Add new features in freed space
  4. Retrain models with compressed features

Best For: Adding many features while maintaining size

Example:

# Compress OHLCV from 6000 to 3000 features using PCA
from sklearn.decomposition import PCA
pca = PCA(n_components=3000)
compressed_ohlcv = pca.fit_transform(ohlcv_features)
# Now have 3000 features free for new data

Enhanced Candle TA Features (NEW)

Overview

The OHLCVBar class has been enhanced with comprehensive technical analysis features for improved pattern recognition and feature engineering.

New Candle Properties

Property Type Description
body_size float Absolute size of candle body (abs(close - open))
upper_wick float Size of upper shadow (high - max(open, close))
lower_wick float Size of lower shadow (min(open, close) - low)
total_range float Total high-low range
is_bullish bool True if close > open (hollow/green candle)
is_bearish bool True if close < open (solid/red candle)
is_doji bool True if body < 10% of total range

New Methods

1. Ratio Calculations

bar.get_body_to_range_ratio()      # Body as % of total range (0.0-1.0)
bar.get_upper_wick_ratio()         # Upper wick as % of range (0.0-1.0)
bar.get_lower_wick_ratio()         # Lower wick as % of range (0.0-1.0)

2. Relative Sizing

# Compare to last 10 candles
reference_bars = ohlcv_list[-10:]
relative_size = bar.get_relative_size(reference_bars, method='avg')
# Returns: 1.0 = same size, >1.0 = larger, <1.0 = smaller

Methods available:

  • 'avg': Compare to average of reference bars (default)
  • 'max': Compare to maximum of reference bars
  • 'median': Compare to median of reference bars

3. Pattern Recognition

pattern = bar.get_candle_pattern()

Patterns detected:

  • 'doji': Very small body (<10% of range)
  • 'hammer': Small body at top, long lower wick
  • 'shooting_star': Small body at bottom, long upper wick
  • 'spinning_top': Small body, both wicks present
  • 'marubozu_bullish': Large bullish body (>90% of range)
  • 'marubozu_bearish': Large bearish body (>90% of range)
  • 'standard': Regular candle

4. Complete TA Feature Set

ta_features = bar.get_ta_features(reference_bars)

Returns dictionary with 22 features:

  • Basic properties: is_bullish, is_bearish, is_doji
  • Size ratios: body_to_range_ratio, upper_wick_ratio, lower_wick_ratio
  • Normalized sizes: body_size_pct, upper_wick_pct, lower_wick_pct, total_range_pct
  • Volume analysis: volume_per_range
  • Relative sizing: relative_size_avg, relative_size_max, relative_size_median
  • Pattern encoding: pattern_doji, pattern_hammer, pattern_shooting_star, pattern_spinning_top, pattern_marubozu_bullish, pattern_marubozu_bearish, pattern_standard

Integration with BaseDataInput

The enhanced features are available via get_feature_vector():

# Standard mode (7,850 features - backward compatible)
features = base_data.get_feature_vector(include_candle_ta=False)

# Enhanced mode (10,850 features - includes candle TA)
features = base_data.get_feature_vector(include_candle_ta=True)

Enhanced mode adds 3,000 features:

  • ETH: 300 frames × 4 timeframes × 10 TA features = 12,000 → 18,000 features
  • BTC: 300 frames × 10 TA features = 1,500 → 4,500 features
  • Total increase: 3,000 features

10 TA features per candle:

  1. is_bullish (0 or 1)
  2. body_to_range_ratio (0.0-1.0)
  3. upper_wick_ratio (0.0-1.0)
  4. lower_wick_ratio (0.0-1.0)
  5. body_size_pct (% of close price)
  6. total_range_pct (% of close price)
  7. relative_size_avg (vs last 10 candles)
  8. pattern_doji (0 or 1)
  9. pattern_hammer (0 or 1)
  10. pattern_shooting_star (0 or 1)

Migration Strategy for Enhanced Features

Phase 1: Backward Compatible (Current)

  • Default mode remains 7,850 features
  • No model retraining required
  • Enhanced features available opt-in

Phase 2: Gradual Adoption (Recommended)

  1. Test with new models first

    # New model training
base_data = data_provider.build_base_data_input('ETH/USDT')
features = base_data.get_feature_vector(include_candle_ta=True)

  2. Compare performance

    • Train identical model with/without TA features
    • Measure accuracy improvement
    • Assess computational overhead

  3. Migrate high-value models

    • Start with CNN models (benefit most from pattern recognition)
    • Then RL agents (benefit from relative sizing)
    • Finally transformers (benefit from pattern encoding)

Phase 3: Full Migration (If Beneficial)

  • Make include_candle_ta=True the default
  • Update all model architectures for 10,850 features
  • Retrain all models
  • Update documentation

Performance Impact

Computation Time:

  • get_ta_features(): ~0.1 ms per candle
  • Total overhead for 1,500 candles: ~150 ms
  • Recommendation: Cache TA features in OHLCVBar when created

Memory Impact:

  • Additional 3,000 float32 values = 12 KB per feature vector
  • Negligible for modern systems

Model Training:

  • More features = longer training time (~20-30% increase)
  • But potentially better accuracy and pattern recognition

Usage Examples

Example 1: Analyze Single Candle

from core.data_models import OHLCVBar
from datetime import datetime

bar = OHLCVBar(
    symbol='ETH/USDT',
    timestamp=datetime.now(),
    open=2000.0,
    high=2050.0,
    low=1990.0,
    close=2040.0,
    volume=1000.0,
    timeframe='1m'
)

# Check candle type
print(f"Bullish: {bar.is_bullish}")  # True
print(f"Pattern: {bar.get_candle_pattern()}")  # 'standard'

# Analyze structure
print(f"Body ratio: {bar.get_body_to_range_ratio():.2f}")  # 0.67
print(f"Upper wick: {bar.get_upper_wick_ratio():.2f}")  # 0.17
print(f"Lower wick: {bar.get_lower_wick_ratio():.2f}")  # 0.17

Example 2: Compare Candle Sizes

# Get last 10 candles
recent_bars = base_data.ohlcv_1m[-10:]
current_bar = base_data.ohlcv_1m[-1]

# Check if current candle is unusually large
relative_size = current_bar.get_relative_size(recent_bars[:-1], method='avg')
if relative_size > 2.0:
    print("Current candle is 2x larger than average!")

Example 3: Pattern Detection

# Scan for specific patterns
for bar in base_data.ohlcv_1m[-50:]:
    pattern = bar.get_candle_pattern()
    if pattern in ['hammer', 'shooting_star']:
        print(f"{bar.timestamp}: {pattern} detected at {bar.close}")

Example 4: Full TA Feature Extraction

# Get complete TA features for model input
reference_bars = base_data.ohlcv_1m[-10:-1]
current_bar = base_data.ohlcv_1m[-1]

ta_features = current_bar.get_ta_features(reference_bars)
print(f"Features: {len(ta_features)}")  # 22 features
print(f"Is doji: {ta_features['is_doji']}")
print(f"Relative size: {ta_features['relative_size_avg']:.2f}")

Recommendations

Immediate Actions (Priority 1)

  1. ✅ COMPLETED: Enhanced OHLCVBar with TA features

    • Added candle pattern recognition
    • Added relative sizing calculations
    • Added body/wick ratio analysis
    • Integrated with get_feature_vector()

  2. ✅ COMPLETED: Proper OHLCV normalization

    • All OHLCV data normalized to 0-1 range by default
    • Uses daily (longest timeframe) min/max for primary symbol
    • Independent normalization for BTC reference symbol
    • Cached normalization bounds for performance
    • Easy denormalization via NormalizationBounds class
    • See docs/NORMALIZATION_GUIDE.md for details

  3. Audit all models for BaseDataInput usage

    • Check each model in NN/models/
    • Document current input method
    • Create migration plan

  4. Test enhanced TA features

    • Train test model with include_candle_ta=True
    • Compare accuracy vs standard features
    • Measure performance impact
    • Document findings

  5. Deprecate ModelInputData

    • Add deprecation warnings
    • Create migration guide
    • Set sunset date (e.g., 3 months)

  6. Fix RealtimeRLCOBTrader

    • Migrate to BaseDataInput
    • Remove custom _extract_features()
    • Test thoroughly

  7. Replace MockBaseDataInput

    • Implement proper BaseDataInput construction in COBY adapter
    • Remove mock implementation
    • Validate integration

Short-term Actions (Priority 2)

  1. Standardize all model interfaces

    • Ensure all models accept BaseDataInput
    • Update model_interfaces.py
    • Add type hints

  2. Add validation tests

    • Test feature vector size for all models
    • Test BaseDataInput validation
    • Test with missing data

  3. Document extension process

    • Create step-by-step guide
    • Provide code examples
    • Document best practices

Long-term Actions (Priority 3)

  1. Implement feature versioning

    • Add version field to BaseDataInput
    • Support multiple feature vector versions
    • Enable gradual migration

  2. Add feature importance tracking

    • Track which features are used by each model
    • Identify unused features
    • Optimize feature extraction

  3. Research feature compression

    • Evaluate dimensionality reduction techniques
    • Test impact on model performance
    • Implement if beneficial

Migration Checklist

For Each Model Not Using BaseDataInput

  • Identify current input method
  • Document current feature extraction
  • Create BaseDataInput adapter
  • Update model interface
  • Add unit tests
  • Test with real data
  • Validate predictions match previous implementation
  • Deploy to staging
  • Monitor performance
  • Deploy to production
  • Remove old implementation

For Adding New Features

  • Determine feature size needed
  • Choose extension strategy
  • Update BaseDataInput class
  • Update get_feature_vector() method
  • Update data provider
  • Add validation logic
  • Update documentation
  • Add unit tests
  • Test with all models
  • Retrain models if needed
  • Deploy changes

For Adopting Enhanced Candle TA Features

  • Review candle TA feature documentation
  • Test with single model first (recommend CNN)
  • Compare accuracy: standard vs enhanced features
  • Measure performance impact (training time, inference speed)
  • Update model architecture for 22,850 features
  • Retrain model with include_candle_ta=True
  • Validate predictions are reasonable
  • A/B test in paper trading
  • Monitor for overfitting
  • Document results and learnings
  • Decide: rollout to other models or revert
  • Update production configuration

Testing Requirements

Unit Tests

# Test feature vector size
def test_feature_vector_size():
    base_data = create_test_base_data_input()
    features = base_data.get_feature_vector()
    assert len(features) == 7850

# Test with missing data
def test_feature_vector_with_missing_data():
    base_data = BaseDataInput(symbol='ETH/USDT', timestamp=datetime.now())
    features = base_data.get_feature_vector()
    assert len(features) == 7850
    assert not np.isnan(features).any()

# Test validation
def test_validation():
    base_data = create_test_base_data_input()
    assert base_data.validate() == True

Integration Tests

# Test all models with BaseDataInput
def test_all_models_with_base_data_input():
    orchestrator = create_test_orchestrator()
    base_data = orchestrator.data_provider.build_base_data_input('ETH/USDT')
    
    # Test CNN
    cnn_output = orchestrator.cnn_model.predict_from_base_input(base_data)
    assert isinstance(cnn_output, ModelOutput)
    
    # Test RL
    rl_output = orchestrator.rl_agent.predict_from_base_input(base_data)
    assert isinstance(rl_output, ModelOutput)
    
    # Test Transformer
    transformer_output = orchestrator.transformer.predict_from_base_input(base_data)
    assert isinstance(transformer_output, ModelOutput)

Performance Impact

Current Performance

  • Building BaseDataInput: ~5-10 ms
  • get_feature_vector(): ~1-2 ms
  • Total overhead: ~6-12 ms per prediction

After Full Migration

  • Expected improvement: 10-20% faster
    • Reason: Eliminate duplicate feature extraction
    • Reason: Better caching opportunities
    • Reason: Consistent data flow

Memory Impact

  • Per BaseDataInput: ~2-5 MB
  • Per feature vector: ~31 KB
  • Recommendation: Cache BaseDataInput for 1-2 seconds

Conclusion

BaseDataInput is well-designed and mostly adopted, but full migration is needed to ensure system-wide consistency. The structure is extensible, but careful planning is required when adding features.

Next Steps:

  1. Complete model audit
  2. Migrate non-compliant models
  3. Deprecate alternative implementations
  4. Add comprehensive tests
  5. Document extension process

Timeline: 2-4 weeks for full migration

Appendix: Code Examples

Creating BaseDataInput

from core.data_models import BaseDataInput, OHLCVBar, COBData

# Via data provider (recommended)
base_data = data_provider.build_base_data_input('ETH/USDT')

# Manual construction (for testing)
base_data = BaseDataInput(
    symbol='ETH/USDT',
    timestamp=datetime.now(),
    ohlcv_1s=[...],  # List of OHLCVBar
    ohlcv_1m=[...],
    ohlcv_1h=[...],
    ohlcv_1d=[...],
    btc_ohlcv_1s=[...],
    cob_data=COBData(...),
    technical_indicators={...},
    pivot_points=[...],
    last_predictions={...},
    position_info={...}
)

Using BaseDataInput in Models

# CNN Model
def predict_from_base_input(self, base_input: BaseDataInput) -> ModelOutput:
    features = base_input.get_feature_vector()
    tensor = torch.tensor(features).unsqueeze(0).to(self.device)
    output = self.forward(tensor)
    return create_model_output(...)

# RL Agent
def act_from_base_input(self, base_input: BaseDataInput) -> int:
    state = base_input.get_feature_vector()
    return self.act(state, explore=False)

Extending BaseDataInput

# Add new field
@dataclass
class BaseDataInput:
    # ... existing fields ...
    sentiment_data: Dict[str, float] = field(default_factory=dict)

# Update get_feature_vector()
def get_feature_vector(self) -> np.ndarray:
    # ... existing code ...
    
    # Add sentiment features (use existing padding space)
    sentiment_features = [
        self.sentiment_data.get('twitter_sentiment', 0.0),
        self.sentiment_data.get('news_sentiment', 0.0),
    ]
    indicator_values.extend(sentiment_features)
    
    # ... rest of code ...

Implementation Guide: Enhanced Candle TA Features

Step-by-Step Integration

Step 1: Update Data Provider

Ensure your data provider creates OHLCVBar objects properly:

# In data_provider.py or standardized_data_provider.py

def _create_ohlcv_bar(self, row, symbol: str, timeframe: str) -> OHLCVBar:
    """Create OHLCVBar from data row"""
    return OHLCVBar(
        symbol=symbol,
        timestamp=row['timestamp'],
        open=float(row['open']),
        high=float(row['high']),
        low=float(row['low']),
        close=float(row['close']),
        volume=float(row['volume']),
        timeframe=timeframe
    )
    # TA features are computed on-demand via properties

Step 2: Test Candle Analysis

# test_candle_ta.py

from core.data_models import OHLCVBar
from datetime import datetime

def test_candle_properties():
    """Test basic candle properties"""
    bar = OHLCVBar(
        symbol='ETH/USDT',
        timestamp=datetime.now(),
        open=2000.0,
        high=2050.0,
        low=1990.0,
        close=2040.0,
        volume=1000.0,
        timeframe='1m'
    )
    
    assert bar.is_bullish == True
    assert bar.body_size == 40.0
    assert bar.upper_wick == 10.0
    assert bar.lower_wick == 10.0
    assert bar.total_range == 60.0
    assert 0.6 < bar.get_body_to_range_ratio() < 0.7
    
    print("✓ Candle properties working correctly")

def test_pattern_recognition():
    """Test pattern recognition"""
    # Doji
    doji = OHLCVBar('ETH/USDT', datetime.now(), 2000, 2005, 1995, 2001, 100, '1m')
    assert doji.get_candle_pattern() == 'doji'
    
    # Hammer
    hammer = OHLCVBar('ETH/USDT', datetime.now(), 2000, 2005, 1950, 2003, 100, '1m')
    assert hammer.get_candle_pattern() == 'hammer'
    
    # Shooting star
    star = OHLCVBar('ETH/USDT', datetime.now(), 2000, 2050, 1995, 1997, 100, '1m')
    assert star.get_candle_pattern() == 'shooting_star'
    
    print("✓ Pattern recognition working correctly")

def test_relative_sizing():
    """Test relative sizing calculations"""
    bars = [
        OHLCVBar('ETH/USDT', datetime.now(), 2000, 2010, 1990, 2005, 100, '1m'),
        OHLCVBar('ETH/USDT', datetime.now(), 2005, 2015, 1995, 2010, 100, '1m'),
        OHLCVBar('ETH/USDT', datetime.now(), 2010, 2020, 2000, 2015, 100, '1m'),
    ]
    
    # Large candle
    large = OHLCVBar('ETH/USDT', datetime.now(), 2015, 2055, 1995, 2050, 100, '1m')
    relative = large.get_relative_size(bars, 'avg')
    assert relative > 2.0  # Should be 2x larger
    
    print("✓ Relative sizing working correctly")

if __name__ == '__main__':
    test_candle_properties()
    test_pattern_recognition()
    test_relative_sizing()
    print("\n✅ All candle TA tests passed!")

Step 3: Update Model for Enhanced Features

# In NN/models/standardized_cnn.py or your model file

class EnhancedCNN(nn.Module):
    def __init__(self, use_candle_ta: bool = False):
        super().__init__()
        self.use_candle_ta = use_candle_ta
        
        # Adjust input size based on feature mode
        self.input_size = 22850 if use_candle_ta else 7850
        
        # Update first layer
        self.input_layer = nn.Linear(self.input_size, 4096)
        # ... rest of architecture ...
    
    def predict_from_base_input(self, base_input: BaseDataInput) -> ModelOutput:
        """Make prediction with optional candle TA features"""
        features = base_input.get_feature_vector(include_candle_ta=self.use_candle_ta)
        tensor = torch.tensor(features).unsqueeze(0).to(self.device)
        output = self.forward(tensor)
        return create_model_output(...)

Step 4: Training Script

# train_with_candle_ta.py

import logging
from core.orchestrator import Orchestrator
from core.data_provider import DataProvider

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def train_model_with_candle_ta():
    """Train model with enhanced candle TA features"""
    
    # Initialize components
    data_provider = DataProvider()
    orchestrator = Orchestrator(
        data_provider=data_provider,
        use_candle_ta=True  # Enable enhanced features
    )
    
    logger.info("Training with enhanced candle TA features (22,850 dimensions)")
    
    # Training loop
    for epoch in range(100):
        # Get training data
        base_data = data_provider.build_base_data_input('ETH/USDT')
        
        if not base_data or not base_data.validate():
            continue
        
        # Get enhanced features
        features = base_data.get_feature_vector(include_candle_ta=True)
        logger.info(f"Feature vector size: {len(features)}")
        
        # Train model
        loss = orchestrator.train_step(base_data)
        
        if epoch % 10 == 0:
            logger.info(f"Epoch {epoch}, Loss: {loss:.4f}")
    
    logger.info("Training complete!")

if __name__ == '__main__':
    train_model_with_candle_ta()

Step 5: Comparison Script

# compare_features.py

import numpy as np
from core.data_provider import DataProvider

def compare_feature_modes():
    """Compare standard vs enhanced feature modes"""
    
    data_provider = DataProvider()
    base_data = data_provider.build_base_data_input('ETH/USDT')
    
    # Standard features
    standard_features = base_data.get_feature_vector(include_candle_ta=False)
    print(f"Standard features: {len(standard_features)}")
    print(f"  Non-zero: {np.count_nonzero(standard_features)}")
    print(f"  Mean: {np.mean(standard_features):.4f}")
    print(f"  Std: {np.std(standard_features):.4f}")
    
    # Enhanced features
    enhanced_features = base_data.get_feature_vector(include_candle_ta=True)
    print(f"\nEnhanced features: {len(enhanced_features)}")
    print(f"  Non-zero: {np.count_nonzero(enhanced_features)}")
    print(f"  Mean: {np.mean(enhanced_features):.4f}")
    print(f"  Std: {np.std(enhanced_features):.4f}")
    
    # Analyze candle patterns in recent data
    print("\n--- Recent Candle Patterns ---")
    for i, bar in enumerate(base_data.ohlcv_1m[-10:]):
        pattern = bar.get_candle_pattern()
        direction = "🟢" if bar.is_bullish else "🔴"
        body_ratio = bar.get_body_to_range_ratio()
        print(f"{i+1}. {direction} {pattern:20s} Body: {body_ratio:.2%}")

if __name__ == '__main__':
    compare_feature_modes()

Step 6: Performance Benchmarking

# benchmark_candle_ta.py

import time
import numpy as np
from core.data_provider import DataProvider

def benchmark_feature_extraction():
    """Benchmark feature extraction performance"""
    
    data_provider = DataProvider()
    base_data = data_provider.build_base_data_input('ETH/USDT')
    
    # Benchmark standard mode
    times_standard = []
    for _ in range(100):
        start = time.time()
        features = base_data.get_feature_vector(include_candle_ta=False)
        times_standard.append(time.time() - start)
    
    # Benchmark enhanced mode
    times_enhanced = []
    for _ in range(100):
        start = time.time()
        features = base_data.get_feature_vector(include_candle_ta=True)
        times_enhanced.append(time.time() - start)
    
    print("Performance Benchmark (100 iterations)")
    print("=" * 50)
    print(f"Standard mode:  {np.mean(times_standard)*1000:.2f} ms ± {np.std(times_standard)*1000:.2f} ms")
    print(f"Enhanced mode:  {np.mean(times_enhanced)*1000:.2f} ms ± {np.std(times_enhanced)*1000:.2f} ms")
    print(f"Overhead:       {(np.mean(times_enhanced) - np.mean(times_standard))*1000:.2f} ms")
    print(f"Slowdown:       {np.mean(times_enhanced) / np.mean(times_standard):.2f}x")

if __name__ == '__main__':
    benchmark_feature_extraction()

Expected Results

Feature Extraction Performance:

  • Standard mode: ~1-2 ms
  • Enhanced mode: ~150-200 ms (due to TA calculations)
  • Optimization needed: Cache TA features in OHLCVBar

Model Training:

  • Standard mode: ~100 ms per batch
  • Enhanced mode: ~150-200 ms per batch (50-100% slower)
  • Trade-off: Better features vs longer training

Model Accuracy:

  • Expected improvement: 2-5% for pattern-heavy strategies
  • Best for: CNN, Transformer models
  • Less impact: Simple RL agents

Optimization: Caching TA Features

To improve performance, cache TA features when creating OHLCVBar:

# In data_provider.py

def _create_ohlcv_bar_with_ta(self, row, symbol: str, timeframe: str, 
                               reference_bars: List[OHLCVBar] = None) -> OHLCVBar:
    """Create OHLCVBar with pre-computed TA features"""
    bar = OHLCVBar(
        symbol=symbol,
        timestamp=row['timestamp'],
        open=float(row['open']),
        high=float(row['high']),
        low=float(row['low']),
        close=float(row['close']),
        volume=float(row['volume']),
        timeframe=timeframe
    )
    
    # Pre-compute and cache TA features
    if reference_bars:
        ta_features = bar.get_ta_features(reference_bars)
        bar.indicators.update(ta_features)  # Cache in indicators dict
    
    return bar

This reduces feature extraction time from ~150ms to ~2ms!

Decision Matrix: Should You Use Enhanced Candle TA?

Factor Standard Features Enhanced Candle TA Winner
Feature Count 7,850 22,850 Standard (simpler)
Pattern Recognition Limited Excellent Enhanced
Training Time Fast Slower (50-100%) Standard
Memory Usage Low (31 KB) Medium (91 KB) Standard
Model Complexity Lower Higher Standard
Accuracy Potential Good Better (2-5%) Enhanced
Overfitting Risk Lower Higher Standard
Interpretability Moderate High Enhanced
Setup Complexity Simple Moderate Standard

Recommendation by Model Type

Model Type Recommendation Reason
CNN ✅ Use Enhanced Benefits from spatial patterns
Transformer ✅ Use Enhanced Benefits from pattern encoding
RL Agent (DQN) ⚠️ Test First May not need all features
LSTM ✅ Use Enhanced Benefits from temporal patterns
Simple Linear ❌ Use Standard Too many features for simple model

When to Use Enhanced Features

✅ Use Enhanced TA if:

  • Training pattern-recognition models (CNN, Transformer)
  • Have sufficient training data (>100k samples)
  • Can afford longer training time
  • Need interpretable features
  • Trading strategy relies on candle patterns

❌ Stick with Standard if:

  • Training simple models (linear, small NN)
  • Limited training data (<10k samples)
  • Need fast inference (<10ms)
  • Memory constrained environment
  • Strategy doesn't use patterns