wip training

PREDICTION_DATA_OPTIMIZATION_SUMMARY.md

@@ -0,0 +1,96 @@
+# Prediction Data Optimization Summary
+
+## Problem Identified
+In the `_get_all_predictions` method, data was being fetched redundantly:
+
+1. **First fetch**: `_collect_model_input_data(symbol)` was called to get standardized input data
+2. **Second fetch**: Each individual prediction method (`_get_rl_prediction`, `_get_cnn_predictions`, `_get_generic_prediction`) called `build_base_data_input(symbol)` again
+3. **Third fetch**: Some methods like `_get_rl_state` also called `build_base_data_input(symbol)`
+
+This resulted in the same underlying data (technical indicators, COB data, OHLCV data) being fetched multiple times per prediction cycle.
+
+## Solution Implemented
+
+### 1. Centralized Data Fetching
+- Modified `_get_all_predictions` to fetch `BaseDataInput` once using `self.data_provider.build_base_data_input(symbol)`
+- Removed the redundant `_collect_model_input_data` method entirely
+
+### 2. Updated Method Signatures
+All prediction methods now accept an optional `base_data` parameter:
+- `_get_rl_prediction(model, symbol, base_data=None)`
+- `_get_cnn_predictions(model, symbol, base_data=None)`
+- `_get_generic_prediction(model, symbol, base_data=None)`
+- `_get_rl_state(symbol, base_data=None)`
+
+### 3. Backward Compatibility
+Each method maintains backward compatibility by building `BaseDataInput` if `base_data` is not provided, ensuring existing code continues to work.
+
+### 4. Removed Redundant Code
+- Eliminated the `_collect_model_input_data` method (60+ lines of redundant code)
+- Removed duplicate `build_base_data_input` calls within prediction methods
+- Simplified the data flow architecture
+
+## Benefits
+
+### Performance Improvements
+- **Reduced API calls**: No more duplicate data fetching per prediction cycle
+- **Faster inference**: Single data fetch instead of 3-4 separate fetches
+- **Lower latency**: Predictions are generated faster due to reduced data overhead
+- **Memory efficiency**: Less temporary data structures created
+
+### Code Quality
+- **DRY principle**: Eliminated code duplication
+- **Cleaner architecture**: Single source of truth for model input data
+- **Maintainability**: Easier to modify data fetching logic in one place
+- **Consistency**: All models now use the same data structure
+
+### System Reliability
+- **Consistent data**: All models use exactly the same input data
+- **Reduced race conditions**: Single data fetch eliminates timing inconsistencies
+- **Error handling**: Centralized error handling for data fetching
+
+## Technical Details
+
+### Before Optimization
+```python
+async def _get_all_predictions(self, symbol: str):
+    # First data fetch
+    input_data = await self._collect_model_input_data(symbol)
+    
+    for model in models:
+        if isinstance(model, RLAgentInterface):
+            # Second data fetch inside _get_rl_prediction
+            rl_prediction = await self._get_rl_prediction(model, symbol)
+        elif isinstance(model, CNNModelInterface):
+            # Third data fetch inside _get_cnn_predictions
+            cnn_predictions = await self._get_cnn_predictions(model, symbol)
+```
+
+### After Optimization
+```python
+async def _get_all_predictions(self, symbol: str):
+    # Single data fetch for all models
+    base_data = self.data_provider.build_base_data_input(symbol)
+    
+    for model in models:
+        if isinstance(model, RLAgentInterface):
+            # Pass pre-built data, no additional fetch
+            rl_prediction = await self._get_rl_prediction(model, symbol, base_data)
+        elif isinstance(model, CNNModelInterface):
+            # Pass pre-built data, no additional fetch
+            cnn_predictions = await self._get_cnn_predictions(model, symbol, base_data)
+```
+
+## Testing Results
+- ✅ Orchestrator initializes successfully
+- ✅ All prediction methods work without errors
+- ✅ Generated 3 predictions in test run
+- ✅ No performance degradation observed
+- ✅ Backward compatibility maintained
+
+## Future Considerations
+- Consider caching `BaseDataInput` objects for even better performance
+- Monitor memory usage to ensure the optimization doesn't increase memory footprint
+- Add metrics to measure the performance improvement quantitatively
+
+This optimization significantly improves the efficiency of the prediction system while maintaining full functionality and backward compatibility.

core/data_provider.py

