prediction database

core/orchestrator.py

@@ -1112,11 +1112,76 @@ class TradingOrchestrator:
         return predictions
     
     async def _get_cnn_predictions(self, model: CNNModelInterface, symbol: str) -> List[Prediction]:
-        """Get predictions from CNN model for all timeframes with enhanced COB features"""
+        """Get CNN predictions for multiple timeframes"""
         predictions = []
         
         try:
-            for timeframe in self.config.timeframes:
+            # Get predictions for different timeframes
+            timeframes = ['1m', '5m', '1h']
+            
+            for timeframe in timeframes:
+                try:
+                    # Get features from data provider 
+                    features = self.data_provider.get_cnn_features_for_inference(symbol, timeframe, window_size=60)
+                    
+                    if features is not None and len(features) > 0:
+                        # Get prediction from model
+                        prediction_result = await model.predict(features)
+                        
+                        if prediction_result:
+                            prediction = Prediction(
+                                model_name=f"CNN_{timeframe}",
+                                symbol=symbol,
+                                signal=prediction_result.get('signal', 'HOLD'),
+                                confidence=prediction_result.get('confidence', 0.0),
+                                reasoning=f"CNN {timeframe} prediction",
+                                features=features[:10].tolist() if len(features) > 10 else features.tolist(),
+                                metadata={'timeframe': timeframe}
+                            )
+                            predictions.append(prediction)
+                            
+                            # Store prediction in database for tracking
+                            if (hasattr(self, 'enhanced_training_system') and 
+                                self.enhanced_training_system and 
+                                hasattr(self.enhanced_training_system, 'store_model_prediction')):
+                                
+                                current_price = self._get_current_price_safe(symbol)
+                                if current_price > 0:
+                                    prediction_id = self.enhanced_training_system.store_model_prediction(
+                                        model_name=f"CNN_{timeframe}",
+                                        symbol=symbol,
+                                        prediction_type=prediction.signal,
+                                        confidence=prediction.confidence,
+                                        current_price=current_price
+                                    )
+                                    logger.debug(f"Stored CNN prediction {prediction_id} for {symbol} {timeframe}")
+                            
+                except Exception as e:
+                    logger.debug(f"Error getting CNN prediction for {symbol} {timeframe}: {e}")
+                    continue
+                    
+        except Exception as e:
+            logger.error(f"Error in CNN predictions for {symbol}: {e}")
+        
+        return predictions
+    
+    def _get_current_price_safe(self, symbol: str) -> float:
+        """Safely get current price for a symbol"""
+        try:
+            # Try to get from data provider
+            if hasattr(self.data_provider, 'get_latest_data'):
+                latest = self.data_provider.get_latest_data(symbol)
+                if latest and 'close' in latest:
+                    return float(latest['close'])
+            
+            # Fallback values
+            fallback_prices = {'ETH/USDT': 4300.0, 'BTC/USDT': 111000.0}
+            return fallback_prices.get(symbol, 1000.0)
+            
+        except Exception as e:
+            logger.debug(f"Error getting current price for {symbol}: {e}")
+            return 0.0
+    
                 # Get standard feature matrix for this timeframe
                 feature_matrix = self.data_provider.get_feature_matrix(
                     symbol=symbol,
@@ -1259,11 +1324,58 @@ class TradingOrchestrator:
                     action_idx, confidence = result
                     raw_q_values = None
                 else:
-                    logger.error(f"Unexpected return format from act_with_confidence: {len(result)} values")
+                    logger.warning(f"Unexpected result format from RL model: {result}")
                     return None
-            elif hasattr(model.model, 'act'):
-                action_idx = model.model.act(state, explore=False)
-                confidence = 0.7  # Default confidence for basic act method
+            else:
+                # Fallback to standard act method
+                action_idx = model.model.act(state)
+                confidence = 0.6  # Default confidence
+                raw_q_values = None
+            
+            # Convert action index to action name
+            action_names = ['BUY', 'SELL', 'HOLD']
+            if 0 <= action_idx < len(action_names):
+                action = action_names[action_idx]
+            else:
+                logger.warning(f"Invalid action index from RL model: {action_idx}")
+                return None
+            
+            # Store prediction in database for tracking
+            if (hasattr(self, 'enhanced_training_system') and 
+                self.enhanced_training_system and 
+                hasattr(self.enhanced_training_system, 'store_model_prediction')):
+                
+                current_price = self._get_current_price_safe(symbol)
+                if current_price > 0:
+                    prediction_id = self.enhanced_training_system.store_model_prediction(
+                        model_name=f"DQN_{model.model_name}" if hasattr(model, 'model_name') else "DQN",
+                        symbol=symbol,
+                        prediction_type=action,
+                        confidence=confidence,
+                        current_price=current_price
+                    )
+                    logger.debug(f"Stored DQN prediction {prediction_id} for {symbol}")
+            
+            # Create prediction object
+            prediction = Prediction(
+                model_name=f"DQN_{model.model_name}" if hasattr(model, 'model_name') else "DQN",
+                symbol=symbol,
+                signal=action,
+                confidence=confidence,
+                reasoning=f"DQN agent prediction with Q-values: {raw_q_values}",
+                features=state.tolist() if isinstance(state, np.ndarray) else [],
+                metadata={
+                    'action_idx': action_idx,
+                    'q_values': raw_q_values.tolist() if raw_q_values is not None else None,
+                    'state_size': len(state) if state is not None else 0
+                }
+            )
+            
+            return prediction
+        
+        except Exception as e:
+            logger.error(f"Error getting RL prediction for {symbol}: {e}")
+            return None
                 raw_q_values = None # No raw q_values from simple act
             else:
                 logger.error(f"RL model {model.name} has no act method")