From d9a66026c609b215e6f8211a85e17069fc35427d Mon Sep 17 00:00:00 2001 From: Dobromir Popov Date: Thu, 25 Sep 2025 00:32:59 +0300 Subject: [PATCH] docker container, inference chaining --- Dockerfile | 23 +++++++ compose.yaml | 6 ++ core/orchestrator.py | 158 ++++++++++++++++++++++++++++++++++++++++++- requirements.txt | 5 +- 4 files changed, 190 insertions(+), 2 deletions(-) create mode 100644 Dockerfile create mode 100644 compose.yaml diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..0e8e387 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,23 @@ +# For more information, please refer to https://aka.ms/vscode-docker-python +FROM python:3-slim + +# Keeps Python from generating .pyc files in the container +ENV PYTHONDONTWRITEBYTECODE=1 + +# Turns off buffering for easier container logging +ENV PYTHONUNBUFFERED=1 + +# Install pip requirements +COPY requirements.txt . +RUN python -m pip install -r requirements.txt + +WORKDIR /app +COPY . /app + +# Creates a non-root user with an explicit UID and adds permission to access the /app folder +# For more info, please refer to https://aka.ms/vscode-docker-python-configure-containers +RUN adduser -u 5678 --disabled-password --gecos "" appuser && chown -R appuser /app +USER appuser + +# During debugging, this entry point will be overridden. For more information, please refer to https://aka.ms/vscode-docker-python-debug +CMD ["python", "run_clean_dashboard.py"] diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..5cc6246 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,6 @@ +services: + gogo2: + image: gogo2 + build: + context: . + dockerfile: ./Dockerfile diff --git a/core/orchestrator.py b/core/orchestrator.py index 88f7789..b24b351 100644 --- a/core/orchestrator.py +++ b/core/orchestrator.py @@ -2651,4 +2651,160 @@ class TradingOrchestrator: return result except Exception as e: logger.error(f"Error getting OHLCV data: {e}") - return [] \ No newline at end of file + return [] + + def chain_inference(self, symbol: str, n_steps: int = 10) -> List[Dict]: + """ + Chain n inference steps using real models instead of mock predictions. + Each step uses the previous prediction as input for the next prediction. + + Args: + symbol: Trading symbol (e.g., 'ETH/USDT') + n_steps: Number of chained predictions to generate + + Returns: + List of prediction dictionaries with timestamps + """ + try: + logger.info(f"🔗 Starting chained inference for {symbol} with {n_steps} steps") + + predictions = [] + current_data = None + + for step in range(n_steps): + try: + # Get current market data for the first step + if step == 0: + current_data = self._get_current_market_data(symbol) + if not current_data: + logger.warning(f"No market data available for {symbol}") + break + + # Run inference with available models + step_predictions = [] + + # CNN Model inference + if hasattr(self, 'cnn_model') and self.cnn_model: + try: + cnn_pred = self.cnn_model.predict(current_data) + if cnn_pred: + step_predictions.append({ + 'model': 'CNN', + 'prediction': cnn_pred, + 'confidence': cnn_pred.get('confidence', 0.5) + }) + except Exception as e: + logger.debug(f"CNN inference error: {e}") + + # DQN Model inference + if hasattr(self, 'dqn_model') and self.dqn_model: + try: + dqn_pred = self.dqn_model.predict(current_data) + if dqn_pred: + step_predictions.append({ + 'model': 'DQN', + 'prediction': dqn_pred, + 'confidence': dqn_pred.get('confidence', 0.5) + }) + except Exception as e: + logger.debug(f"DQN inference error: {e}") + + # COB RL Model inference + if hasattr(self, 'cob_rl_agent') and self.cob_rl_agent: + try: + cob_pred = self.cob_rl_agent.predict(current_data) + if cob_pred: + step_predictions.append({ + 'model': 'COB_RL', + 'prediction': cob_pred, + 'confidence': cob_pred.get('confidence', 0.5) + }) + except Exception as e: + logger.debug(f"COB RL inference error: {e}") + + if not step_predictions: + logger.warning(f"No model predictions available for step {step}") + break + + # Combine predictions (simple average for now) + combined_prediction = self._combine_predictions(step_predictions) + + # Add timestamp for future prediction + prediction_time = datetime.now() + timedelta(minutes=step + 1) + combined_prediction['timestamp'] = prediction_time + combined_prediction['step'] = step + + predictions.append(combined_prediction) + + # Update current_data for next iteration using the prediction + current_data = self._update_data_with_prediction(current_data, combined_prediction) + + logger.debug(f"Step {step}: Generated prediction for {prediction_time}") + + except Exception as e: + logger.error(f"Error in chained inference step {step}: {e}") + break + + logger.info(f"✅ Chained inference completed: {len(predictions)} predictions generated") + return predictions + + except Exception as e: + logger.error(f"Error in chained inference: {e}") + return [] + + def _get_current_market_data(self, symbol: str) -> Optional[Dict]: + """Get current market data for inference""" + try: + # This would get real market data - placeholder for now + return { + 'symbol': symbol, + 'timestamp': datetime.now(), + 'price': 4300.0, # Placeholder + 'volume': 1000.0, + 'features': [4300.0, 4305.0, 4295.0, 4302.0, 1000.0] # OHLCV placeholder + } + except Exception as e: + logger.error(f"Error getting market data: {e}") + return None + + def _combine_predictions(self, predictions: List[Dict]) -> Dict: + """Combine multiple model predictions into a single prediction""" + try: + if not predictions: + return {} + + # Simple averaging for now + avg_confidence = sum(p['confidence'] for p in predictions) / len(predictions) + + # Use the prediction with highest confidence + best_pred = max(predictions, key=lambda x: x['confidence']) + + return { + 'prediction': best_pred['prediction'], + 'confidence': avg_confidence, + 'models_used': len(predictions), + 'model': best_pred['model'] + } + + except Exception as e: + logger.error(f"Error combining predictions: {e}") + return {} + + def _update_data_with_prediction(self, current_data: Dict, prediction: Dict) -> Dict: + """Update current data with the prediction for next iteration""" + try: + # Simple update - use predicted price as new current price + updated_data = current_data.copy() + pred_data = prediction.get('prediction', {}) + + if 'price' in pred_data: + updated_data['price'] = pred_data['price'] + + # Update timestamp + updated_data['timestamp'] = prediction.get('timestamp', datetime.now()) + + return updated_data + + except Exception as e: + logger.error(f"Error updating data with prediction: {e}") + return current_data \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 41a75c2..d340556 100644 --- a/requirements.txt +++ b/requirements.txt @@ -24,4 +24,7 @@ dash-bootstrap-components>=2.0.0 # NVIDIA GPU (CUDA): # Visit https://pytorch.org/get-started/locally/ for the correct command for your CUDA version. # Example (CUDA 12.1): -# pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 \ No newline at end of file +# pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 +# +# AMD Strix Halo NPU Acceleration: +# pip install onnxruntime-directml onnx transformers optimum \ No newline at end of file