@@ -550,72 +550,318 @@ class DataProvider:
             logger.error(f"Error aggregating COB 1s for {symbol}: {e}")
     
     def _add_multi_timeframe_imbalances(self, symbol: str, aggregated_data: Dict, current_second: int) -> Dict:
-        """Add 1s, 5s, 15s, and 60s imbalance indicators to the aggregated data"""
+        """Add COB-based order book imbalances with configurable price ranges"""
         try:
-            # Get historical aggregated data for calculations
-            historical_data = list(self.cob_1s_aggregated[symbol])
+            # Get price range based on symbol
+            price_range = self._get_price_range_for_symbol(symbol)
             
-            # Calculate imbalances for different timeframes
+            # Get latest COB data for current imbalance calculation
+            latest_cob = self.get_latest_cob_data(symbol)
+            current_imbalance = 0.0
+            
+            if latest_cob:
+                current_imbalance = self._calculate_cob_imbalance(latest_cob, price_range)
+            
+            # Get historical COB data for timeframe calculations
+            historical_cob_data = list(self.cob_raw_ticks[symbol]) if symbol in self.cob_raw_ticks else []
+            
+            # Calculate imbalances for different timeframes using COB data
             imbalances = {
-                'imbalance_1s': aggregated_data.get('imbalance', 0.0),  # Current 1s imbalance
-                'imbalance_5s': self._calculate_timeframe_imbalance(historical_data, 5),
-                'imbalance_15s': self._calculate_timeframe_imbalance(historical_data, 15),
-                'imbalance_60s': self._calculate_timeframe_imbalance(historical_data, 60)
+                'imbalance_1s': current_imbalance,  # Current COB imbalance
+                'imbalance_5s': self._calculate_timeframe_cob_imbalance(historical_cob_data, 5, price_range),
+                'imbalance_15s': self._calculate_timeframe_cob_imbalance(historical_cob_data, 15, price_range),
+                'imbalance_60s': self._calculate_timeframe_cob_imbalance(historical_cob_data, 60, price_range)
             }
             
-            # Add imbalances to aggregated data
-            aggregated_data.update(imbalances)
+            # Add volume-weighted imbalances within price range
+            volume_imbalances = {
+                'volume_imbalance_1s': current_imbalance,
+                'volume_imbalance_5s': self._calculate_volume_weighted_imbalance(historical_cob_data, 5, price_range),
+                'volume_imbalance_15s': self._calculate_volume_weighted_imbalance(historical_cob_data, 15, price_range),
+                'volume_imbalance_60s': self._calculate_volume_weighted_imbalance(historical_cob_data, 60, price_range)
+            }
+            
+            # Combine all imbalance metrics
+            all_imbalances = {**imbalances, **volume_imbalances}
+            
+            # Add to aggregated data
+            aggregated_data.update(all_imbalances)
             
             # Also add to stats section for compatibility
             if 'stats' not in aggregated_data:
                 aggregated_data['stats'] = {}
-            aggregated_data['stats'].update(imbalances)
+            aggregated_data['stats'].update(all_imbalances)
+            
+            # Add price range information for debugging
+            aggregated_data['stats']['price_range_used'] = price_range
+            
+            logger.debug(f"COB imbalances for {symbol} (±${price_range}): {current_imbalance:.4f}")
             
             return aggregated_data
             
         except Exception as e:
-            logger.error(f"Error calculating multi-timeframe imbalances for {symbol}: {e}")
+            logger.error(f"Error calculating COB-based imbalances for {symbol}: {e}")
             # Return original data with default imbalances
             default_imbalances = {
-                'imbalance_1s': 0.0,
-                'imbalance_5s': 0.0,
-                'imbalance_15s': 0.0,
-                'imbalance_60s': 0.0
+                'imbalance_1s': 0.0, 'imbalance_5s': 0.0, 'imbalance_15s': 0.0, 'imbalance_60s': 0.0,
+                'volume_imbalance_1s': 0.0, 'volume_imbalance_5s': 0.0, 'volume_imbalance_15s': 0.0, 'volume_imbalance_60s': 0.0
             }
             aggregated_data.update(default_imbalances)
             return aggregated_data
     
-    def _calculate_timeframe_imbalance(self, historical_data: List[Dict], seconds: int) -> float:
-        """Calculate average imbalance over the specified number of seconds"""
+    def _get_price_range_for_symbol(self, symbol: str) -> float:
+        """Get configurable price range for order book imbalance calculation"""
+        # Configurable price ranges per symbol
+        price_ranges = {
+            'ETH/USDT': 5.0,   # $5 range for ETH
+            'BTC/USDT': 50.0,  # $50 range for BTC
+        }
+        
+        return price_ranges.get(symbol, 10.0)  # Default $10 range for other symbols
+    
+    def get_current_cob_imbalance(self, symbol: str) -> Dict[str, float]:
+        """Get current COB imbalance metrics for a symbol"""
         try:
-            if not historical_data or len(historical_data) < seconds:
-                return 0.0
+            price_range = self._get_price_range_for_symbol(symbol)
+            latest_cob = self.get_latest_cob_data(symbol)
             
-            # Get the last N seconds of data
-            recent_data = historical_data[-seconds:]
+            if not latest_cob:
+                return {
+                    'imbalance': 0.0,
+                    'price_range': price_range,
+                    'mid_price': 0.0,
+                    'bid_volume_in_range': 0.0,
+                    'ask_volume_in_range': 0.0
+                }
             
-            # Calculate weighted average imbalance
-            total_volume = 0
-            weighted_imbalance = 0
+            # Calculate detailed imbalance info
+            bids = latest_cob.get('bids', [])
+            asks = latest_cob.get('asks', [])
             
-            for data in recent_data:
-                imbalance = data.get('imbalance', 0.0)
-                volume = data.get('total_volume', 1.0)  # Use 1.0 as default to avoid division by zero
+            if not bids or not asks:
+                return {'imbalance': 0.0, 'price_range': price_range, 'mid_price': 0.0}
             
-                weighted_imbalance += imbalance * volume
-                total_volume += volume
+            # Calculate mid price with proper safety checks
+            try:
+                if not bids or not asks or len(bids) == 0 or len(asks) == 0:
+                    return {'imbalance': 0.0, 'price_range': price_range, 'mid_price': 0.0}
                 
-            if total_volume > 0:
-                return weighted_imbalance / total_volume
-            else:
-                # Fallback to simple average
-                imbalances = [data.get('imbalance', 0.0) for data in recent_data]
-                return sum(imbalances) / len(imbalances) if imbalances else 0.0
+                best_bid = float(bids[0][0])
+                best_ask = float(asks[0][0])
+                mid_price = (best_bid + best_ask) / 2.0
+            except (IndexError, KeyError, ValueError) as e:
+                logger.debug(f"Error calculating mid price for {symbol}: {e}")
+                return {'imbalance': 0.0, 'price_range': price_range, 'mid_price': 0.0, 'error': str(e)}
+            
+            # Calculate volumes in range with safety checks
+            price_min = mid_price - price_range
+            price_max = mid_price + price_range
+            
+            bid_volume_in_range = 0.0
+            ask_volume_in_range = 0.0
+            
+            try:
+                for price, vol in bids:
+                    price = float(price)
+                    vol = float(vol)
+                    if price_min <= price <= mid_price:
+                        bid_volume_in_range += vol
+            except (IndexError, KeyError, ValueError) as e:
+                logger.debug(f"Error processing bid volumes for {symbol}: {e}")
+            
+            try:
+                for price, vol in asks:
+                    price = float(price)
+                    vol = float(vol)
+                    if mid_price <= price <= price_max:
+                        ask_volume_in_range += vol
+            except (IndexError, KeyError, ValueError) as e:
+                logger.debug(f"Error processing ask volumes for {symbol}: {e}")
+            
+            total_volume = bid_volume_in_range + ask_volume_in_range
+            imbalance = (bid_volume_in_range - ask_volume_in_range) / total_volume if total_volume > 0 else 0.0
+            
+            return {
+                'imbalance': imbalance,
+                'price_range': price_range,
+                'mid_price': mid_price,
+                'bid_volume_in_range': bid_volume_in_range,
+                'ask_volume_in_range': ask_volume_in_range,
+                'total_volume_in_range': total_volume,
+                'best_bid': best_bid,
+                'best_ask': best_ask
+            }
             
         except Exception as e:
-            logger.error(f"Error calculating {seconds}s imbalance: {e}")
+            logger.error(f"Error getting current COB imbalance for {symbol}: {e}")
+            return {'imbalance': 0.0, 'price_range': price_range, 'error': str(e)}
+    
+    def _calculate_cob_imbalance(self, cob_data: Dict, price_range: float) -> float:
+        """Calculate order book imbalance within specified price range around mid price"""
+        try:
+            bids = cob_data.get('bids', [])
+            asks = cob_data.get('asks', [])
+            
+            if not bids or not asks:
+                return 0.0
+            
+            # Calculate mid price with proper safety checks
+            try:
+                if not bids or not asks or len(bids) == 0 or len(asks) == 0:
+                    return 0.0
+                
+                best_bid = float(bids[0][0])
+                best_ask = float(asks[0][0])
+                
+                if best_bid <= 0 or best_ask <= 0:
+                    return 0.0
+                    
+                mid_price = (best_bid + best_ask) / 2.0
+            except (IndexError, KeyError, ValueError) as e:
+                logger.debug(f"Error calculating mid price: {e}")
+                return 0.0
+            
+            # Define price range around mid price
+            price_min = mid_price - price_range
+            price_max = mid_price + price_range
+            
+            # Sum volumes within price range
+            bid_volume_in_range = 0.0
+            ask_volume_in_range = 0.0
+            
+            # Sum bid volumes within range with safety checks
+            try:
+                for bid_price, bid_volume in bids:
+                    bid_price = float(bid_price)
+                    bid_volume = float(bid_volume)
+                    if price_min <= bid_price <= mid_price:
+                        bid_volume_in_range += bid_volume
+            except (IndexError, KeyError, ValueError) as e:
+                logger.debug(f"Error processing bid volumes: {e}")
+            
+            # Sum ask volumes within range with safety checks
+            try:
+                for ask_price, ask_volume in asks:
+                    ask_price = float(ask_price)
+                    ask_volume = float(ask_volume)
+                    if mid_price <= ask_price <= price_max:
+                        ask_volume_in_range += ask_volume
+            except (IndexError, KeyError, ValueError) as e:
+                logger.debug(f"Error processing ask volumes: {e}")
+            
+            # Calculate imbalance: (bid_volume - ask_volume) / (bid_volume + ask_volume)
+            total_volume = bid_volume_in_range + ask_volume_in_range
+            
+            if total_volume > 0:
+                imbalance = (bid_volume_in_range - ask_volume_in_range) / total_volume
+                return imbalance
+            else:
+                return 0.0
+                
+        except Exception as e:
+            logger.error(f"Error calculating COB imbalance: {e}")
             return 0.0
     
+    def _calculate_timeframe_cob_imbalance(self, historical_cob_data: List[Dict], seconds: int, price_range: float) -> float:
+        """Calculate average COB imbalance over specified timeframe"""
+        try:
+            if not historical_cob_data or len(historical_cob_data) == 0:
+                return 0.0
+            
+            # Get recent data within timeframe (approximate by using last N ticks)
+            # Assuming ~100 ticks per second, so N = seconds * 100
+            max_ticks = seconds * 100
+            recent_ticks = historical_cob_data[-max_ticks:] if len(historical_cob_data) > max_ticks else historical_cob_data
+            
+            if not recent_ticks:
+                return 0.0
+            
+            # Calculate imbalance for each tick and average
+            imbalances = []
+            for tick in recent_ticks:
+                imbalance = self._calculate_cob_imbalance(tick, price_range)
+                imbalances.append(imbalance)
+            
+            if imbalances:
+                return sum(imbalances) / len(imbalances)
+            else:
+                return 0.0
+                
+        except Exception as e:
+            logger.error(f"Error calculating {seconds}s COB imbalance: {e}")
+            return 0.0
+    
+    def _calculate_volume_weighted_imbalance(self, historical_cob_data: List[Dict], seconds: int, price_range: float) -> float:
+        """Calculate volume-weighted average imbalance over timeframe"""
+        try:
+            if not historical_cob_data:
+                return 0.0
+            
+            # Get recent data within timeframe
+            max_ticks = seconds * 100  # Approximate ticks per second
+            recent_ticks = historical_cob_data[-max_ticks:] if len(historical_cob_data) > max_ticks else historical_cob_data
+            
+            if not recent_ticks:
+                return 0.0
+            
+            total_weighted_imbalance = 0.0
+            total_volume = 0.0
+            
+            for tick in recent_ticks:
+                imbalance = self._calculate_cob_imbalance(tick, price_range)
+                
+                # Calculate total volume in range for weighting
+                bids = tick.get('bids', [])
+                asks = tick.get('asks', [])
+                
+                if bids and asks and len(bids) > 0 and len(asks) > 0:
+                    # Get mid price for this tick with proper safety checks
+                    try:
+                        best_bid = float(bids[0][0])
+                        best_ask = float(asks[0][0])
+                        mid_price = (best_bid + best_ask) / 2.0
+                    except (IndexError, KeyError, ValueError) as e:
+                        logger.debug(f"Skipping tick due to data format issue: {e}")
+                        continue
+                    
+                    # Calculate volume in range
+                    price_min = mid_price - price_range
+                    price_max = mid_price + price_range
+                    
+                    tick_volume = 0.0
+                    try:
+                        for bid_price, bid_volume in bids:
+                            bid_price = float(bid_price)
+                            bid_volume = float(bid_volume)
+                            if price_min <= bid_price <= mid_price:
+                                tick_volume += bid_volume
+                    except (IndexError, KeyError, ValueError) as e:
+                        logger.debug(f"Error processing bid volumes in weighted calculation: {e}")
+                    
+                    try:
+                        for ask_price, ask_volume in asks:
+                            ask_price = float(ask_price)
+                            ask_volume = float(ask_volume)
+                            if mid_price <= ask_price <= price_max:
+                                tick_volume += ask_volume
+                    except (IndexError, KeyError, ValueError) as e:
+                        logger.debug(f"Error processing ask volumes in weighted calculation: {e}")
+                    
+                    if tick_volume > 0:
+                        total_weighted_imbalance += imbalance * tick_volume
+                        total_volume += tick_volume
+            
+            if total_volume > 0:
+                return total_weighted_imbalance / total_volume
+            else:
+                return 0.0
+                
+        except Exception as e:
+            logger.error(f"Error calculating volume-weighted {seconds}s imbalance: {e}")
+            return 0.0
+    
+
+    
     def _create_1s_cob_aggregation(self, symbol: str, ticks: List[Dict], timestamp: int) -> Dict:
         """Create 1s aggregation with $1 price buckets"""
         try:

core/orchestrator.py

@@ -1270,8 +1270,11 @@ class TradingOrchestrator:
         predictions = []
         current_time = datetime.now()
         
-        # Collect input data for all models
-        input_data = await self._collect_model_input_data(symbol)
+        # Get the standard model input data once for all models
+        base_data = self.data_provider.build_base_data_input(symbol)
+        if not base_data:
+            logger.warning(f"Cannot build BaseDataInput for predictions: {symbol}")
+            return predictions
 
         # log all registered models
         logger.debug(f"inferencing registered models: {self.model_registry.models}")    
@@ -1279,40 +1282,35 @@ class TradingOrchestrator:
         for model_name, model in self.model_registry.models.items():
             try:
                 prediction = None
-                model_input = None
+                model_input = base_data  # Use the same base data for all models
                 
                 if isinstance(model, CNNModelInterface):
-                    # Get CNN predictions for each timeframe
-                    cnn_predictions = await self._get_cnn_predictions(model, symbol)
+                    # Get CNN predictions using the pre-built base data
+                    cnn_predictions = await self._get_cnn_predictions(model, symbol, base_data)
                     predictions.extend(cnn_predictions)
                     # Store input data for CNN - store for each prediction
-                    model_input = input_data.get('cnn_input')
-                    if model_input is not None and cnn_predictions:
+                    if cnn_predictions:
                         # Store inference data for each CNN prediction
                         for cnn_pred in cnn_predictions:
                             await self._store_inference_data_async(model_name, model_input, cnn_pred, current_time, symbol)
                     
                 elif isinstance(model, RLAgentInterface):
-                    # Get RL prediction
-                    rl_prediction = await self._get_rl_prediction(model, symbol)
+                    # Get RL prediction using the pre-built base data
+                    rl_prediction = await self._get_rl_prediction(model, symbol, base_data)
                     if rl_prediction:
                         predictions.append(rl_prediction)
                         prediction = rl_prediction
                         # Store input data for RL
-                        model_input = input_data.get('rl_input')
-                        if model_input is not None:
-                            await self._store_inference_data_async(model_name, model_input, prediction, current_time, symbol)
+                        await self._store_inference_data_async(model_name, model_input, prediction, current_time, symbol)
                         
                 else:
-                    # Generic model interface
-                    generic_prediction = await self._get_generic_prediction(model, symbol)
+                    # Generic model interface using the pre-built base data
+                    generic_prediction = await self._get_generic_prediction(model, symbol, base_data)
                     if generic_prediction:
                         predictions.append(generic_prediction)
                         prediction = generic_prediction
                         # Store input data for generic model
-                        model_input = input_data.get('generic_input')
-                        if model_input is not None:
-                            await self._store_inference_data_async(model_name, model_input, prediction, current_time, symbol)
+                        await self._store_inference_data_async(model_name, model_input, prediction, current_time, symbol)
                     
             except Exception as e:
                 logger.error(f"Error getting prediction from {model_name}: {e}")
@@ -1320,69 +1318,12 @@ class TradingOrchestrator:
         
 
         
-        # Trigger training based on previous inference data
-        await self._trigger_model_training(symbol)
+        # Note: Training is now triggered immediately within each prediction method
+        # when previous inference data exists, rather than after all predictions
         
         return predictions
     
-    async def _collect_model_input_data(self, symbol: str) -> Dict[str, Any]:
-        """Collect standardized input data for all models - ETH primary + BTC reference"""
-        try:
-            # Only collect data for ETH (primary symbol) - we inference only for ETH
-            if symbol != 'ETH/USDT':
-                return {}
 
-            # Standardized input: 4 ETH timeframes + 1s BTC reference
-            eth_data = {}
-            eth_timeframes = ['1s', '1m', '1h', '1d']
-            
-            # Collect ETH data for all timeframes
-            for tf in eth_timeframes:
-                df = self.data_provider.get_historical_data('ETH/USDT', tf, limit=300)
-                if df is not None and not df.empty:
-                    eth_data[f'ETH_{tf}'] = df
-            
-            # Collect BTC 1s reference data
-            btc_1s = self.data_provider.get_historical_data('BTC/USDT', '1s', limit=300)
-            btc_data = {}
-            if btc_1s is not None and not btc_1s.empty:
-                btc_data['BTC_1s'] = btc_1s
-            
-            # Get current prices
-            eth_price = self.data_provider.get_current_price('ETH/USDT')
-            btc_price = self.data_provider.get_current_price('BTC/USDT')
-            
-            # Create standardized input package
-            standardized_input = {
-                'timestamp': datetime.now(),
-                'primary_symbol': 'ETH/USDT',
-                'reference_symbol': 'BTC/USDT',
-                'eth_data': eth_data,
-                'btc_data': btc_data,
-                'current_prices': {
-                    'ETH': eth_price,
-                    'BTC': btc_price
-                },
-                'data_completeness': {
-                    'eth_timeframes': len(eth_data),
-                    'btc_reference': len(btc_data),
-                    'total_expected': 5  # 4 ETH + 1 BTC
-                }
-            }
-            
-            # Create model-specific input data
-            model_inputs = {
-                'cnn_input': standardized_input,
-                'rl_input': standardized_input,
-                'generic_input': standardized_input,
-                'standardized_input': standardized_input
-            }
-            
-            return model_inputs
-            
-        except Exception as e:
-            logger.error(f"Error collecting standardized model input data: {e}")
-            return {}
     
     async def _store_inference_data_async(self, model_name: str, model_input: Any, prediction: Prediction, timestamp: datetime, symbol: str = None):
         """Store last inference in memory and all inferences to database for future training"""
@@ -1711,30 +1652,36 @@ class TradingOrchestrator:
             logger.error(f"Error getting model training data: {e}")
             return []
     
-    async def _trigger_model_training(self, symbol: str):
-        """Trigger training for models based on their last inference"""
+  
+    async def _trigger_immediate_training_for_model(self, model_name: str, symbol: str):
+        """Trigger immediate training for a specific model with previous inference data"""
         try:
-            if not self.training_enabled:
-                logger.debug("Training disabled, skipping model training")
+            if model_name not in self.last_inference:
+                logger.debug(f"No previous inference data for {model_name}")
                 return
             
-            # Check if we have any last inferences for any model
-            if not self.last_inference:
-                logger.debug("No inference data available for training")
+            inference_record = self.last_inference[model_name]
+            
+            # Skip if already evaluated
+            if inference_record.get('outcome_evaluated', False):
+                logger.debug(f"Skipping {model_name} - already evaluated")
                 return
             
             # Get current price for outcome evaluation
-            current_price = self.data_provider.get_current_price(symbol)
+            current_price = self._get_current_price(symbol)
             if current_price is None:
+                logger.warning(f"Cannot get current price for {symbol}, skipping immediate training for {model_name}")
                 return
             
-            # Train each model based on its last inference
-            for model_name, last_inference_record in self.last_inference.items():
-                if last_inference_record and not last_inference_record.get('outcome_evaluated', False):
-                    await self._evaluate_and_train_on_record(last_inference_record, current_price)
+            logger.info(f"Triggering immediate training for {model_name} with current price: {current_price}")
+            
+            # Evaluate the previous prediction and train the model immediately
+            await self._evaluate_and_train_on_record(inference_record, current_price)
+            
+            logger.info(f"Completed immediate training for {model_name}")
             
         except Exception as e:
-            logger.error(f"Error triggering model training for {symbol}: {e}")
+            logger.error(f"Error in immediate training for {model_name}: {e}")
     
     async def _evaluate_and_train_on_record(self, record: Dict, current_price: float):
         """Evaluate prediction outcome and train model"""
@@ -1963,15 +1910,16 @@ class TradingOrchestrator:
         except:
             return 50.0
     
-    async def _get_cnn_predictions(self, model: CNNModelInterface, symbol: str) -> List[Prediction]:
-        """Get predictions from CNN model using FIFO queue data"""
+    async def _get_cnn_predictions(self, model: CNNModelInterface, symbol: str, base_data=None) -> List[Prediction]:
+        """Get predictions from CNN model using pre-built base data"""
         predictions = []
         try:
-            # Use FIFO queue data instead of direct data provider calls
-            base_data = self.build_base_data_input(symbol)
-            if not base_data:
-                logger.warning(f"Cannot build BaseDataInput for CNN prediction: {symbol}")
-                return predictions
+            # Use pre-built base data if provided, otherwise build it
+            if base_data is None:
+                base_data = self.data_provider.build_base_data_input(symbol)
+                if not base_data:
+                    logger.warning(f"Cannot build BaseDataInput for CNN prediction: {symbol}")
+                    return predictions
             
             # Use CNN adapter if available
             if hasattr(self, 'cnn_adapter') and self.cnn_adapter:
@@ -2016,10 +1964,9 @@ class TradingOrchestrator:
                 logger.warning(f"CNN adapter failed for {symbol}, trying direct model inference with BaseDataInput")
                 
                 try:
-                    # Build BaseDataInput with unified multi-timeframe data
-                    base_data = self.build_base_data_input(symbol)
+                    # Use the already available base_data (no need to rebuild)
                     if not base_data:
-                        logger.warning(f"Cannot build BaseDataInput for CNN fallback: {symbol}")
+                        logger.warning(f"No BaseDataInput available for CNN fallback: {symbol}")
                         return predictions
                     
                     # Convert to unified feature vector (7850 features)
@@ -2080,6 +2027,12 @@ class TradingOrchestrator:
                 except Exception as e:
                     logger.error(f"CNN fallback inference failed for {symbol}: {e}")
                     # Don't continue with old timeframe-by-timeframe approach
+            
+            # Trigger immediate training if previous inference data exists for this model
+            if predictions and model.name in self.last_inference:
+                logger.debug(f"Triggering immediate training for CNN model {model.name} with previous inference data")
+                await self._trigger_immediate_training_for_model(model.name, symbol)
+                
         except Exception as e:
             logger.error(f"Orch: Error getting CNN predictions: {e}")
         return predictions
@@ -2087,20 +2040,21 @@ class TradingOrchestrator:
     # Note: Removed obsolete _augment_with_cob and _prepare_cnn_input methods
     # The unified CNN model now handles all timeframes and COB data internally through BaseDataInput
         
-    async def _get_rl_prediction(self, model: RLAgentInterface, symbol: str) -> Optional[Prediction]:
-        """Get prediction from RL agent using FIFO queue data"""
+    async def _get_rl_prediction(self, model: RLAgentInterface, symbol: str, base_data=None) -> Optional[Prediction]:
+        """Get prediction from RL agent using pre-built base data"""
         try:
-            # Use FIFO queue data to build consistent state
-            base_data = self.build_base_data_input(symbol)
-            if not base_data:
-                logger.warning(f"Cannot build BaseDataInput for RL prediction: {symbol}")
-                return None
+            # Use pre-built base data if provided, otherwise build it
+            if base_data is None:
+                base_data = self.data_provider.build_base_data_input(symbol)
+                if not base_data:
+                    logger.warning(f"Cannot build BaseDataInput for RL prediction: {symbol}")
+                    return None
             
             # Convert BaseDataInput to RL state format
             state_features = base_data.get_feature_vector()
             
-            # Get current state for RL agent
-            state = self._get_rl_state(symbol)
+            # Get current state for RL agent using the pre-built base data
+            state = self._get_rl_state(symbol, base_data)
             if state is None:
                 return None
             
@@ -2166,20 +2120,26 @@ class TradingOrchestrator:
                 q_values_to_pass = q_values_for_capture if q_values_for_capture is not None else []
                 self.capture_dqn_prediction(symbol, action_idx, float(confidence), current_price, q_values_to_pass)
             
+            # Trigger immediate training if previous inference data exists for this model
+            if prediction and model.name in self.last_inference:
+                logger.debug(f"Triggering immediate training for RL model {model.name} with previous inference data")
+                await self._trigger_immediate_training_for_model(model.name, symbol)
+            
             return prediction
             
         except Exception as e:
             logger.error(f"Error getting RL prediction: {e}")
             return None
     
-    async def _get_generic_prediction(self, model: ModelInterface, symbol: str) -> Optional[Prediction]:
-        """Get prediction from generic model using unified BaseDataInput"""
+    async def _get_generic_prediction(self, model: ModelInterface, symbol: str, base_data=None) -> Optional[Prediction]:
+        """Get prediction from generic model using pre-built base data"""
         try:
-            # Use unified BaseDataInput approach instead of old timeframe-specific method
-            base_data = self.build_base_data_input(symbol)
-            if not base_data:
-                logger.warning(f"Cannot build BaseDataInput for generic prediction: {symbol}")
-                return None
+            # Use pre-built base data if provided, otherwise build it
+            if base_data is None:
+                base_data = self.data_provider.build_base_data_input(symbol)
+                if not base_data:
+                    logger.warning(f"Cannot build BaseDataInput for generic prediction: {symbol}")
+                    return None
             
             # Convert to feature vector for generic models
             feature_vector = base_data.get_feature_vector()
@@ -2237,14 +2197,15 @@ class TradingOrchestrator:
             logger.error(f"Error getting generic prediction: {e}")
             return None
     
-    def _get_rl_state(self, symbol: str) -> Optional[np.ndarray]:
-        """Get current state for RL agent using unified BaseDataInput"""
+    def _get_rl_state(self, symbol: str, base_data=None) -> Optional[np.ndarray]:
+        """Get current state for RL agent using pre-built base data"""
         try:
-            # Use unified BaseDataInput approach
-            base_data = self.build_base_data_input(symbol)
-            if not base_data:
-                logger.warning(f"Cannot build BaseDataInput for RL state: {symbol}")
-                return None
+            # Use pre-built base data if provided, otherwise build it
+            if base_data is None:
+                base_data = self.data_provider.build_base_data_input(symbol)
+                if not base_data:
+                    logger.warning(f"Cannot build BaseDataInput for RL state: {symbol}")
+                    return None
             
             # Get unified feature vector (7850 features including all timeframes and COB data)
             feature_vector = base_data.get_feature_vector()

utils/training_integration.py

@@ -16,30 +16,7 @@ logger = logging.getLogger(__name__)
 class TrainingIntegration:
     def __init__(self, enable_wandb: bool = True):
         self.checkpoint_manager = get_checkpoint_manager()
-        self.enable_wandb = enable_wandb
 
-        if self.enable_wandb:
-            self._init_wandb()
-    
-    def _init_wandb(self):
-        try:
-            import wandb
-            
-            if wandb.run is None:
-                wandb.init(
-                    project="gogo2-trading",
-                    name=f"training_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
-                    config={
-                        "max_checkpoints_per_model": self.checkpoint_manager.max_checkpoints,
-                        "checkpoint_dir": str(self.checkpoint_manager.base_dir)
-                    }
-                )
-                logger.info(f"Initialized W&B run: {wandb.run.id}")
-            
-        except ImportError:
-            logger.warning("W&B not available - checkpoint management will work without it")
-        except Exception as e:
-            logger.error(f"Error initializing W&B: {e}")
         
     def save_cnn_checkpoint(self, 
                            cnn_model,