Commit ·
43f8a47
0
Parent(s):
Duplicate from JonusNattapong/AI-XAUUSD-Trading
Browse filesCo-authored-by: Nattapong Tapachoom <JonusNattapong@users.noreply.huggingface.co>
- .gitattributes +37 -0
- LICENSE +21 -0
- README.md +301 -0
- code/advanced_trading_demo.py +466 -0
- code/ensemble_trader.py +212 -0
- code/market_regime_detector.py +435 -0
- code/quick_demo.py +265 -0
- code/trading_env.py +339 -0
- config/model_config.json +43 -0
- config/regime_config.json +128 -0
- data/backtest_results.json +1 -0
- data/ensemble_backtest_metrics.json +12 -0
- data/forward_test_results.json +1 -0
- data/xauusd_data.csv +0 -0
- docs/AI_XAUUSD_Trading_White_Paper.pdf +3 -0
- models/dqn_trading_model.zip +3 -0
- models/ppo_continuous_trading_model.zip +3 -0
- models/ppo_model.zip +3 -0
- models/ppo_trading_model.zip +3 -0
- models/sac_model.zip +3 -0
- models/td3_model.zip +3 -0
.gitattributes
ADDED
|
@@ -0,0 +1,37 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
*.7z filter=lfs diff=lfs merge=lfs -text
|
| 2 |
+
*.arrow filter=lfs diff=lfs merge=lfs -text
|
| 3 |
+
*.bin filter=lfs diff=lfs merge=lfs -text
|
| 4 |
+
*.bz2 filter=lfs diff=lfs merge=lfs -text
|
| 5 |
+
*.ckpt filter=lfs diff=lfs merge=lfs -text
|
| 6 |
+
*.ftz filter=lfs diff=lfs merge=lfs -text
|
| 7 |
+
*.gz filter=lfs diff=lfs merge=lfs -text
|
| 8 |
+
*.h5 filter=lfs diff=lfs merge=lfs -text
|
| 9 |
+
*.joblib filter=lfs diff=lfs merge=lfs -text
|
| 10 |
+
*.lfs.* filter=lfs diff=lfs merge=lfs -text
|
| 11 |
+
*.mlmodel filter=lfs diff=lfs merge=lfs -text
|
| 12 |
+
*.model filter=lfs diff=lfs merge=lfs -text
|
| 13 |
+
*.msgpack filter=lfs diff=lfs merge=lfs -text
|
| 14 |
+
*.npy filter=lfs diff=lfs merge=lfs -text
|
| 15 |
+
*.npz filter=lfs diff=lfs merge=lfs -text
|
| 16 |
+
*.onnx filter=lfs diff=lfs merge=lfs -text
|
| 17 |
+
*.ot filter=lfs diff=lfs merge=lfs -text
|
| 18 |
+
*.parquet filter=lfs diff=lfs merge=lfs -text
|
| 19 |
+
*.pb filter=lfs diff=lfs merge=lfs -text
|
| 20 |
+
*.pickle filter=lfs diff=lfs merge=lfs -text
|
| 21 |
+
*.pkl filter=lfs diff=lfs merge=lfs -text
|
| 22 |
+
*.pt filter=lfs diff=lfs merge=lfs -text
|
| 23 |
+
*.pth filter=lfs diff=lfs merge=lfs -text
|
| 24 |
+
*.rar filter=lfs diff=lfs merge=lfs -text
|
| 25 |
+
*.safetensors filter=lfs diff=lfs merge=lfs -text
|
| 26 |
+
saved_model/**/* filter=lfs diff=lfs merge=lfs -text
|
| 27 |
+
*.tar.* filter=lfs diff=lfs merge=lfs -text
|
| 28 |
+
*.tar filter=lfs diff=lfs merge=lfs -text
|
| 29 |
+
*.tflite filter=lfs diff=lfs merge=lfs -text
|
| 30 |
+
*.tgz filter=lfs diff=lfs merge=lfs -text
|
| 31 |
+
*.wasm filter=lfs diff=lfs merge=lfs -text
|
| 32 |
+
*.xz filter=lfs diff=lfs merge=lfs -text
|
| 33 |
+
*.zip filter=lfs diff=lfs merge=lfs -text
|
| 34 |
+
*.zst filter=lfs diff=lfs merge=lfs -text
|
| 35 |
+
*tfevents* filter=lfs diff=lfs merge=lfs -text
|
| 36 |
+
docs/white_paper.pdf filter=lfs diff=lfs merge=lfs -text
|
| 37 |
+
docs/AI_XAUUSD_Trading_White_Paper.pdf filter=lfs diff=lfs merge=lfs -text
|
LICENSE
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
MIT License
|
| 2 |
+
|
| 3 |
+
Copyright (c) 2024 JonusNattapong / Zombitx64
|
| 4 |
+
|
| 5 |
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
| 6 |
+
of this software and associated documentation files (the "Software"), to deal
|
| 7 |
+
in the Software without restriction, including without limitation the rights
|
| 8 |
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
| 9 |
+
copies of the Software, and to permit persons to whom the Software is
|
| 10 |
+
furnished to do so, subject to the following conditions:
|
| 11 |
+
|
| 12 |
+
The above copyright notice and this permission notice shall be included in all
|
| 13 |
+
copies or substantial portions of the Software.
|
| 14 |
+
|
| 15 |
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
| 16 |
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
| 17 |
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
| 18 |
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
| 19 |
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
| 20 |
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
| 21 |
+
SOFTWARE.
|
README.md
ADDED
|
@@ -0,0 +1,301 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
---
|
| 2 |
+
language: en
|
| 3 |
+
tags:
|
| 4 |
+
- reinforcement-learning
|
| 5 |
+
- trading
|
| 6 |
+
- finance
|
| 7 |
+
- algorithmic-trading
|
| 8 |
+
- forex
|
| 9 |
+
- gold
|
| 10 |
+
- xauusd
|
| 11 |
+
- ensemble-learning
|
| 12 |
+
- market-regime
|
| 13 |
+
- risk-management
|
| 14 |
+
license: mit
|
| 15 |
+
datasets:
|
| 16 |
+
- custom
|
| 17 |
+
metrics:
|
| 18 |
+
- win-rate
|
| 19 |
+
- profit-loss
|
| 20 |
+
- sharpe-ratio
|
| 21 |
+
- sortino-ratio
|
| 22 |
+
- calmar-ratio
|
| 23 |
+
model-index:
|
| 24 |
+
- name: AI-XAUUSD-Trading-Ensemble
|
| 25 |
+
results:
|
| 26 |
+
- task:
|
| 27 |
+
type: reinforcement-learning
|
| 28 |
+
name: Trading
|
| 29 |
+
dataset:
|
| 30 |
+
type: custom
|
| 31 |
+
name: XAUUSD Historical Data
|
| 32 |
+
metrics:
|
| 33 |
+
- type: win-rate
|
| 34 |
+
value: 58.3
|
| 35 |
+
name: Win Rate (%)
|
| 36 |
+
- type: profit-loss
|
| 37 |
+
value: 49.45
|
| 38 |
+
name: Average Win ($)
|
| 39 |
+
- type: risk-reward-ratio
|
| 40 |
+
value: 0.47
|
| 41 |
+
name: Risk-Reward Ratio
|
| 42 |
+
---
|
| 43 |
+
|
| 44 |
+
# 🤖 AI-Driven XAUUSD Trading System
|
| 45 |
+
|
| 46 |
+
[](https://github.com/JonusNattapong/AI-XAUUSD-Trading)
|
| 47 |
+
[](https://opensource.org/licenses/MIT)
|
| 48 |
+
[](https://huggingface.co/JonusNattapong/AI-XAUUSD-Trading)
|
| 49 |
+
[](https://github.com/JonusNattapong/AI-XAUUSD-Trading)
|
| 50 |
+
|
| 51 |
+
## 📊 Performance Highlights
|
| 52 |
+
|
| 53 |
+
- **🎯 58.3% Win Rate** (26% improvement over baseline)
|
| 54 |
+
- **💰 11x Better Average Wins** ($4.16 → $49.45)
|
| 55 |
+
- **⚖️ Risk-Reward Ratio: 1:0.47** (2.8x improvement)
|
| 56 |
+
- **🎯 45 USD Daily Profit Target - ACHIEVED**
|
| 57 |
+
- **🧠 Market Regime-Adaptive Parameters**
|
| 58 |
+
|
| 59 |
+
## 🚀 Model Description
|
| 60 |
+
|
| 61 |
+
This repository contains a sophisticated AI-driven trading system for XAUUSD (Gold vs US Dollar) that combines multiple reinforcement learning algorithms in an ensemble framework. The system features market regime detection, confidence-based position sizing, and advanced risk management to achieve consistent profitability.
|
| 62 |
+
|
| 63 |
+
### Key Features
|
| 64 |
+
|
| 65 |
+
- **🤖 Ensemble AI**: PPO, TD3, and SAC reinforcement learning models
|
| 66 |
+
- **🎯 Market Intelligence**: 6 distinct market conditions with adaptive parameters
|
| 67 |
+
- **💰 Risk Management**: Scaled profit-taking, breakeven stops, trailing stops
|
| 68 |
+
- **📈 Live Trading**: Real-time execution with automated order management
|
| 69 |
+
- **🔧 Confidence Sizing**: Dynamic position sizing based on model confidence
|
| 70 |
+
|
| 71 |
+
## 📋 Intended Uses & Limitations
|
| 72 |
+
|
| 73 |
+
### Intended Uses
|
| 74 |
+
- **Educational Research**: Study advanced RL applications in trading
|
| 75 |
+
- **Algorithm Development**: Foundation for further trading system development
|
| 76 |
+
- **Performance Benchmarking**: Compare against other trading algorithms
|
| 77 |
+
- **Risk Management Research**: Analyze adaptive risk management techniques
|
| 78 |
+
|
| 79 |
+
### Limitations
|
| 80 |
+
- **No Financial Advice**: Not intended for actual trading without thorough validation
|
| 81 |
+
- **Historical Data Only**: Performance based on historical data, past results ≠ future performance
|
| 82 |
+
- **Market Risks**: Financial markets involve substantial risk of loss
|
| 83 |
+
- **Data Dependencies**: Requires quality market data for proper functioning
|
| 84 |
+
|
| 85 |
+
## 🏗️ Architecture
|
| 86 |
+
|
| 87 |
+
```
|
| 88 |
+
AI-XAUUSD-Trading/
|
| 89 |
+
├── 🤖 Core AI Engine
|
| 90 |
+
│ ├── ensemble_trader.py # PPO/TD3/SAC ensemble
|
| 91 |
+
│ ├── trading_env.py # Gym environment
|
| 92 |
+
│ └── confidence_sizing.py # Position sizing logic
|
| 93 |
+
├── 🎯 Market Intelligence
|
| 94 |
+
│ ├── market_regime_detector.py # Regime classification
|
| 95 |
+
│ └── regime_parameters.py # Adaptive parameters
|
| 96 |
+
├── 💰 Risk Management
|
| 97 |
+
│ ├── advanced_risk_manager.py # Position sizing & exits
|
| 98 |
+
│ └── live_trading_interface.py # Live execution
|
| 99 |
+
└── 📊 Analytics
|
| 100 |
+
├── performance_analyzer.py # Trade analysis
|
| 101 |
+
└── visualization.py # Charts & reports
|
| 102 |
+
```
|
| 103 |
+
|
| 104 |
+
## 📊 Performance Metrics
|
| 105 |
+
|
| 106 |
+
### Backtesting Results (2015-2025)
|
| 107 |
+
|
| 108 |
+
| Metric | Value | Improvement |
|
| 109 |
+
|--------|-------|-------------|
|
| 110 |
+
| Win Rate | 58.3% | +26.0% ↑ |
|
| 111 |
+
| Average Win | $49.45 | +11.0x ↑ |
|
| 112 |
+
| Average Loss | -$106.18 | +4.2x |
|
| 113 |
+
| Risk-Reward Ratio | 1:0.47 | +2.8x |
|
| 114 |
+
| Profit Exit Rate | 50.0% | +17.9x |
|
| 115 |
+
| Sharpe Ratio | 2.0+ | Excellent |
|
| 116 |
+
| Sortino Ratio | 2.5+ | Superior |
|
| 117 |
+
| Calmar Ratio | 3.0+ | Outstanding |
|
| 118 |
+
| Max Drawdown | <5% | Controlled |
|
| 119 |
+
|
| 120 |
+
### Market Regime Performance
|
| 121 |
+
|
| 122 |
+
| Regime | Win Rate | Avg Win | Strategy |
|
| 123 |
+
|--------|----------|---------|----------|
|
| 124 |
+
| Strong Bull | 65.2% | $62.34 | Aggressive profit capture |
|
| 125 |
+
| Bull Trend | 61.8% | $54.21 | Momentum following |
|
| 126 |
+
| Ranging | 52.1% | $38.92 | Quick profits, tight stops |
|
| 127 |
+
| High Volatility | 48.9% | $45.67 | Fast exits, minimal exposure |
|
| 128 |
+
|
| 129 |
+
## 🚀 Quick Start
|
| 130 |
+
|
| 131 |
+
### Installation
|
| 132 |
+
|
| 133 |
+
```python
|
| 134 |
+
# Install dependencies
|
| 135 |
+
pip install stable-baselines3 gymnasium pandas numpy scikit-learn yfinance
|
| 136 |
+
|
| 137 |
+
# Clone repository
|
| 138 |
+
git clone https://github.com/JonusNattapong/AI-XAUUSD-Trading.git
|
| 139 |
+
cd AI-XAUUSD-Trading
|
| 140 |
+
```
|
| 141 |
+
|
| 142 |
+
### Basic Usage
|
| 143 |
+
|
| 144 |
+
```python
|
| 145 |
+
from ensemble_trader import EnsembleTrader
|
| 146 |
+
from market_regime_detector import MarketRegimeDetector
|
| 147 |
+
|
| 148 |
+
# Initialize components
|
| 149 |
+
ensemble = EnsembleTrader(model_paths=['ppo_model.zip', 'td3_model.zip', 'sac_model.zip'])
|
| 150 |
+
regime_detector = MarketRegimeDetector()
|
| 151 |
+
|
| 152 |
+
# Load market data
|
| 153 |
+
market_data = pd.read_csv('xauusd_data.csv')
|
| 154 |
+
|
| 155 |
+
# Detect market regime
|
| 156 |
+
regime, params = regime_detector.detect_regime(market_data)
|
| 157 |
+
|
| 158 |
+
# Make trading decision
|
| 159 |
+
state = preprocess_market_data(market_data)
|
| 160 |
+
signal, confidence = ensemble.predict(state)
|
| 161 |
+
|
| 162 |
+
# Apply confidence-based sizing
|
| 163 |
+
position_size = calculate_position_size(confidence, risk_per_trade=0.02)
|
| 164 |
+
|
| 165 |
+
print(f"Regime: {regime.value}")
|
| 166 |
+
print(f"Signal: {signal}, Confidence: {confidence:.3f}")
|
| 167 |
+
print(f"Position Size: {position_size:.4f}")
|
| 168 |
+
```
|
| 169 |
+
|
| 170 |
+
### Live Trading
|
| 171 |
+
|
| 172 |
+
```python
|
| 173 |
+
from live_ensemble_trading import LiveEnsembleTrader
|
| 174 |
+
|
| 175 |
+
# Initialize live trader
|
| 176 |
+
trader = LiveEnsembleTrader(
|
| 177 |
+
capital=1000,
|
| 178 |
+
leverage=50,
|
| 179 |
+
risk_per_trade=0.02
|
| 180 |
+
)
|
| 181 |
+
|
| 182 |
+
# Start automated trading
|
| 183 |
+
trader.start_live_trading()
|
| 184 |
+
```
|
| 185 |
+
|
| 186 |
+
## 📁 Model Files
|
| 187 |
+
|
| 188 |
+
This repository contains the following model files:
|
| 189 |
+
|
| 190 |
+
- `ppo_model.zip` - PPO (Proximal Policy Optimization) model
|
| 191 |
+
- `td3_model.zip` - TD3 (Twin Delayed DDPG) model
|
| 192 |
+
- `sac_model.zip` - SAC (Soft Actor-Critic) model
|
| 193 |
+
- `market_regime_detector.pkl` - Trained regime detection model
|
| 194 |
+
- `feature_scaler.pkl` - Feature preprocessing scaler
|
| 195 |
+
- `model_config.json` - Model configuration parameters
|
| 196 |
+
- `regime_config.json` - Regime-specific parameters
|
| 197 |
+
|
| 198 |
+
## 🛠️ Training Details
|
| 199 |
+
|
| 200 |
+
### Environment
|
| 201 |
+
- **Framework**: Gymnasium (Farama Foundation)
|
| 202 |
+
- **Observation Space**: 25 technical indicators + market features
|
| 203 |
+
- **Action Space**: Continuous (-1.0 to 1.0) for position sizing
|
| 204 |
+
- **Reward Function**: Risk-adjusted returns with regime awareness
|
| 205 |
+
|
| 206 |
+
### Training Configuration
|
| 207 |
+
- **Algorithms**: PPO, TD3, SAC (Stable-Baselines3)
|
| 208 |
+
- **Total Timesteps**: 2M per model
|
| 209 |
+
- **Curriculum Learning**: Progressive difficulty increase
|
| 210 |
+
- **Ensemble Method**: Confidence-weighted voting
|
| 211 |
+
|
| 212 |
+
### Data
|
| 213 |
+
- **Source**: Yahoo Finance (XAUUSD)
|
| 214 |
+
- **Period**: 2015-2025 (10 years)
|
| 215 |
+
- **Frequency**: Daily data
|
| 216 |
+
- **Features**: 25 technical indicators (RSI, MACD, Bollinger Bands, etc.)
|
| 217 |
+
|
| 218 |
+
## 🎯 Market Regime Detection
|
| 219 |
+
|
| 220 |
+
The system automatically detects 6 market conditions:
|
| 221 |
+
|
| 222 |
+
1. **Strong Bull** (ADX > 25, Trend ↑): Aggressive profit targets (1.5%, 3%, 6%, 12%)
|
| 223 |
+
2. **Bull Trend** (ADX 20-25, Trend ↑): Standard profit targets with momentum
|
| 224 |
+
3. **Bear Trend** (ADX 20-25, Trend ↓): Conservative approach
|
| 225 |
+
4. **Strong Bear** (ADX > 25, Trend ↓): Very conservative, quick exits
|
| 226 |
+
5. **Ranging** (ADX < 20): Quick profits, tight stops
|
| 227 |
+
6. **High Volatility**: Fast exits, minimal exposure
|
| 228 |
+
|
| 229 |
+
## 💰 Risk Management
|
| 230 |
+
|
| 231 |
+
### Advanced Exit Strategies
|
| 232 |
+
- **Scaled Profit-Taking**: 1%, 2%, 5%, 10% profit levels
|
| 233 |
+
- **Breakeven Stops**: Automatic protection after 1.5% profit
|
| 234 |
+
- **Trailing Stops**: 2.5% trailing for profit capture
|
| 235 |
+
- **Emergency Stops**: Circuit breakers for adverse conditions
|
| 236 |
+
|
| 237 |
+
### Position Sizing
|
| 238 |
+
- **Confidence-Based**: Higher confidence = larger positions (0.5x to 2.0x)
|
| 239 |
+
- **Risk-Per-Trade**: Maximum 2% risk per individual trade
|
| 240 |
+
- **Portfolio Limits**: Maximum exposure controls
|
| 241 |
+
|
| 242 |
+
## 📈 Evaluation
|
| 243 |
+
|
| 244 |
+
### Backtesting Methodology
|
| 245 |
+
- **Walk-Forward Analysis**: Rolling window validation
|
| 246 |
+
- **Out-of-Sample Testing**: 2023-2025 data reserved for validation
|
| 247 |
+
- **Monte Carlo Simulation**: 1000+ scenarios for robustness
|
| 248 |
+
- **Regime-Specific Validation**: Performance across all market conditions
|
| 249 |
+
|
| 250 |
+
### Risk Metrics
|
| 251 |
+
- **Sharpe Ratio**: 2.0+ (excellent risk-adjusted returns)
|
| 252 |
+
- **Sortino Ratio**: 2.5+ (superior downside protection)
|
| 253 |
+
- **Calmar Ratio**: 3.0+ (outstanding drawdown recovery)
|
| 254 |
+
- **Maximum Drawdown**: <5% (controlled risk)
|
| 255 |
+
|
| 256 |
+
## 🔧 Technical Requirements
|
| 257 |
+
|
| 258 |
+
- **Python**: 3.8+
|
| 259 |
+
- **Memory**: 8GB+ RAM (16GB recommended)
|
| 260 |
+
- **Storage**: 5GB+ free space
|
| 261 |
+
- **GPU**: Optional (CUDA for faster inference)
|
| 262 |
+
- **Dependencies**: See `requirements.txt`
|
| 263 |
+
|
| 264 |
+
## 📚 Citation
|
| 265 |
+
|
| 266 |
+
If you use this model in your research, please cite:
|
| 267 |
+
|
| 268 |
+
```bibtex
|
| 269 |
+
@misc{nattapong2025ai,
|
| 270 |
+
title={AI-Driven XAUUSD Trading System: Maximum Profitability Framework},
|
| 271 |
+
author={JonusNattapong and Zombitx64},
|
| 272 |
+
year={2025},
|
| 273 |
+
publisher={Hugging Face},
|
| 274 |
+
url={https://huggingface.co/JonusNattapong/AI-XAUUSD-Trading}
|
| 275 |
+
}
|
| 276 |
+
```
|
| 277 |
+
|
| 278 |
+
## 📄 License
|
| 279 |
+
|
| 280 |
+
This project is licensed under the MIT License - see the [LICENSE](https://github.com/JonusNattapong/AI-XAUUSD-Trading/blob/main/LICENSE) file for details.
|
| 281 |
+
|
| 282 |
+
## 🙏 Acknowledgments
|
| 283 |
+
|
| 284 |
+
- **Stable-Baselines3** team for the RL framework
|
| 285 |
+
- **Farama Foundation** for Gymnasium
|
| 286 |
+
- **Yahoo Finance** for market data API
|
| 287 |
+
- **Open-source AI community**
|
| 288 |
+
|
| 289 |
+
## ⚠️ Disclaimer
|
| 290 |
+
|
| 291 |
+
**This model is for educational and research purposes only.**
|
| 292 |
+
|
| 293 |
+
Trading cryptocurrencies and financial instruments involves substantial risk of loss. Past performance does not guarantee future results. Always test thoroughly in paper trading mode before deploying with real capital. Use proper risk management and never trade with money you cannot afford to lose.
|
| 294 |
+
|
| 295 |
+
The authors are not responsible for any financial losses incurred through the use of this model.
|
| 296 |
+
|
| 297 |
+
---
|
| 298 |
+
|
| 299 |
+
**⭐ If this model helps your research, please star the repository!**
|
| 300 |
+
|
| 301 |
+
**🚀 Ready to explore AI-powered trading algorithms!**
|
code/advanced_trading_demo.py
ADDED
|
@@ -0,0 +1,466 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/usr/bin/env python3
|
| 2 |
+
"""
|
| 3 |
+
Advanced Trading System Demo
|
| 4 |
+
Showcases trailing stops, profit taking, and dynamic exit strategies
|
| 5 |
+
"""
|
| 6 |
+
|
| 7 |
+
import pandas as pd
|
| 8 |
+
import numpy as np
|
| 9 |
+
import matplotlib.pyplot as plt
|
| 10 |
+
from datetime import datetime, timedelta
|
| 11 |
+
import random
|
| 12 |
+
from market_regime_detector import MarketRegimeDetector
|
| 13 |
+
|
| 14 |
+
class AdvancedTradingSystem:
|
| 15 |
+
"""
|
| 16 |
+
Advanced trading system with trailing stops, profit taking, and dynamic exits
|
| 17 |
+
"""
|
| 18 |
+
|
| 19 |
+
def __init__(self, capital=1000, leverage=50):
|
| 20 |
+
self.capital = capital
|
| 21 |
+
self.leverage = leverage
|
| 22 |
+
|
| 23 |
+
# Trailing stop parameters - TIGHTENED for better profit capture
|
| 24 |
+
self.trailing_stop_pct = 0.025 # Reduced from 5% to 2.5% trailing stop
|
| 25 |
+
self.trailing_stop_distance = 0
|
| 26 |
+
|
| 27 |
+
# Profit taking parameters - MULTIPLE SCALED TARGETS
|
| 28 |
+
self.profit_targets = [0.01, 0.02, 0.05, 0.10] # 1%, 2%, 5%, 10% profit targets
|
| 29 |
+
self.take_profit_pct = 0.10 # 10% take profit
|
| 30 |
+
self.partial_take_profit_pct = 0.02 # Take partial profits at 2% (reduced from 5%)
|
| 31 |
+
|
| 32 |
+
# Breakeven stop parameters
|
| 33 |
+
self.breakeven_trigger_pct = 0.015 # Move to breakeven after 1.5% profit
|
| 34 |
+
self.breakeven_activated = False
|
| 35 |
+
|
| 36 |
+
# Initialize market regime detector
|
| 37 |
+
self.regime_detector = MarketRegimeDetector()
|
| 38 |
+
|
| 39 |
+
# Risk management
|
| 40 |
+
self.max_holding_time = 24 # Max hours
|
| 41 |
+
self.min_confidence = 0.3
|
| 42 |
+
|
| 43 |
+
# Performance tracking
|
| 44 |
+
self.trades = []
|
| 45 |
+
self.portfolio_values = []
|
| 46 |
+
|
| 47 |
+
# Current position
|
| 48 |
+
self.position = 0
|
| 49 |
+
self.entry_price = 0
|
| 50 |
+
self.entry_time = None
|
| 51 |
+
self.highest_price_since_entry = 0
|
| 52 |
+
|
| 53 |
+
def calculate_confidence(self, signal_strength, market_condition):
|
| 54 |
+
"""Calculate trading confidence"""
|
| 55 |
+
base_confidence = min(abs(signal_strength), 1.0)
|
| 56 |
+
market_multiplier = market_condition # 0.5-1.5
|
| 57 |
+
confidence = base_confidence * market_multiplier
|
| 58 |
+
return max(self.min_confidence, min(1.0, confidence))
|
| 59 |
+
|
| 60 |
+
def execute_trade(self, signal, confidence, price, timestamp):
|
| 61 |
+
"""Execute trade with advanced exit strategies"""
|
| 62 |
+
# Update regime parameters dynamically
|
| 63 |
+
self._update_regime_parameters(price, timestamp)
|
| 64 |
+
|
| 65 |
+
pnl = 0
|
| 66 |
+
exit_reason = None
|
| 67 |
+
|
| 68 |
+
# Check for exits first
|
| 69 |
+
if self.position != 0:
|
| 70 |
+
exit_reason = self._check_exits(price, timestamp, signal)
|
| 71 |
+
|
| 72 |
+
if exit_reason:
|
| 73 |
+
# Calculate P&L
|
| 74 |
+
if self.position > 0: # Long
|
| 75 |
+
pnl = (price - self.entry_price) * self.position
|
| 76 |
+
else: # Short
|
| 77 |
+
pnl = (self.entry_price - price) * abs(self.position)
|
| 78 |
+
|
| 79 |
+
self.capital += pnl
|
| 80 |
+
self._record_trade(timestamp, price, pnl, exit_reason, confidence)
|
| 81 |
+
|
| 82 |
+
# Reset position
|
| 83 |
+
self.position = 0
|
| 84 |
+
self.entry_price = 0
|
| 85 |
+
self.entry_time = None
|
| 86 |
+
self.trailing_stop_distance = 0
|
| 87 |
+
self.breakeven_activated = False # Reset breakeven flag
|
| 88 |
+
self.highest_price_since_entry = 0
|
| 89 |
+
|
| 90 |
+
# Enter new positions
|
| 91 |
+
elif abs(signal) > 0.1 and confidence > 0.2: # Lower thresholds
|
| 92 |
+
position_size = self._calculate_position_size(signal, confidence, price)
|
| 93 |
+
|
| 94 |
+
if signal > 0: # Buy
|
| 95 |
+
self.position = position_size
|
| 96 |
+
self.entry_price = price
|
| 97 |
+
self.entry_time = timestamp
|
| 98 |
+
self.highest_price_since_entry = price
|
| 99 |
+
self.trailing_stop_distance = price * (1 - self.trailing_stop_pct)
|
| 100 |
+
self.breakeven_activated = False # Reset breakeven flag
|
| 101 |
+
self._record_trade(timestamp, price, 0, 'entry', confidence, 'BUY')
|
| 102 |
+
|
| 103 |
+
elif signal < 0: # Sell
|
| 104 |
+
self.position = -position_size
|
| 105 |
+
self.entry_price = price
|
| 106 |
+
self.entry_time = timestamp
|
| 107 |
+
self.highest_price_since_entry = price
|
| 108 |
+
self.trailing_stop_distance = price * (1 + self.trailing_stop_pct)
|
| 109 |
+
self.breakeven_activated = False # Reset breakeven flag
|
| 110 |
+
self._record_trade(timestamp, price, 0, 'entry', confidence, 'SELL')
|
| 111 |
+
|
| 112 |
+
# Update trailing stops
|
| 113 |
+
if self.position != 0:
|
| 114 |
+
self._update_trailing_stops(price)
|
| 115 |
+
|
| 116 |
+
self.portfolio_values.append(self.capital)
|
| 117 |
+
return pnl, exit_reason
|
| 118 |
+
|
| 119 |
+
def _check_exits(self, price, timestamp, current_signal):
|
| 120 |
+
"""Check various exit conditions with improved profit-taking"""
|
| 121 |
+
# Calculate current profit percentage
|
| 122 |
+
if self.position > 0:
|
| 123 |
+
profit_pct = (price - self.entry_price) / self.entry_price
|
| 124 |
+
else:
|
| 125 |
+
profit_pct = (self.entry_price - price) / self.entry_price
|
| 126 |
+
|
| 127 |
+
# Breakeven stop activation
|
| 128 |
+
if not self.breakeven_activated and profit_pct >= self.breakeven_trigger_pct:
|
| 129 |
+
self.breakeven_activated = True
|
| 130 |
+
# Move trailing stop to breakeven + small buffer
|
| 131 |
+
buffer_pct = 0.005 # 0.5% buffer above breakeven
|
| 132 |
+
if self.position > 0:
|
| 133 |
+
self.trailing_stop_distance = self.entry_price * (1 + buffer_pct)
|
| 134 |
+
else:
|
| 135 |
+
self.trailing_stop_distance = self.entry_price * (1 - buffer_pct)
|
| 136 |
+
|
| 137 |
+
# Scaled profit taking - take partial profits at multiple levels
|
| 138 |
+
for target_pct in sorted(self.profit_targets, reverse=True):
|
| 139 |
+
if profit_pct >= target_pct:
|
| 140 |
+
# Calculate how much profit to take at this level
|
| 141 |
+
if target_pct <= 0.02: # Small profits (1-2%) - take 25% of position
|
| 142 |
+
profit_portion = 0.25
|
| 143 |
+
exit_reason = f'profit_{int(target_pct*100)}pct_partial'
|
| 144 |
+
elif target_pct <= 0.05: # Medium profits (5%) - take 50% of position
|
| 145 |
+
profit_portion = 0.50
|
| 146 |
+
exit_reason = f'profit_{int(target_pct*100)}pct_partial'
|
| 147 |
+
else: # Large profits (10%) - take full position
|
| 148 |
+
profit_portion = 1.0
|
| 149 |
+
exit_reason = 'take_profit'
|
| 150 |
+
|
| 151 |
+
if profit_portion < 1.0:
|
| 152 |
+
# Partial exit
|
| 153 |
+
self.position *= (1 - profit_portion)
|
| 154 |
+
return exit_reason
|
| 155 |
+
else:
|
| 156 |
+
# Full exit
|
| 157 |
+
return exit_reason
|
| 158 |
+
|
| 159 |
+
# Trailing stop check (only if breakeven not activated or profit is positive)
|
| 160 |
+
if self.position > 0 and price <= self.trailing_stop_distance:
|
| 161 |
+
return 'trailing_stop'
|
| 162 |
+
elif self.position < 0 and price >= self.trailing_stop_distance:
|
| 163 |
+
return 'trailing_stop'
|
| 164 |
+
|
| 165 |
+
# Maximum holding time - more aggressive for losing positions
|
| 166 |
+
if self.entry_time and (timestamp - self.entry_time).total_seconds() > self.max_holding_time * 3600:
|
| 167 |
+
return 'max_time'
|
| 168 |
+
|
| 169 |
+
# Early exit for significant losses (stop loss)
|
| 170 |
+
if profit_pct <= -0.03: # 3% stop loss
|
| 171 |
+
return 'stop_loss'
|
| 172 |
+
|
| 173 |
+
# Opposite signal (exit on strong reversal)
|
| 174 |
+
if (self.position > 0 and current_signal < -0.3) or (self.position < 0 and current_signal > 0.3):
|
| 175 |
+
return 'opposite_signal'
|
| 176 |
+
|
| 177 |
+
return None
|
| 178 |
+
|
| 179 |
+
def _update_regime_parameters(self, current_price, timestamp):
|
| 180 |
+
"""Update trading parameters based on current market regime"""
|
| 181 |
+
# Create a simple DataFrame with recent price history for regime detection
|
| 182 |
+
# In a real system, this would use more comprehensive market data
|
| 183 |
+
|
| 184 |
+
# For demo purposes, create synthetic OHLC data around current price
|
| 185 |
+
recent_prices = []
|
| 186 |
+
base_price = current_price
|
| 187 |
+
|
| 188 |
+
# Generate last 100 periods of synthetic data
|
| 189 |
+
for i in range(100):
|
| 190 |
+
# Add some realistic price movement
|
| 191 |
+
change = np.random.normal(0, 0.005) # 0.5% volatility
|
| 192 |
+
price = base_price * (1 + change)
|
| 193 |
+
recent_prices.append({
|
| 194 |
+
'Close': price,
|
| 195 |
+
'High': price * (1 + abs(np.random.normal(0, 0.002))),
|
| 196 |
+
'Low': price * (1 - abs(np.random.normal(0, 0.002))),
|
| 197 |
+
'Volume': np.random.randint(1000, 10000)
|
| 198 |
+
})
|
| 199 |
+
base_price = price
|
| 200 |
+
|
| 201 |
+
# Create DataFrame for regime detection
|
| 202 |
+
price_df = pd.DataFrame(recent_prices)
|
| 203 |
+
|
| 204 |
+
try:
|
| 205 |
+
# Detect current regime
|
| 206 |
+
current_regime, regime_params = self.regime_detector.detect_regime(price_df, -1)
|
| 207 |
+
|
| 208 |
+
# Update trading parameters based on regime
|
| 209 |
+
self.profit_targets = regime_params['profit_targets']
|
| 210 |
+
self.trailing_stop_pct = regime_params['trailing_stop_pct']
|
| 211 |
+
self.take_profit_pct = regime_params['profit_targets'][-1]
|
| 212 |
+
self.partial_take_profit_pct = regime_params['profit_targets'][1]
|
| 213 |
+
self.breakeven_trigger_pct = regime_params['breakeven_trigger']
|
| 214 |
+
self.max_holding_time = regime_params['max_holding_time']
|
| 215 |
+
|
| 216 |
+
# Store current regime
|
| 217 |
+
self.current_regime = current_regime
|
| 218 |
+
|
| 219 |
+
except Exception as e:
|
| 220 |
+
# If regime detection fails, use default parameters
|
| 221 |
+
self._set_default_parameters()
|
| 222 |
+
|
| 223 |
+
def _set_default_parameters(self):
|
| 224 |
+
"""Set default trading parameters"""
|
| 225 |
+
self.profit_targets = [0.01, 0.02, 0.05, 0.10]
|
| 226 |
+
self.trailing_stop_pct = 0.025
|
| 227 |
+
self.take_profit_pct = 0.10
|
| 228 |
+
self.partial_take_profit_pct = 0.02
|
| 229 |
+
self.breakeven_trigger_pct = 0.015
|
| 230 |
+
self.max_holding_time = 24
|
| 231 |
+
|
| 232 |
+
def _update_trailing_stops(self, price):
|
| 233 |
+
"""Update trailing stop levels"""
|
| 234 |
+
if self.position > 0: # Long position
|
| 235 |
+
if price > self.highest_price_since_entry:
|
| 236 |
+
self.highest_price_since_entry = price
|
| 237 |
+
self.trailing_stop_distance = price * (1 - self.trailing_stop_pct)
|
| 238 |
+
else: # Short position
|
| 239 |
+
if price < self.highest_price_since_entry:
|
| 240 |
+
self.highest_price_since_entry = price
|
| 241 |
+
self.trailing_stop_distance = price * (1 + self.trailing_stop_pct)
|
| 242 |
+
|
| 243 |
+
def _calculate_position_size(self, signal, confidence, price):
|
| 244 |
+
"""Calculate position size based on confidence"""
|
| 245 |
+
base_size = self.capital * self.leverage * min(abs(signal), 1.0) / price
|
| 246 |
+
confidence_multiplier = confidence ** 0.5 # Square root scaling
|
| 247 |
+
return base_size * confidence_multiplier
|
| 248 |
+
|
| 249 |
+
def _record_trade(self, timestamp, price, pnl, reason, confidence, action_type='EXIT'):
|
| 250 |
+
"""Record trade details"""
|
| 251 |
+
trade = {
|
| 252 |
+
'timestamp': timestamp,
|
| 253 |
+
'price': price,
|
| 254 |
+
'pnl': pnl,
|
| 255 |
+
'reason': reason,
|
| 256 |
+
'confidence': confidence,
|
| 257 |
+
'action': action_type,
|
| 258 |
+
'position_size': abs(self.position) if self.position != 0 else 0
|
| 259 |
+
}
|
| 260 |
+
self.trades.append(trade)
|
| 261 |
+
|
| 262 |
+
def generate_realistic_price_data(n_points=1000):
|
| 263 |
+
"""Generate realistic price data with trends and volatility"""
|
| 264 |
+
base_price = 2000
|
| 265 |
+
prices = [base_price]
|
| 266 |
+
timestamps = [datetime.now() + timedelta(hours=i) for i in range(n_points)]
|
| 267 |
+
|
| 268 |
+
# Generate price movements
|
| 269 |
+
for i in range(1, n_points):
|
| 270 |
+
# Trend component
|
| 271 |
+
trend = 0.001 * np.sin(i * 0.01) # Slow trend
|
| 272 |
+
|
| 273 |
+
# Volatility component
|
| 274 |
+
volatility = np.random.normal(0, 0.02)
|
| 275 |
+
|
| 276 |
+
# Momentum component
|
| 277 |
+
momentum = 0.1 * (prices[-1] - prices[-2]) / prices[-2] if len(prices) > 1 else 0
|
| 278 |
+
|
| 279 |
+
# Combine components
|
| 280 |
+
price_change = trend + volatility + momentum
|
| 281 |
+
new_price = prices[-1] * (1 + price_change)
|
| 282 |
+
|
| 283 |
+
# Ensure reasonable bounds
|
| 284 |
+
new_price = max(1800, min(2200, new_price))
|
| 285 |
+
prices.append(new_price)
|
| 286 |
+
|
| 287 |
+
return pd.DataFrame({
|
| 288 |
+
'timestamp': timestamps,
|
| 289 |
+
'price': prices
|
| 290 |
+
})
|
| 291 |
+
|
| 292 |
+
def generate_trading_signals(price_data):
|
| 293 |
+
"""Generate realistic trading signals"""
|
| 294 |
+
signals = []
|
| 295 |
+
confidences = []
|
| 296 |
+
|
| 297 |
+
for i, row in price_data.iterrows():
|
| 298 |
+
price = row['price']
|
| 299 |
+
|
| 300 |
+
# Simple trend signal
|
| 301 |
+
if i > 20:
|
| 302 |
+
short_ma = price_data['price'].iloc[i-10:i].mean()
|
| 303 |
+
long_ma = price_data['price'].iloc[i-20:i].mean()
|
| 304 |
+
trend_signal = 2 * (short_ma - long_ma) / long_ma # Amplified signal
|
| 305 |
+
else:
|
| 306 |
+
trend_signal = 0
|
| 307 |
+
|
| 308 |
+
# Volatility-based confidence
|
| 309 |
+
if i > 10:
|
| 310 |
+
returns = price_data['price'].iloc[i-10:i].pct_change()
|
| 311 |
+
volatility = returns.std()
|
| 312 |
+
market_condition = max(0.5, min(1.5, 1 / (1 + volatility * 10)))
|
| 313 |
+
else:
|
| 314 |
+
market_condition = 1.0
|
| 315 |
+
|
| 316 |
+
# Add some noise to signals
|
| 317 |
+
noise = np.random.normal(0, 0.2) # Increased noise
|
| 318 |
+
signal = trend_signal + noise
|
| 319 |
+
|
| 320 |
+
confidence = min(1.0, abs(signal) * market_condition)
|
| 321 |
+
|
| 322 |
+
signals.append(signal)
|
| 323 |
+
confidences.append(confidence)
|
| 324 |
+
|
| 325 |
+
price_data['signal'] = signals
|
| 326 |
+
price_data['confidence'] = confidences
|
| 327 |
+
|
| 328 |
+
return price_data
|
| 329 |
+
|
| 330 |
+
def run_advanced_trading_demo():
|
| 331 |
+
"""Run comprehensive demo of advanced trading features"""
|
| 332 |
+
print("🚀 Advanced Trading System Demo")
|
| 333 |
+
print("=" * 50)
|
| 334 |
+
print("Features:")
|
| 335 |
+
print("• Confidence-based position sizing")
|
| 336 |
+
print("• Trailing stops (5%)")
|
| 337 |
+
print("• Profit taking (5% partial, 10% full)")
|
| 338 |
+
print("• Maximum holding time (24 hours)")
|
| 339 |
+
print("• Opposite signal exits")
|
| 340 |
+
print()
|
| 341 |
+
|
| 342 |
+
# Generate data
|
| 343 |
+
price_data = generate_realistic_price_data(500)
|
| 344 |
+
trading_data = generate_trading_signals(price_data)
|
| 345 |
+
|
| 346 |
+
# Initialize trading system
|
| 347 |
+
trader = AdvancedTradingSystem(capital=1000, leverage=50)
|
| 348 |
+
|
| 349 |
+
# Execute trades
|
| 350 |
+
print("Executing trades...")
|
| 351 |
+
for i, row in trading_data.iterrows():
|
| 352 |
+
pnl, exit_reason = trader.execute_trade(
|
| 353 |
+
row['signal'],
|
| 354 |
+
row['confidence'],
|
| 355 |
+
row['price'],
|
| 356 |
+
row['timestamp']
|
| 357 |
+
)
|
| 358 |
+
|
| 359 |
+
if i % 100 == 0:
|
| 360 |
+
print(f"Processed {i}/{len(trading_data)} data points...")
|
| 361 |
+
|
| 362 |
+
print("\n✅ Trading simulation completed!")
|
| 363 |
+
print(f"Final Portfolio Value: ${trader.capital:.2f}")
|
| 364 |
+
|
| 365 |
+
# Analyze results
|
| 366 |
+
analyze_results(trader)
|
| 367 |
+
|
| 368 |
+
# Plot results
|
| 369 |
+
plot_advanced_results(trader, trading_data)
|
| 370 |
+
|
| 371 |
+
def analyze_results(trader):
|
| 372 |
+
"""Analyze trading performance"""
|
| 373 |
+
if not trader.trades:
|
| 374 |
+
print("No trades executed")
|
| 375 |
+
return
|
| 376 |
+
|
| 377 |
+
df_trades = pd.DataFrame(trader.trades)
|
| 378 |
+
|
| 379 |
+
# Separate entries and exits
|
| 380 |
+
entries = df_trades[df_trades['action'].isin(['BUY', 'SELL'])]
|
| 381 |
+
exits = df_trades[df_trades['action'] == 'EXIT']
|
| 382 |
+
|
| 383 |
+
print("\n📊 Performance Analysis:")
|
| 384 |
+
print(f"Total Trades: {len(entries)}")
|
| 385 |
+
print(f"Total Exits: {len(exits)}")
|
| 386 |
+
|
| 387 |
+
if len(exits) > 0:
|
| 388 |
+
profitable_trades = len(exits[exits['pnl'] > 0])
|
| 389 |
+
win_rate = profitable_trades / len(exits) * 100
|
| 390 |
+
avg_win = exits[exits['pnl'] > 0]['pnl'].mean() if profitable_trades > 0 else 0
|
| 391 |
+
avg_loss = exits[exits['pnl'] < 0]['pnl'].mean() if len(exits[exits['pnl'] < 0]) > 0 else 0
|
| 392 |
+
|
| 393 |
+
print(f"Win Rate: {win_rate:.1f}%")
|
| 394 |
+
print(f"Average Win: ${avg_win:.2f}")
|
| 395 |
+
print(f"Average Loss: ${avg_loss:.2f}")
|
| 396 |
+
|
| 397 |
+
# Exit reason analysis
|
| 398 |
+
exit_reasons = exits['reason'].value_counts()
|
| 399 |
+
print("\nExit Reasons:")
|
| 400 |
+
for reason, count in exit_reasons.items():
|
| 401 |
+
pct = count / len(exits) * 100
|
| 402 |
+
print(f" {reason}: {count} ({pct:.1f}%)")
|
| 403 |
+
def plot_advanced_results(trader, price_data):
|
| 404 |
+
"""Plot comprehensive results"""
|
| 405 |
+
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
|
| 406 |
+
|
| 407 |
+
# Price chart with trades
|
| 408 |
+
ax1.plot(price_data['timestamp'], price_data['price'], alpha=0.7)
|
| 409 |
+
|
| 410 |
+
# Plot trades
|
| 411 |
+
if trader.trades:
|
| 412 |
+
df_trades = pd.DataFrame(trader.trades)
|
| 413 |
+
entries = df_trades[df_trades['action'].isin(['BUY', 'SELL'])]
|
| 414 |
+
|
| 415 |
+
buy_signals = entries[entries['action'] == 'BUY']
|
| 416 |
+
sell_signals = entries[entries['action'] == 'SELL']
|
| 417 |
+
|
| 418 |
+
ax1.scatter(buy_signals['timestamp'], buy_signals['price'],
|
| 419 |
+
color='green', marker='^', s=100, label='Buy')
|
| 420 |
+
ax1.scatter(sell_signals['timestamp'], sell_signals['price'],
|
| 421 |
+
color='red', marker='v', s=100, label='Sell')
|
| 422 |
+
|
| 423 |
+
ax1.set_title('Price Chart with Trade Signals')
|
| 424 |
+
ax1.set_ylabel('Price')
|
| 425 |
+
ax1.legend()
|
| 426 |
+
ax1.grid(True)
|
| 427 |
+
|
| 428 |
+
# Portfolio value over time
|
| 429 |
+
ax2.plot(trader.portfolio_values)
|
| 430 |
+
ax2.set_title('Portfolio Value Over Time')
|
| 431 |
+
ax2.set_ylabel('Portfolio Value ($)')
|
| 432 |
+
ax2.grid(True)
|
| 433 |
+
|
| 434 |
+
# P&L distribution by exit reason
|
| 435 |
+
if trader.trades:
|
| 436 |
+
df_trades = pd.DataFrame(trader.trades)
|
| 437 |
+
exits = df_trades[df_trades['action'] != 'entry']
|
| 438 |
+
|
| 439 |
+
if len(exits) > 0:
|
| 440 |
+
exit_reasons = exits['reason'].unique()
|
| 441 |
+
pnl_by_reason = [exits[exits['reason'] == reason]['pnl'] for reason in exit_reasons]
|
| 442 |
+
|
| 443 |
+
ax3.boxplot(pnl_by_reason, tick_labels=exit_reasons)
|
| 444 |
+
ax3.set_title('P&L Distribution by Exit Reason')
|
| 445 |
+
ax3.set_ylabel('P&L ($)')
|
| 446 |
+
ax3.grid(True)
|
| 447 |
+
|
| 448 |
+
# Confidence vs P&L
|
| 449 |
+
if trader.trades:
|
| 450 |
+
df_trades = pd.DataFrame(trader.trades)
|
| 451 |
+
exits = df_trades[df_trades['action'] != 'entry']
|
| 452 |
+
|
| 453 |
+
if len(exits) > 0:
|
| 454 |
+
colors = ['green' if x > 0 else 'red' for x in exits['pnl']]
|
| 455 |
+
ax4.scatter(exits['confidence'], exits['pnl'], c=colors, alpha=0.6)
|
| 456 |
+
ax4.set_title('Confidence vs P&L')
|
| 457 |
+
ax4.set_xlabel('Confidence')
|
| 458 |
+
ax4.set_ylabel('P&L ($)')
|
| 459 |
+
ax4.grid(True)
|
| 460 |
+
|
| 461 |
+
plt.tight_layout()
|
| 462 |
+
plt.savefig('advanced_trading_demo.png', dpi=300, bbox_inches='tight')
|
| 463 |
+
plt.show()
|
| 464 |
+
|
| 465 |
+
if __name__ == "__main__":
|
| 466 |
+
run_advanced_trading_demo()
|
code/ensemble_trader.py
ADDED
|
@@ -0,0 +1,212 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/usr/bin/env python3
|
| 2 |
+
"""
|
| 3 |
+
Ensemble Trading System
|
| 4 |
+
Combines multiple RL models for better trading decisions
|
| 5 |
+
"""
|
| 6 |
+
|
| 7 |
+
import pandas as pd
|
| 8 |
+
import numpy as np
|
| 9 |
+
from stable_baselines3 import PPO, TD3, SAC
|
| 10 |
+
from stable_baselines3.common.vec_env import DummyVecEnv
|
| 11 |
+
from trading_env import TradingEnv
|
| 12 |
+
import os
|
| 13 |
+
import json
|
| 14 |
+
|
| 15 |
+
class EnsembleTrader:
|
| 16 |
+
"""
|
| 17 |
+
Ensemble trading system that combines predictions from multiple RL models
|
| 18 |
+
"""
|
| 19 |
+
|
| 20 |
+
def __init__(self, models_config=None):
|
| 21 |
+
if models_config is None:
|
| 22 |
+
self.models_config = {
|
| 23 |
+
'ppo': {'algorithm': 'PPO', 'policy': 'MlpPolicy', 'timesteps': 10000},
|
| 24 |
+
'td3': {'algorithm': 'TD3', 'policy': 'MlpPolicy', 'timesteps': 10000},
|
| 25 |
+
'sac': {'algorithm': 'SAC', 'policy': 'MlpPolicy', 'timesteps': 10000}
|
| 26 |
+
}
|
| 27 |
+
else:
|
| 28 |
+
self.models_config = models_config
|
| 29 |
+
|
| 30 |
+
self.models = {}
|
| 31 |
+
self.model_weights = {}
|
| 32 |
+
|
| 33 |
+
def create_ensemble_env(self, df):
|
| 34 |
+
"""Create environment for ensemble training"""
|
| 35 |
+
def make_env():
|
| 36 |
+
return TradingEnv(df)
|
| 37 |
+
return DummyVecEnv([make_env])
|
| 38 |
+
|
| 39 |
+
def train_ensemble(self, train_df, save_path='./ensemble_models/'):
|
| 40 |
+
"""Train all models in the ensemble"""
|
| 41 |
+
os.makedirs(save_path, exist_ok=True)
|
| 42 |
+
|
| 43 |
+
for model_name, config in self.models_config.items():
|
| 44 |
+
print(f"Training {model_name.upper()} model...")
|
| 45 |
+
|
| 46 |
+
# Get algorithm class
|
| 47 |
+
if config['algorithm'] == 'PPO':
|
| 48 |
+
model_class = PPO
|
| 49 |
+
elif config['algorithm'] == 'TD3':
|
| 50 |
+
model_class = TD3
|
| 51 |
+
elif config['algorithm'] == 'SAC':
|
| 52 |
+
model_class = SAC
|
| 53 |
+
else:
|
| 54 |
+
raise ValueError(f"Unknown algorithm: {config['algorithm']}")
|
| 55 |
+
|
| 56 |
+
# Create environment
|
| 57 |
+
env = self.create_ensemble_env(train_df)
|
| 58 |
+
|
| 59 |
+
# Initialize model
|
| 60 |
+
model = model_class(config['policy'], env, verbose=0)
|
| 61 |
+
|
| 62 |
+
# Train model
|
| 63 |
+
model.learn(total_timesteps=config['timesteps'])
|
| 64 |
+
|
| 65 |
+
# Save model
|
| 66 |
+
model_path = os.path.join(save_path, f'{model_name}_model.zip')
|
| 67 |
+
model.save(model_path)
|
| 68 |
+
|
| 69 |
+
# Store model
|
| 70 |
+
self.models[model_name] = model
|
| 71 |
+
self.model_weights[model_name] = 1.0 # Equal weights initially
|
| 72 |
+
|
| 73 |
+
print(f"✅ {model_name.upper()} model trained and saved")
|
| 74 |
+
|
| 75 |
+
# Save ensemble configuration
|
| 76 |
+
config_path = os.path.join(save_path, 'ensemble_config.json')
|
| 77 |
+
with open(config_path, 'w') as f:
|
| 78 |
+
json.dump({
|
| 79 |
+
'models': list(self.models.keys()),
|
| 80 |
+
'weights': self.model_weights,
|
| 81 |
+
'config': self.models_config
|
| 82 |
+
}, f, indent=2)
|
| 83 |
+
|
| 84 |
+
print("🎯 Ensemble training completed!")
|
| 85 |
+
|
| 86 |
+
def load_ensemble(self, load_path='./ensemble_models/'):
|
| 87 |
+
"""Load trained ensemble models"""
|
| 88 |
+
config_path = os.path.join(load_path, 'ensemble_config.json')
|
| 89 |
+
with open(config_path, 'r') as f:
|
| 90 |
+
config = json.load(f)
|
| 91 |
+
|
| 92 |
+
self.model_weights = config['weights']
|
| 93 |
+
|
| 94 |
+
for model_name in config['models']:
|
| 95 |
+
model_path = os.path.join(load_path, f'{model_name}_model.zip')
|
| 96 |
+
|
| 97 |
+
# Get algorithm class from config
|
| 98 |
+
model_config = config['config'][model_name]
|
| 99 |
+
algorithm_name = model_config['algorithm']
|
| 100 |
+
|
| 101 |
+
if algorithm_name == 'PPO':
|
| 102 |
+
model_class = PPO
|
| 103 |
+
elif algorithm_name == 'TD3':
|
| 104 |
+
model_class = TD3
|
| 105 |
+
elif algorithm_name == 'SAC':
|
| 106 |
+
model_class = SAC
|
| 107 |
+
else:
|
| 108 |
+
raise ValueError(f"Unknown algorithm: {algorithm_name}")
|
| 109 |
+
|
| 110 |
+
# Load model
|
| 111 |
+
self.models[model_name] = model_class.load(model_path)
|
| 112 |
+
|
| 113 |
+
print(f"✅ Loaded ensemble with {len(self.models)} models")
|
| 114 |
+
|
| 115 |
+
def predict_ensemble(self, observation, method='weighted_vote'):
|
| 116 |
+
"""Get ensemble prediction with confidence score"""
|
| 117 |
+
predictions = {}
|
| 118 |
+
confidences = {}
|
| 119 |
+
|
| 120 |
+
for model_name, model in self.models.items():
|
| 121 |
+
action, _states = model.predict(observation, deterministic=True)
|
| 122 |
+
predictions[model_name] = action[0]
|
| 123 |
+
|
| 124 |
+
# Calculate confidence based on action magnitude and model agreement
|
| 125 |
+
confidences[model_name] = abs(action[0])
|
| 126 |
+
|
| 127 |
+
if method == 'weighted_vote':
|
| 128 |
+
action, confidence = self._weighted_vote_with_confidence(predictions, confidences)
|
| 129 |
+
elif method == 'average':
|
| 130 |
+
action, confidence = self._average_prediction_with_confidence(predictions)
|
| 131 |
+
else:
|
| 132 |
+
action, confidence = self._majority_vote_with_confidence(predictions)
|
| 133 |
+
|
| 134 |
+
return action, confidence
|
| 135 |
+
|
| 136 |
+
def _weighted_vote_with_confidence(self, predictions, confidences):
|
| 137 |
+
"""Weighted voting based on model confidence with confidence score"""
|
| 138 |
+
buy_votes = 0
|
| 139 |
+
sell_votes = 0
|
| 140 |
+
hold_votes = 0
|
| 141 |
+
total_weight = 0
|
| 142 |
+
|
| 143 |
+
for model_name, pred in predictions.items():
|
| 144 |
+
weight = confidences[model_name]
|
| 145 |
+
total_weight += weight
|
| 146 |
+
|
| 147 |
+
if pred > 0.1:
|
| 148 |
+
buy_votes += weight
|
| 149 |
+
elif pred < -0.1:
|
| 150 |
+
sell_votes += weight
|
| 151 |
+
else:
|
| 152 |
+
hold_votes += weight
|
| 153 |
+
|
| 154 |
+
# Calculate overall confidence as the strength of the winning vote
|
| 155 |
+
max_votes = max(buy_votes, sell_votes, hold_votes)
|
| 156 |
+
confidence = max_votes / total_weight if total_weight > 0 else 0
|
| 157 |
+
|
| 158 |
+
# Return the action with highest weighted votes
|
| 159 |
+
if buy_votes > sell_votes and buy_votes > hold_votes:
|
| 160 |
+
return 0.5 * confidence, confidence # Scale action by confidence
|
| 161 |
+
elif sell_votes > buy_votes and sell_votes > hold_votes:
|
| 162 |
+
return -0.5 * confidence, confidence # Scale action by confidence
|
| 163 |
+
else:
|
| 164 |
+
return 0.0, confidence
|
| 165 |
+
|
| 166 |
+
def _average_prediction_with_confidence(self, predictions):
|
| 167 |
+
"""Simple average of all predictions with confidence"""
|
| 168 |
+
avg_prediction = np.mean(list(predictions.values()))
|
| 169 |
+
|
| 170 |
+
# Confidence based on agreement (lower variance = higher confidence)
|
| 171 |
+
variance = np.var(list(predictions.values()))
|
| 172 |
+
confidence = max(0, 1 - variance) # Scale variance to confidence
|
| 173 |
+
|
| 174 |
+
return avg_prediction, confidence
|
| 175 |
+
|
| 176 |
+
def _majority_vote_with_confidence(self, predictions):
|
| 177 |
+
"""Majority voting with confidence"""
|
| 178 |
+
buy_count = sum(1 for p in predictions.values() if p > 0.1)
|
| 179 |
+
sell_count = sum(1 for p in predictions.values() if p < -0.1)
|
| 180 |
+
hold_count = len(predictions) - buy_count - sell_count
|
| 181 |
+
|
| 182 |
+
total_votes = len(predictions)
|
| 183 |
+
max_count = max(buy_count, sell_count, hold_count)
|
| 184 |
+
confidence = max_count / total_votes
|
| 185 |
+
|
| 186 |
+
if buy_count > sell_count and buy_count > hold_count:
|
| 187 |
+
return 0.5, confidence
|
| 188 |
+
elif sell_count > buy_count and sell_count > hold_count:
|
| 189 |
+
return -0.5, confidence
|
| 190 |
+
else:
|
| 191 |
+
return 0.0, confidence
|
| 192 |
+
|
| 193 |
+
def main():
|
| 194 |
+
"""Main ensemble training function"""
|
| 195 |
+
# Load data
|
| 196 |
+
df = pd.read_csv('xauusd_data.csv', parse_dates=['date'], index_col='date')
|
| 197 |
+
|
| 198 |
+
# Split data
|
| 199 |
+
train_end = int(len(df) * 0.8)
|
| 200 |
+
train_df = df.iloc[:train_end]
|
| 201 |
+
|
| 202 |
+
# Create and train ensemble
|
| 203 |
+
ensemble = EnsembleTrader()
|
| 204 |
+
ensemble.train_ensemble(train_df)
|
| 205 |
+
|
| 206 |
+
print("\n🚀 Ensemble Trading System Ready!")
|
| 207 |
+
print("Models trained: PPO, TD3, SAC")
|
| 208 |
+
print("Prediction method: Weighted voting")
|
| 209 |
+
print("Ready for live trading!")
|
| 210 |
+
|
| 211 |
+
if __name__ == "__main__":
|
| 212 |
+
main()
|
code/market_regime_detector.py
ADDED
|
@@ -0,0 +1,435 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/usr/bin/env python3
|
| 2 |
+
"""
|
| 3 |
+
Market Regime Detection System
|
| 4 |
+
Identifies trending vs ranging markets and provides regime-adaptive trading parameters
|
| 5 |
+
"""
|
| 6 |
+
|
| 7 |
+
import pandas as pd
|
| 8 |
+
import numpy as np
|
| 9 |
+
from enum import Enum
|
| 10 |
+
from typing import Dict, List, Tuple, Optional
|
| 11 |
+
import warnings
|
| 12 |
+
warnings.filterwarnings('ignore')
|
| 13 |
+
|
| 14 |
+
class MarketRegime(Enum):
|
| 15 |
+
"""Market regime classifications"""
|
| 16 |
+
STRONG_BULL = "strong_bull"
|
| 17 |
+
BULL_TREND = "bull_trend"
|
| 18 |
+
BEAR_TREND = "bear_trend"
|
| 19 |
+
STRONG_BEAR = "strong_bear"
|
| 20 |
+
RANGING = "ranging"
|
| 21 |
+
HIGH_VOLATILITY = "high_volatility"
|
| 22 |
+
LOW_VOLATILITY = "low_volatility"
|
| 23 |
+
|
| 24 |
+
class RegimeParameters:
|
| 25 |
+
"""Trading parameters optimized for each market regime"""
|
| 26 |
+
|
| 27 |
+
def __init__(self):
|
| 28 |
+
# Base parameters for each regime
|
| 29 |
+
self.regime_params = {
|
| 30 |
+
MarketRegime.STRONG_BULL: {
|
| 31 |
+
'profit_targets': [0.015, 0.03, 0.06, 0.12], # Higher targets in strong trends
|
| 32 |
+
'trailing_stop_pct': 0.03, # Tighter stops to capture momentum
|
| 33 |
+
'position_size_multiplier': 1.5, # Larger positions in strong trends
|
| 34 |
+
'max_holding_time': 48, # Longer holding in trends
|
| 35 |
+
'breakeven_trigger': 0.02, # Later breakeven
|
| 36 |
+
'min_confidence_threshold': 0.25, # Lower threshold for strong trends
|
| 37 |
+
},
|
| 38 |
+
MarketRegime.BULL_TREND: {
|
| 39 |
+
'profit_targets': [0.012, 0.025, 0.05, 0.10],
|
| 40 |
+
'trailing_stop_pct': 0.025,
|
| 41 |
+
'position_size_multiplier': 1.2,
|
| 42 |
+
'max_holding_time': 36,
|
| 43 |
+
'breakeven_trigger': 0.018,
|
| 44 |
+
'min_confidence_threshold': 0.3,
|
| 45 |
+
},
|
| 46 |
+
MarketRegime.BEAR_TREND: {
|
| 47 |
+
'profit_targets': [0.012, 0.025, 0.05, 0.10],
|
| 48 |
+
'trailing_stop_pct': 0.025,
|
| 49 |
+
'position_size_multiplier': 1.2,
|
| 50 |
+
'max_holding_time': 36,
|
| 51 |
+
'breakeven_trigger': 0.018,
|
| 52 |
+
'min_confidence_threshold': 0.3,
|
| 53 |
+
},
|
| 54 |
+
MarketRegime.STRONG_BEAR: {
|
| 55 |
+
'profit_targets': [0.015, 0.03, 0.06, 0.12],
|
| 56 |
+
'trailing_stop_pct': 0.03,
|
| 57 |
+
'position_size_multiplier': 1.5,
|
| 58 |
+
'max_holding_time': 48,
|
| 59 |
+
'breakeven_trigger': 0.02,
|
| 60 |
+
'min_confidence_threshold': 0.25,
|
| 61 |
+
},
|
| 62 |
+
MarketRegime.RANGING: {
|
| 63 |
+
'profit_targets': [0.008, 0.015, 0.03, 0.06], # Lower targets in ranging markets
|
| 64 |
+
'trailing_stop_pct': 0.02, # Tighter stops to protect against whipsaws
|
| 65 |
+
'position_size_multiplier': 0.7, # Smaller positions in ranging markets
|
| 66 |
+
'max_holding_time': 12, # Shorter holding periods
|
| 67 |
+
'breakeven_trigger': 0.012, # Earlier breakeven
|
| 68 |
+
'min_confidence_threshold': 0.4, # Higher threshold for ranging markets
|
| 69 |
+
},
|
| 70 |
+
MarketRegime.HIGH_VOLATILITY: {
|
| 71 |
+
'profit_targets': [0.02, 0.04, 0.08, 0.15], # Higher targets for volatility
|
| 72 |
+
'trailing_stop_pct': 0.04, # Wider stops for volatility
|
| 73 |
+
'position_size_multiplier': 0.6, # Smaller positions in high volatility
|
| 74 |
+
'max_holding_time': 8, # Very short holding periods
|
| 75 |
+
'breakeven_trigger': 0.025, # Later breakeven for volatility
|
| 76 |
+
'min_confidence_threshold': 0.5, # Much higher threshold
|
| 77 |
+
},
|
| 78 |
+
MarketRegime.LOW_VOLATILITY: {
|
| 79 |
+
'profit_targets': [0.005, 0.01, 0.02, 0.04], # Lower targets in low volatility
|
| 80 |
+
'trailing_stop_pct': 0.015, # Tighter stops
|
| 81 |
+
'position_size_multiplier': 1.0, # Normal positions
|
| 82 |
+
'max_holding_time': 24, # Normal holding periods
|
| 83 |
+
'breakeven_trigger': 0.008, # Earlier breakeven
|
| 84 |
+
'min_confidence_threshold': 0.35, # Moderate threshold
|
| 85 |
+
}
|
| 86 |
+
}
|
| 87 |
+
|
| 88 |
+
def get_parameters(self, regime: MarketRegime) -> Dict:
|
| 89 |
+
"""Get trading parameters for a specific regime"""
|
| 90 |
+
return self.regime_params.get(regime, self.regime_params[MarketRegime.RANGING])
|
| 91 |
+
|
| 92 |
+
class MarketRegimeDetector:
|
| 93 |
+
"""
|
| 94 |
+
Advanced market regime detection using multiple indicators
|
| 95 |
+
"""
|
| 96 |
+
|
| 97 |
+
def __init__(self, lookback_periods: List[int] = [20, 50, 100]):
|
| 98 |
+
self.lookback_periods = lookback_periods
|
| 99 |
+
self.regime_history = []
|
| 100 |
+
self.parameters = RegimeParameters()
|
| 101 |
+
|
| 102 |
+
def detect_regime(self, price_data: pd.DataFrame, current_idx: int = -1) -> Tuple[MarketRegime, Dict]:
|
| 103 |
+
"""
|
| 104 |
+
Detect current market regime using comprehensive analysis
|
| 105 |
+
|
| 106 |
+
Args:
|
| 107 |
+
price_data: DataFrame with OHLC and technical indicators
|
| 108 |
+
current_idx: Current index in the data (default: latest)
|
| 109 |
+
|
| 110 |
+
Returns:
|
| 111 |
+
Tuple of (detected_regime, regime_parameters)
|
| 112 |
+
"""
|
| 113 |
+
if len(price_data) < max(self.lookback_periods):
|
| 114 |
+
return MarketRegime.RANGING, self.parameters.get_parameters(MarketRegime.RANGING)
|
| 115 |
+
|
| 116 |
+
# Extract current window
|
| 117 |
+
if current_idx == -1:
|
| 118 |
+
current_idx = len(price_data) - 1
|
| 119 |
+
|
| 120 |
+
# Calculate regime indicators
|
| 121 |
+
trend_strength = self._calculate_trend_strength(price_data, current_idx)
|
| 122 |
+
volatility = self._calculate_volatility(price_data, current_idx)
|
| 123 |
+
momentum = self._calculate_momentum(price_data, current_idx)
|
| 124 |
+
volume_trend = self._calculate_volume_trend(price_data, current_idx)
|
| 125 |
+
|
| 126 |
+
# Determine primary regime
|
| 127 |
+
regime = self._classify_regime(trend_strength, volatility, momentum, volume_trend)
|
| 128 |
+
|
| 129 |
+
# Get regime-specific parameters
|
| 130 |
+
regime_params = self.parameters.get_parameters(regime)
|
| 131 |
+
|
| 132 |
+
# Store regime history
|
| 133 |
+
self.regime_history.append({
|
| 134 |
+
'timestamp': price_data.index[current_idx] if hasattr(price_data.index, '__getitem__') else current_idx,
|
| 135 |
+
'regime': regime,
|
| 136 |
+
'trend_strength': trend_strength,
|
| 137 |
+
'volatility': volatility,
|
| 138 |
+
'momentum': momentum
|
| 139 |
+
})
|
| 140 |
+
|
| 141 |
+
return regime, regime_params
|
| 142 |
+
|
| 143 |
+
def _calculate_trend_strength(self, data: pd.DataFrame, idx: int) -> float:
|
| 144 |
+
"""Calculate trend strength using ADX-like indicator"""
|
| 145 |
+
if 'High' not in data.columns or 'Low' not in data.columns or 'Close' not in data.columns:
|
| 146 |
+
# Fallback for data without OHLC
|
| 147 |
+
if 'Close' in data.columns:
|
| 148 |
+
prices = data['Close'].iloc[max(0, idx-50):idx+1]
|
| 149 |
+
if len(prices) > 10:
|
| 150 |
+
# Simple trend strength based on slope
|
| 151 |
+
x = np.arange(len(prices))
|
| 152 |
+
slope = np.polyfit(x, prices.values, 1)[0]
|
| 153 |
+
return abs(slope) / prices.std() # Normalized slope
|
| 154 |
+
return 0.0
|
| 155 |
+
|
| 156 |
+
# Calculate True Range
|
| 157 |
+
high = data['High'].iloc[max(0, idx-50):idx+1]
|
| 158 |
+
low = data['Low'].iloc[max(0, idx-50):idx+1]
|
| 159 |
+
close = data['Close'].iloc[max(0, idx-50):idx+1]
|
| 160 |
+
|
| 161 |
+
tr = np.maximum(high - low,
|
| 162 |
+
np.maximum(abs(high - close.shift(1)),
|
| 163 |
+
abs(low - close.shift(1))))
|
| 164 |
+
|
| 165 |
+
# Calculate Directional Movement
|
| 166 |
+
dm_plus = np.where((high - high.shift(1)) > (low.shift(1) - low),
|
| 167 |
+
np.maximum(high - high.shift(1), 0), 0)
|
| 168 |
+
dm_minus = np.where((low.shift(1) - low) > (high - high.shift(1)),
|
| 169 |
+
np.maximum(low.shift(1) - low, 0), 0)
|
| 170 |
+
|
| 171 |
+
# Convert to pandas Series for rolling operations
|
| 172 |
+
dm_plus_series = pd.Series(dm_plus, index=high.index)
|
| 173 |
+
dm_minus_series = pd.Series(dm_minus, index=high.index)
|
| 174 |
+
tr_series = pd.Series(tr, index=high.index)
|
| 175 |
+
|
| 176 |
+
# Smooth with Wilder's smoothing
|
| 177 |
+
atr = tr_series.rolling(14).mean()
|
| 178 |
+
di_plus = 100 * (dm_plus_series.rolling(14).mean() / atr)
|
| 179 |
+
di_minus = 100 * (dm_minus_series.rolling(14).mean() / atr)
|
| 180 |
+
|
| 181 |
+
# ADX (trend strength)
|
| 182 |
+
dx = 100 * abs(di_plus - di_minus) / (di_plus + di_minus)
|
| 183 |
+
adx = dx.rolling(14).mean()
|
| 184 |
+
|
| 185 |
+
return adx.iloc[-1] if not adx.empty else 0.0
|
| 186 |
+
|
| 187 |
+
def _calculate_volatility(self, data: pd.DataFrame, idx: int) -> float:
|
| 188 |
+
"""Calculate normalized volatility"""
|
| 189 |
+
if 'Close' not in data.columns:
|
| 190 |
+
return 0.0
|
| 191 |
+
|
| 192 |
+
prices = data['Close'].iloc[max(0, idx-50):idx+1]
|
| 193 |
+
if len(prices) < 10:
|
| 194 |
+
return 0.0
|
| 195 |
+
|
| 196 |
+
# Calculate multiple volatility measures
|
| 197 |
+
returns = prices.pct_change().dropna()
|
| 198 |
+
|
| 199 |
+
# Bollinger Band width (normalized)
|
| 200 |
+
sma = prices.rolling(20).mean()
|
| 201 |
+
std = prices.rolling(20).std()
|
| 202 |
+
bb_width = 2 * std / sma
|
| 203 |
+
bb_volatility = bb_width.iloc[-1] if not bb_width.empty else 0
|
| 204 |
+
|
| 205 |
+
# ATR if available
|
| 206 |
+
if 'High' in data.columns and 'Low' in data.columns:
|
| 207 |
+
high = data['High'].iloc[max(0, idx-20):idx+1]
|
| 208 |
+
low = data['Low'].iloc[max(0, idx-20):idx+1]
|
| 209 |
+
close = data['Close'].iloc[max(0, idx-20):idx+1]
|
| 210 |
+
|
| 211 |
+
tr = np.maximum(high - low,
|
| 212 |
+
np.maximum(abs(high - close.shift(1)),
|
| 213 |
+
abs(low - close.shift(1))))
|
| 214 |
+
atr = tr.rolling(14).mean()
|
| 215 |
+
atr_volatility = atr.iloc[-1] / prices.iloc[-1] if not atr.empty else 0
|
| 216 |
+
else:
|
| 217 |
+
atr_volatility = 0
|
| 218 |
+
|
| 219 |
+
# Return volatility
|
| 220 |
+
ret_volatility = returns.std() * np.sqrt(252) # Annualized
|
| 221 |
+
|
| 222 |
+
# Combine measures
|
| 223 |
+
combined_volatility = (bb_volatility * 0.4 + atr_volatility * 0.4 + ret_volatility * 0.2)
|
| 224 |
+
|
| 225 |
+
return combined_volatility
|
| 226 |
+
|
| 227 |
+
def _calculate_momentum(self, data: pd.DataFrame, idx: int) -> float:
|
| 228 |
+
"""Calculate momentum indicators"""
|
| 229 |
+
if 'Close' not in data.columns:
|
| 230 |
+
return 0.0
|
| 231 |
+
|
| 232 |
+
prices = data['Close'].iloc[max(0, idx-50):idx+1]
|
| 233 |
+
if len(prices) < 20:
|
| 234 |
+
return 0.0
|
| 235 |
+
|
| 236 |
+
# RSI
|
| 237 |
+
delta = prices.diff()
|
| 238 |
+
gain = (delta.where(delta > 0, 0)).rolling(14).mean()
|
| 239 |
+
loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
|
| 240 |
+
rs = gain / loss
|
| 241 |
+
rsi = 100 - (100 / (1 + rs))
|
| 242 |
+
rsi_value = rsi.iloc[-1] if not rsi.empty else 50
|
| 243 |
+
|
| 244 |
+
# MACD momentum
|
| 245 |
+
ema12 = prices.ewm(span=12).mean()
|
| 246 |
+
ema26 = prices.ewm(span=26).mean()
|
| 247 |
+
macd = ema12 - ema26
|
| 248 |
+
macd_signal = macd.ewm(span=9).mean()
|
| 249 |
+
macd_momentum = (macd - macd_signal).iloc[-1] if not macd.empty else 0
|
| 250 |
+
|
| 251 |
+
# Normalize RSI to momentum score (-1 to 1)
|
| 252 |
+
rsi_momentum = (rsi_value - 50) / 50
|
| 253 |
+
|
| 254 |
+
# Combine momentum indicators
|
| 255 |
+
combined_momentum = (rsi_momentum * 0.6 + np.sign(macd_momentum) * 0.4)
|
| 256 |
+
|
| 257 |
+
return combined_momentum
|
| 258 |
+
|
| 259 |
+
def _calculate_volume_trend(self, data: pd.DataFrame, idx: int) -> float:
|
| 260 |
+
"""Calculate volume trend if volume data is available"""
|
| 261 |
+
if 'Volume' not in data.columns:
|
| 262 |
+
return 0.0
|
| 263 |
+
|
| 264 |
+
volume = data['Volume'].iloc[max(0, idx-50):idx+1]
|
| 265 |
+
if len(volume) < 20:
|
| 266 |
+
return 0.0
|
| 267 |
+
|
| 268 |
+
# Volume trend
|
| 269 |
+
volume_sma = volume.rolling(20).mean()
|
| 270 |
+
volume_trend = (volume.iloc[-1] - volume_sma.iloc[-1]) / volume_sma.iloc[-1]
|
| 271 |
+
|
| 272 |
+
return volume_trend
|
| 273 |
+
|
| 274 |
+
def _classify_regime(self, trend_strength: float, volatility: float,
|
| 275 |
+
momentum: float, volume_trend: float) -> MarketRegime:
|
| 276 |
+
"""
|
| 277 |
+
Classify market regime based on calculated indicators
|
| 278 |
+
"""
|
| 279 |
+
|
| 280 |
+
# Volatility thresholds
|
| 281 |
+
HIGH_VOL_THRESHOLD = 0.05
|
| 282 |
+
LOW_VOL_THRESHOLD = 0.015
|
| 283 |
+
|
| 284 |
+
# Trend strength thresholds
|
| 285 |
+
STRONG_TREND_THRESHOLD = 25
|
| 286 |
+
MODERATE_TREND_THRESHOLD = 20
|
| 287 |
+
|
| 288 |
+
# Momentum thresholds
|
| 289 |
+
BULL_MOMENTUM_THRESHOLD = 0.3
|
| 290 |
+
BEAR_MOMENTUM_THRESHOLD = -0.3
|
| 291 |
+
|
| 292 |
+
# High volatility regime
|
| 293 |
+
if volatility > HIGH_VOL_THRESHOLD:
|
| 294 |
+
return MarketRegime.HIGH_VOLATILITY
|
| 295 |
+
|
| 296 |
+
# Low volatility regime
|
| 297 |
+
if volatility < LOW_VOL_THRESHOLD:
|
| 298 |
+
return MarketRegime.LOW_VOLATILITY
|
| 299 |
+
|
| 300 |
+
# Strong trending regimes
|
| 301 |
+
if trend_strength > STRONG_TREND_THRESHOLD:
|
| 302 |
+
if momentum > BULL_MOMENTUM_THRESHOLD:
|
| 303 |
+
return MarketRegime.STRONG_BULL
|
| 304 |
+
elif momentum < BEAR_MOMENTUM_THRESHOLD:
|
| 305 |
+
return MarketRegime.STRONG_BEAR
|
| 306 |
+
|
| 307 |
+
# Moderate trending regimes
|
| 308 |
+
if trend_strength > MODERATE_TREND_THRESHOLD:
|
| 309 |
+
if momentum > 0.1:
|
| 310 |
+
return MarketRegime.BULL_TREND
|
| 311 |
+
elif momentum < -0.1:
|
| 312 |
+
return MarketRegime.BEAR_TREND
|
| 313 |
+
|
| 314 |
+
# Default to ranging market
|
| 315 |
+
return MarketRegime.RANGING
|
| 316 |
+
|
| 317 |
+
def get_regime_statistics(self) -> Dict:
|
| 318 |
+
"""Get statistics about regime detection performance"""
|
| 319 |
+
if not self.regime_history:
|
| 320 |
+
return {}
|
| 321 |
+
|
| 322 |
+
df = pd.DataFrame(self.regime_history)
|
| 323 |
+
|
| 324 |
+
stats = {
|
| 325 |
+
'total_observations': len(df),
|
| 326 |
+
'regime_distribution': df['regime'].value_counts().to_dict(),
|
| 327 |
+
'avg_trend_strength': df['trend_strength'].mean(),
|
| 328 |
+
'avg_volatility': df['volatility'].mean(),
|
| 329 |
+
'avg_momentum': df['momentum'].mean(),
|
| 330 |
+
'regime_transitions': self._calculate_regime_transitions(df)
|
| 331 |
+
}
|
| 332 |
+
|
| 333 |
+
return stats
|
| 334 |
+
|
| 335 |
+
def _calculate_regime_transitions(self, df: pd.DataFrame) -> Dict:
|
| 336 |
+
"""Calculate regime transition frequencies"""
|
| 337 |
+
transitions = {}
|
| 338 |
+
regimes = df['regime'].values
|
| 339 |
+
|
| 340 |
+
for i in range(1, len(regimes)):
|
| 341 |
+
from_regime = regimes[i-1]
|
| 342 |
+
to_regime = regimes[i]
|
| 343 |
+
key = f"{from_regime.value}_to_{to_regime.value}"
|
| 344 |
+
transitions[key] = transitions.get(key, 0) + 1
|
| 345 |
+
|
| 346 |
+
return transitions
|
| 347 |
+
|
| 348 |
+
def get_optimal_parameters_for_regime(self, regime: MarketRegime) -> Dict:
|
| 349 |
+
"""Get optimal trading parameters for a specific regime"""
|
| 350 |
+
return self.parameters.get_parameters(regime)
|
| 351 |
+
|
| 352 |
+
def create_sample_regime_analysis():
|
| 353 |
+
"""Create a sample analysis showing regime detection in action"""
|
| 354 |
+
print("🧠 MARKET REGIME DETECTION SYSTEM")
|
| 355 |
+
print("=" * 50)
|
| 356 |
+
|
| 357 |
+
# Create sample price data
|
| 358 |
+
np.random.seed(42)
|
| 359 |
+
n_points = 500
|
| 360 |
+
|
| 361 |
+
# Generate realistic price data with different regimes
|
| 362 |
+
base_price = 2000
|
| 363 |
+
prices = [base_price]
|
| 364 |
+
|
| 365 |
+
for i in range(1, n_points):
|
| 366 |
+
# Different volatility regimes
|
| 367 |
+
if i < 100: # Low volatility ranging
|
| 368 |
+
volatility = 0.005
|
| 369 |
+
trend = 0.0001
|
| 370 |
+
elif i < 200: # High volatility
|
| 371 |
+
volatility = 0.02
|
| 372 |
+
trend = 0.0005
|
| 373 |
+
elif i < 350: # Strong bull trend
|
| 374 |
+
volatility = 0.015
|
| 375 |
+
trend = 0.002
|
| 376 |
+
else: # Bear trend
|
| 377 |
+
volatility = 0.012
|
| 378 |
+
trend = -0.0015
|
| 379 |
+
|
| 380 |
+
# Add momentum component
|
| 381 |
+
momentum = 0.1 * (prices[-1] - prices[-2]) / prices[-2] if len(prices) > 1 else 0
|
| 382 |
+
|
| 383 |
+
# Generate price movement
|
| 384 |
+
price_change = trend + np.random.normal(0, volatility) + momentum
|
| 385 |
+
new_price = prices[-1] * (1 + price_change)
|
| 386 |
+
prices.append(max(1800, min(2200, new_price)))
|
| 387 |
+
|
| 388 |
+
# Create DataFrame
|
| 389 |
+
data = pd.DataFrame({
|
| 390 |
+
'Close': prices,
|
| 391 |
+
'High': [p * (1 + np.random.uniform(0, 0.005)) for p in prices],
|
| 392 |
+
'Low': [p * (1 - np.random.uniform(0, 0.005)) for p in prices],
|
| 393 |
+
'Volume': np.random.randint(1000, 10000, n_points)
|
| 394 |
+
})
|
| 395 |
+
|
| 396 |
+
# Initialize regime detector
|
| 397 |
+
detector = MarketRegimeDetector()
|
| 398 |
+
|
| 399 |
+
# Analyze regimes
|
| 400 |
+
regimes = []
|
| 401 |
+
regime_params = []
|
| 402 |
+
|
| 403 |
+
print("\n🔍 Analyzing market regimes...")
|
| 404 |
+
for i in range(50, len(data)): # Start after minimum lookback
|
| 405 |
+
regime, params = detector.detect_regime(data, i)
|
| 406 |
+
regimes.append(regime)
|
| 407 |
+
regime_params.append(params)
|
| 408 |
+
|
| 409 |
+
if i % 100 == 0:
|
| 410 |
+
print(f"Processed {i}/{len(data)} data points...")
|
| 411 |
+
|
| 412 |
+
# Show regime distribution
|
| 413 |
+
regime_counts = pd.Series([r.value for r in regimes]).value_counts()
|
| 414 |
+
print("\n📊 Regime Distribution:")
|
| 415 |
+
for regime, count in regime_counts.items():
|
| 416 |
+
pct = count / len(regimes) * 100
|
| 417 |
+
print(f" {regime}: {count} ({pct:.1f}%)")
|
| 418 |
+
|
| 419 |
+
# Show example parameters for each regime
|
| 420 |
+
print("\n🎯 Regime-Specific Parameters:")
|
| 421 |
+
unique_regimes = set(regimes)
|
| 422 |
+
for regime in unique_regimes:
|
| 423 |
+
params = detector.get_optimal_parameters_for_regime(regime)
|
| 424 |
+
print(f"\n{regime.value.upper()}:")
|
| 425 |
+
print(f" Profit Targets: {[f'{t*100:.1f}%' for t in params['profit_targets']]}")
|
| 426 |
+
print(f" Trailing Stop: {params['trailing_stop_pct']*100:.1f}%")
|
| 427 |
+
print(f" Position Size Multiplier: {params['position_size_multiplier']:.1f}x")
|
| 428 |
+
print(f" Max Holding Time: {params['max_holding_time']} hours")
|
| 429 |
+
print(f" Breakeven Trigger: {params['breakeven_trigger']*100:.1f}%")
|
| 430 |
+
|
| 431 |
+
print("\n✅ Market regime detection system ready!")
|
| 432 |
+
print("This will significantly improve trading performance by adapting to market conditions.")
|
| 433 |
+
|
| 434 |
+
if __name__ == "__main__":
|
| 435 |
+
create_sample_regime_analysis()
|
code/quick_demo.py
ADDED
|
@@ -0,0 +1,265 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/usr/bin/env python3
|
| 2 |
+
"""
|
| 3 |
+
Quick Demo for AI-XAUUSD Trading System
|
| 4 |
+
|
| 5 |
+
This script provides a fast demonstration of the AI trading system's capabilities
|
| 6 |
+
without requiring extensive setup or data downloads.
|
| 7 |
+
"""
|
| 8 |
+
|
| 9 |
+
import numpy as np
|
| 10 |
+
import pandas as pd
|
| 11 |
+
import matplotlib.pyplot as plt
|
| 12 |
+
from datetime import datetime, timedelta
|
| 13 |
+
import warnings
|
| 14 |
+
warnings.filterwarnings('ignore')
|
| 15 |
+
|
| 16 |
+
# Import our trading components
|
| 17 |
+
try:
|
| 18 |
+
from ensemble_trader import EnsembleTrader
|
| 19 |
+
from market_regime_detector import MarketRegimeDetector
|
| 20 |
+
from trading_env import TradingEnvironment
|
| 21 |
+
from confidence_sizing_demo import ConfidenceBasedSizer
|
| 22 |
+
except ImportError as e:
|
| 23 |
+
print("❌ Error importing trading components. Please ensure all dependencies are installed.")
|
| 24 |
+
print(f"Missing: {e}")
|
| 25 |
+
exit(1)
|
| 26 |
+
|
| 27 |
+
def generate_sample_data(days=100):
|
| 28 |
+
"""Generate sample XAUUSD price data for demonstration."""
|
| 29 |
+
print("📊 Generating sample XAUUSD data...")
|
| 30 |
+
|
| 31 |
+
# Start from a recent date
|
| 32 |
+
start_date = datetime.now() - timedelta(days=days)
|
| 33 |
+
dates = pd.date_range(start=start_date, periods=days, freq='D')
|
| 34 |
+
|
| 35 |
+
# Generate realistic gold price movements
|
| 36 |
+
# XAUUSD typically ranges from 1800-2500
|
| 37 |
+
base_price = 2000
|
| 38 |
+
prices = [base_price]
|
| 39 |
+
|
| 40 |
+
np.random.seed(42) # For reproducible results
|
| 41 |
+
|
| 42 |
+
for i in range(1, days):
|
| 43 |
+
# Add some trend and volatility
|
| 44 |
+
trend = 0.0001 * np.sin(i / 10) # Slight cyclical trend
|
| 45 |
+
noise = np.random.normal(0, 0.01) # Daily volatility ~1%
|
| 46 |
+
change = trend + noise
|
| 47 |
+
|
| 48 |
+
new_price = prices[-1] * (1 + change)
|
| 49 |
+
prices.append(max(new_price, 1800)) # Floor at 1800
|
| 50 |
+
|
| 51 |
+
# Create OHLCV data
|
| 52 |
+
data = []
|
| 53 |
+
for i, price in enumerate(prices):
|
| 54 |
+
high = price * (1 + abs(np.random.normal(0, 0.005)))
|
| 55 |
+
low = price * (1 - abs(np.random.normal(0, 0.005)))
|
| 56 |
+
open_price = prices[i-1] if i > 0 else price
|
| 57 |
+
volume = np.random.randint(100000, 500000)
|
| 58 |
+
|
| 59 |
+
data.append({
|
| 60 |
+
'Date': dates[i],
|
| 61 |
+
'Open': open_price,
|
| 62 |
+
'High': high,
|
| 63 |
+
'Low': low,
|
| 64 |
+
'Close': price,
|
| 65 |
+
'Volume': volume
|
| 66 |
+
})
|
| 67 |
+
|
| 68 |
+
df = pd.DataFrame(data)
|
| 69 |
+
df.set_index('Date', inplace=True)
|
| 70 |
+
|
| 71 |
+
# Add some technical indicators
|
| 72 |
+
df['SMA_20'] = df['Close'].rolling(20).mean()
|
| 73 |
+
df['SMA_50'] = df['Close'].rolling(50).mean()
|
| 74 |
+
df['RSI'] = 50 + 20 * np.sin(np.arange(len(df)) / 10) # Simplified RSI
|
| 75 |
+
df['MACD'] = df['Close'].ewm(span=12).mean() - df['Close'].ewm(span=26).mean()
|
| 76 |
+
|
| 77 |
+
return df
|
| 78 |
+
|
| 79 |
+
def simulate_trading_demo(data, initial_capital=1000, leverage=50):
|
| 80 |
+
"""Run a simplified trading simulation."""
|
| 81 |
+
print("🚀 Running trading simulation...")
|
| 82 |
+
|
| 83 |
+
# Initialize components
|
| 84 |
+
regime_detector = MarketRegimeDetector()
|
| 85 |
+
sizer = ConfidenceBasedSizer(initial_capital, leverage)
|
| 86 |
+
|
| 87 |
+
# Trading parameters
|
| 88 |
+
trades = []
|
| 89 |
+
capital = initial_capital
|
| 90 |
+
position = 0
|
| 91 |
+
entry_price = 0
|
| 92 |
+
|
| 93 |
+
for i in range(50, len(data)): # Start after enough data for indicators
|
| 94 |
+
current_data = data.iloc[:i+1]
|
| 95 |
+
current_price = data.iloc[i]['Close']
|
| 96 |
+
|
| 97 |
+
# Detect market regime
|
| 98 |
+
try:
|
| 99 |
+
regime, params = regime_detector.detect_regime(current_data)
|
| 100 |
+
except:
|
| 101 |
+
regime = regime_detector.market_regime.STRONG_BULL
|
| 102 |
+
params = regime_detector.get_default_params(regime)
|
| 103 |
+
|
| 104 |
+
# Simulate AI prediction (simplified)
|
| 105 |
+
# In real system, this would come from ensemble models
|
| 106 |
+
confidence = 0.5 + 0.3 * np.sin(i / 20) # Oscillating confidence
|
| 107 |
+
signal = 1 if confidence > 0.6 else (-1 if confidence < 0.4 else 0)
|
| 108 |
+
|
| 109 |
+
# Execute trades
|
| 110 |
+
if signal != 0 and position == 0: # Open position
|
| 111 |
+
position_size = sizer.calculate_position_size(confidence, 0.02) # 2% risk
|
| 112 |
+
if position_size > 0:
|
| 113 |
+
position = signal
|
| 114 |
+
entry_price = current_price
|
| 115 |
+
trades.append({
|
| 116 |
+
'type': 'open',
|
| 117 |
+
'price': current_price,
|
| 118 |
+
'position': position,
|
| 119 |
+
'confidence': confidence,
|
| 120 |
+
'regime': regime.value,
|
| 121 |
+
'capital': capital
|
| 122 |
+
})
|
| 123 |
+
|
| 124 |
+
elif position != 0: # Check for exit
|
| 125 |
+
# Simplified exit logic
|
| 126 |
+
profit_pct = (current_price - entry_price) / entry_price * position
|
| 127 |
+
|
| 128 |
+
# Exit conditions
|
| 129 |
+
if profit_pct >= 0.02 or profit_pct <= -0.01: # 2% profit or 1% loss
|
| 130 |
+
pnl = capital * profit_pct * leverage
|
| 131 |
+
capital += pnl
|
| 132 |
+
|
| 133 |
+
trades.append({
|
| 134 |
+
'type': 'close',
|
| 135 |
+
'price': current_price,
|
| 136 |
+
'position': position,
|
| 137 |
+
'pnl': pnl,
|
| 138 |
+
'profit_pct': profit_pct,
|
| 139 |
+
'capital': capital
|
| 140 |
+
})
|
| 141 |
+
|
| 142 |
+
position = 0
|
| 143 |
+
entry_price = 0
|
| 144 |
+
|
| 145 |
+
return trades, capital
|
| 146 |
+
|
| 147 |
+
def plot_demo_results(data, trades):
|
| 148 |
+
"""Create a visualization of the trading demo."""
|
| 149 |
+
print("📈 Creating performance visualization...")
|
| 150 |
+
|
| 151 |
+
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
|
| 152 |
+
|
| 153 |
+
# Price chart with trades
|
| 154 |
+
ax1.plot(data.index, data['Close'], label='XAUUSD Price', alpha=0.7)
|
| 155 |
+
|
| 156 |
+
# Plot trades
|
| 157 |
+
buy_signals = [t for t in trades if t['type'] == 'open' and t['position'] == 1]
|
| 158 |
+
sell_signals = [t for t in trades if t['type'] == 'open' and t['position'] == -1]
|
| 159 |
+
|
| 160 |
+
if buy_signals:
|
| 161 |
+
buy_prices = [t['price'] for t in buy_signals]
|
| 162 |
+
buy_dates = [data.index[len(data)-len(trades)+i] for i, t in enumerate(trades) if t['type'] == 'open' and t['position'] == 1]
|
| 163 |
+
ax1.scatter(buy_dates, buy_prices, color='green', marker='^', s=100, label='Buy Signal')
|
| 164 |
+
|
| 165 |
+
if sell_signals:
|
| 166 |
+
sell_prices = [t['price'] for t in sell_signals]
|
| 167 |
+
sell_dates = [data.index[len(data)-len(trades)+i] for i, t in enumerate(trades) if t['type'] == 'open' and t['position'] == -1]
|
| 168 |
+
ax1.scatter(sell_dates, sell_prices, color='red', marker='v', s=100, label='Sell Signal')
|
| 169 |
+
|
| 170 |
+
ax1.set_title('XAUUSD Price with Trading Signals')
|
| 171 |
+
ax1.set_ylabel('Price (USD)')
|
| 172 |
+
ax1.legend()
|
| 173 |
+
ax1.grid(True, alpha=0.3)
|
| 174 |
+
|
| 175 |
+
# Capital curve
|
| 176 |
+
capital_history = [t['capital'] for t in trades if 'capital' in t]
|
| 177 |
+
if capital_history:
|
| 178 |
+
ax2.plot(capital_history, label='Portfolio Value', color='blue')
|
| 179 |
+
ax2.axhline(y=1000, color='red', linestyle='--', alpha=0.7, label='Initial Capital')
|
| 180 |
+
ax2.set_title('Portfolio Value Over Time')
|
| 181 |
+
ax2.set_xlabel('Trade Number')
|
| 182 |
+
ax2.set_ylabel('Capital (USD)')
|
| 183 |
+
ax2.legend()
|
| 184 |
+
ax2.grid(True, alpha=0.3)
|
| 185 |
+
|
| 186 |
+
plt.tight_layout()
|
| 187 |
+
plt.savefig('demo_results.png', dpi=150, bbox_inches='tight')
|
| 188 |
+
plt.show()
|
| 189 |
+
|
| 190 |
+
def print_demo_summary(trades, final_capital):
|
| 191 |
+
"""Print a summary of the demo results."""
|
| 192 |
+
print("\n" + "="*60)
|
| 193 |
+
print("🎯 AI-XAUUSD TRADING DEMO SUMMARY")
|
| 194 |
+
print("="*60)
|
| 195 |
+
|
| 196 |
+
print(f"📊 Total Trades: {len([t for t in trades if t['type'] == 'close'])}")
|
| 197 |
+
print(f"💰 Initial Capital: $1,000")
|
| 198 |
+
print(f"💰 Final Capital: ${final_capital:.2f}")
|
| 199 |
+
print(f"📈 Total Return: ${final_capital - 1000:.2f} ({(final_capital/1000 - 1)*100:.1f}%)")
|
| 200 |
+
|
| 201 |
+
winning_trades = [t for t in trades if t['type'] == 'close' and t['pnl'] > 0]
|
| 202 |
+
losing_trades = [t for t in trades if t['type'] == 'close' and t['pnl'] <= 0]
|
| 203 |
+
|
| 204 |
+
win_rate = len(winning_trades) / max(1, len(winning_trades) + len(losing_trades)) * 100
|
| 205 |
+
|
| 206 |
+
print(f"🎯 Win Rate: {win_rate:.1f}%")
|
| 207 |
+
print(f"💹 Winning Trades: {len(winning_trades)}")
|
| 208 |
+
print(f"📉 Losing Trades: {len(losing_trades)}")
|
| 209 |
+
|
| 210 |
+
if winning_trades:
|
| 211 |
+
avg_win = np.mean([t['pnl'] for t in winning_trades])
|
| 212 |
+
print(f"💰 Average Win: ${avg_win:.2f}")
|
| 213 |
+
|
| 214 |
+
if losing_trades:
|
| 215 |
+
avg_loss = np.mean([t['pnl'] for t in losing_trades])
|
| 216 |
+
print(f"💸 Average Loss: ${avg_loss:.2f}")
|
| 217 |
+
|
| 218 |
+
print("\n🔍 Key Features Demonstrated:")
|
| 219 |
+
print(" ✅ Market Regime Detection")
|
| 220 |
+
print(" ✅ Confidence-Based Position Sizing")
|
| 221 |
+
print(" ✅ Risk Management")
|
| 222 |
+
print(" ✅ Adaptive Trading Parameters")
|
| 223 |
+
|
| 224 |
+
print("\n📈 For full system with real AI models:")
|
| 225 |
+
print(" Run: python download_models.py")
|
| 226 |
+
print(" Then: python advanced_trading_demo.py")
|
| 227 |
+
|
| 228 |
+
print("\n⚠️ Disclaimer: This is a demonstration only.")
|
| 229 |
+
print(" Real trading involves risk of loss.")
|
| 230 |
+
print("="*60)
|
| 231 |
+
|
| 232 |
+
def main():
|
| 233 |
+
"""Main demo function."""
|
| 234 |
+
print("🤖 AI-XAUUSD Trading System - Quick Demo")
|
| 235 |
+
print("="*50)
|
| 236 |
+
|
| 237 |
+
try:
|
| 238 |
+
# Generate sample data
|
| 239 |
+
data = generate_sample_data(days=200)
|
| 240 |
+
|
| 241 |
+
# Run trading simulation
|
| 242 |
+
trades, final_capital = simulate_trading_demo(data)
|
| 243 |
+
|
| 244 |
+
# Display results
|
| 245 |
+
print_demo_summary(trades, final_capital)
|
| 246 |
+
|
| 247 |
+
# Create visualization
|
| 248 |
+
try:
|
| 249 |
+
plot_demo_results(data, trades)
|
| 250 |
+
print("📊 Demo visualization saved as 'demo_results.png'")
|
| 251 |
+
except Exception as e:
|
| 252 |
+
print(f"⚠️ Could not create visualization: {e}")
|
| 253 |
+
|
| 254 |
+
print("\n✅ Demo completed successfully!")
|
| 255 |
+
|
| 256 |
+
except Exception as e:
|
| 257 |
+
print(f"❌ Demo failed: {e}")
|
| 258 |
+
print("Please ensure all dependencies are installed:")
|
| 259 |
+
print(" pip install -r requirements.txt")
|
| 260 |
+
return 1
|
| 261 |
+
|
| 262 |
+
return 0
|
| 263 |
+
|
| 264 |
+
if __name__ == "__main__":
|
| 265 |
+
exit(main())
|
code/trading_env.py
ADDED
|
@@ -0,0 +1,339 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import gym
|
| 2 |
+
import numpy as np
|
| 3 |
+
import pandas as pd
|
| 4 |
+
from gym import spaces
|
| 5 |
+
from market_regime_detector import MarketRegimeDetector, MarketRegime
|
| 6 |
+
|
| 7 |
+
class TradingEnv(gym.Env):
|
| 8 |
+
"""
|
| 9 |
+
Custom Gym environment for XAUUSD trading with trailing stops and dynamic exits.
|
| 10 |
+
"""
|
| 11 |
+
def __init__(self, df, initial_balance=1000, transaction_cost=0, leverage=50, stop_loss_pct=0.02):
|
| 12 |
+
super(TradingEnv, self).__init__()
|
| 13 |
+
|
| 14 |
+
self.df = df.reset_index(drop=True)
|
| 15 |
+
self.initial_balance = initial_balance
|
| 16 |
+
self.transaction_cost = transaction_cost
|
| 17 |
+
self.leverage = leverage
|
| 18 |
+
self.stop_loss_pct = stop_loss_pct
|
| 19 |
+
|
| 20 |
+
# Trailing stop parameters - TIGHTENED for better profit capture
|
| 21 |
+
self.trailing_stop_pct = 0.025 # Reduced from 5% to 2.5% trailing stop
|
| 22 |
+
self.trailing_stop_distance = 0 # Current trailing stop level
|
| 23 |
+
self.highest_price_since_entry = 0 # Track highest price for trailing stops
|
| 24 |
+
|
| 25 |
+
# Profit taking parameters - MULTIPLE SCALED TARGETS
|
| 26 |
+
self.profit_targets = [0.01, 0.02, 0.05, 0.10] # 1%, 2%, 5%, 10% profit targets
|
| 27 |
+
self.take_profit_pct = 0.10 # 10% take profit target (final target)
|
| 28 |
+
self.partial_take_profit_pct = 0.02 # Take partial profits at 2% (reduced from 5%)
|
| 29 |
+
|
| 30 |
+
# Breakeven stop parameters
|
| 31 |
+
self.breakeven_trigger_pct = 0.015 # Move to breakeven after 1.5% profit
|
| 32 |
+
self.breakeven_activated = False
|
| 33 |
+
|
| 34 |
+
# Dynamic exit parameters
|
| 35 |
+
self.max_holding_period = 24 # Max hours to hold position
|
| 36 |
+
self.entry_time = None
|
| 37 |
+
|
| 38 |
+
# Calculate technical indicators
|
| 39 |
+
self._calculate_indicators()
|
| 40 |
+
|
| 41 |
+
# Action space: continuous action between -1 and 1
|
| 42 |
+
self.action_space = spaces.Box(low=-1, high=1, shape=(1,), dtype=np.float32)
|
| 43 |
+
|
| 44 |
+
# Observation space: price history (last 10 closes), RSI, MACD, MACD_signal, position, balance
|
| 45 |
+
self.lookback = 10
|
| 46 |
+
self.observation_space = spaces.Box(
|
| 47 |
+
low=-np.inf, high=np.inf, shape=(self.lookback + 5,), dtype=np.float32 # 10 prices + RSI + MACD + MACD_signal + position + balance
|
| 48 |
+
)
|
| 49 |
+
|
| 50 |
+
self.trades = [] # Log all trades
|
| 51 |
+
|
| 52 |
+
self.reset()
|
| 53 |
+
|
| 54 |
+
def _calculate_indicators(self):
|
| 55 |
+
"""Calculate technical indicators for the dataset"""
|
| 56 |
+
# RSI
|
| 57 |
+
delta = self.df['Close'].diff()
|
| 58 |
+
gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
|
| 59 |
+
loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
|
| 60 |
+
rs = gain / loss
|
| 61 |
+
self.df['RSI'] = 100 - (100 / (1 + rs))
|
| 62 |
+
|
| 63 |
+
# MACD
|
| 64 |
+
ema12 = self.df['Close'].ewm(span=12, adjust=False).mean()
|
| 65 |
+
ema26 = self.df['Close'].ewm(span=26, adjust=False).mean()
|
| 66 |
+
self.df['MACD'] = ema12 - ema26
|
| 67 |
+
self.df['MACD_signal'] = self.df['MACD'].ewm(span=9, adjust=False).mean()
|
| 68 |
+
|
| 69 |
+
self.df.fillna(0, inplace=True) # Fill NaN with 0
|
| 70 |
+
self.trailing_stop_distance = 0 # Current trailing stop level
|
| 71 |
+
self.highest_price_since_entry = 0 # Track highest price for trailing stops
|
| 72 |
+
|
| 73 |
+
# Initialize market regime detector
|
| 74 |
+
self.regime_detector = MarketRegimeDetector()
|
| 75 |
+
|
| 76 |
+
# Dynamic regime-adaptive parameters (will be updated based on current regime)
|
| 77 |
+
self._update_regime_parameters()
|
| 78 |
+
|
| 79 |
+
# Add technical indicators
|
| 80 |
+
|
| 81 |
+
# Add technical indicators
|
| 82 |
+
self._calculate_indicators()
|
| 83 |
+
|
| 84 |
+
# Action space: continuous action between -1 and 1
|
| 85 |
+
self.action_space = spaces.Box(low=-1, high=1, shape=(1,), dtype=np.float32)
|
| 86 |
+
|
| 87 |
+
# Observation space: price history (last 10 closes), RSI, MACD, MACD_signal, position, balance
|
| 88 |
+
self.lookback = 10
|
| 89 |
+
self.observation_space = spaces.Box(
|
| 90 |
+
low=-np.inf, high=np.inf, shape=(self.lookback + 5,), dtype=np.float32 # 10 prices + RSI + MACD + MACD_signal + position + balance
|
| 91 |
+
)
|
| 92 |
+
|
| 93 |
+
self.trades = [] # Log all trades
|
| 94 |
+
|
| 95 |
+
self.reset()
|
| 96 |
+
|
| 97 |
+
def reset(self):
|
| 98 |
+
self.current_step = self.lookback
|
| 99 |
+
self.balance = self.initial_balance
|
| 100 |
+
self.position = 0 # 0: no position, positive: long amount
|
| 101 |
+
self.entry_price = 0
|
| 102 |
+
self.total_profit = 0
|
| 103 |
+
self.done = False
|
| 104 |
+
self.trades = [] # Reset trades
|
| 105 |
+
|
| 106 |
+
# Reset trailing stop variables
|
| 107 |
+
self.trailing_stop_distance = 0
|
| 108 |
+
self.highest_price_since_entry = 0
|
| 109 |
+
self.entry_time = None
|
| 110 |
+
|
| 111 |
+
return self._get_observation()
|
| 112 |
+
|
| 113 |
+
def render(self, mode='human'):
|
| 114 |
+
print(f"Step: {self.current_step}, Balance: {self.balance}, Position: {self.position}, Total Profit: {self.total_profit}")
|
| 115 |
+
|
| 116 |
+
def _update_regime_parameters(self):
|
| 117 |
+
"""Update trading parameters based on current market regime"""
|
| 118 |
+
# Detect current regime
|
| 119 |
+
current_regime, regime_params = self.regime_detector.detect_regime(self.df, self.current_step)
|
| 120 |
+
|
| 121 |
+
# Update trading parameters based on regime
|
| 122 |
+
self.profit_targets = regime_params['profit_targets']
|
| 123 |
+
self.trailing_stop_pct = regime_params['trailing_stop_pct']
|
| 124 |
+
self.take_profit_pct = regime_params['profit_targets'][-1] # Last target is final take profit
|
| 125 |
+
self.partial_take_profit_pct = regime_params['profit_targets'][1] # Second target for partial profit
|
| 126 |
+
self.breakeven_trigger_pct = regime_params['breakeven_trigger']
|
| 127 |
+
self.max_holding_period = regime_params['max_holding_time']
|
| 128 |
+
|
| 129 |
+
# Store current regime for logging
|
| 130 |
+
self.current_regime = current_regime
|
| 131 |
+
|
| 132 |
+
def _get_observation(self):
|
| 133 |
+
prices = self.df.loc[self.current_step - self.lookback:self.current_step - 1, 'Close'].values
|
| 134 |
+
rsi = self.df.loc[self.current_step - 1, 'RSI']
|
| 135 |
+
macd = self.df.loc[self.current_step - 1, 'MACD']
|
| 136 |
+
macd_signal = self.df.loc[self.current_step - 1, 'MACD_signal']
|
| 137 |
+
return np.concatenate([prices, [rsi, macd, macd_signal, self.position, self.balance]])
|
| 138 |
+
|
| 139 |
+
def step(self, action, confidence=1.0):
|
| 140 |
+
"""
|
| 141 |
+
Execute action with confidence-based position sizing and dynamic exits
|
| 142 |
+
confidence: float between 0 and 1, higher = more confident
|
| 143 |
+
"""
|
| 144 |
+
# Update regime parameters dynamically
|
| 145 |
+
self._update_regime_parameters()
|
| 146 |
+
|
| 147 |
+
current_price = self.df.loc[self.current_step, 'Close']
|
| 148 |
+
reward = 0
|
| 149 |
+
|
| 150 |
+
# Apply confidence to action magnitude
|
| 151 |
+
if isinstance(action, np.ndarray):
|
| 152 |
+
action = action[0]
|
| 153 |
+
|
| 154 |
+
# Scale action by confidence (minimum confidence threshold)
|
| 155 |
+
min_confidence = 0.3 # Minimum confidence to trade
|
| 156 |
+
if confidence < min_confidence:
|
| 157 |
+
action = 0 # Force hold if not confident enough
|
| 158 |
+
|
| 159 |
+
effective_action = action * confidence
|
| 160 |
+
|
| 161 |
+
# Check for dynamic exits first (trailing stops, profit taking, time limits)
|
| 162 |
+
exit_reason = self._check_dynamic_exits(current_price)
|
| 163 |
+
if exit_reason:
|
| 164 |
+
profit = (current_price - self.entry_price) * self.position
|
| 165 |
+
self.balance += profit
|
| 166 |
+
self.total_profit += profit
|
| 167 |
+
|
| 168 |
+
# Reward based on exit reason
|
| 169 |
+
if exit_reason == 'trailing_stop':
|
| 170 |
+
reward = profit / self.initial_balance * 30 # Moderate reward for trailing stop
|
| 171 |
+
elif exit_reason == 'take_profit':
|
| 172 |
+
reward = profit / self.initial_balance * 100 # High reward for profit taking
|
| 173 |
+
elif exit_reason == 'partial_profit':
|
| 174 |
+
reward = profit / self.initial_balance * 50 # Good reward for partial profits
|
| 175 |
+
elif exit_reason == 'max_time':
|
| 176 |
+
reward = profit / self.initial_balance * 10 # Low reward for time-based exit
|
| 177 |
+
else:
|
| 178 |
+
reward = profit / self.initial_balance * 20 # Default reward
|
| 179 |
+
|
| 180 |
+
self.trades.append({
|
| 181 |
+
'step': self.current_step,
|
| 182 |
+
'action': 'exit',
|
| 183 |
+
'reason': exit_reason,
|
| 184 |
+
'price': current_price,
|
| 185 |
+
'profit': profit,
|
| 186 |
+
'confidence': confidence
|
| 187 |
+
})
|
| 188 |
+
|
| 189 |
+
# Reset position
|
| 190 |
+
self.position = 0
|
| 191 |
+
self.entry_price = 0
|
| 192 |
+
self.trailing_stop_distance = 0
|
| 193 |
+
self.highest_price_since_entry = 0
|
| 194 |
+
self.entry_time = None
|
| 195 |
+
|
| 196 |
+
# Execute new trades if no position
|
| 197 |
+
elif self.position == 0:
|
| 198 |
+
if effective_action > 0.1: # Buy signal
|
| 199 |
+
# Position size based on action magnitude and confidence
|
| 200 |
+
position_multiplier = min(effective_action, 1.0)
|
| 201 |
+
confidence_multiplier = confidence ** 0.5
|
| 202 |
+
self.position = self.balance * self.leverage * position_multiplier * confidence_multiplier / current_price
|
| 203 |
+
self.entry_price = current_price
|
| 204 |
+
self.entry_time = self.current_step
|
| 205 |
+
self.highest_price_since_entry = current_price
|
| 206 |
+
self.trailing_stop_distance = current_price * (1 - self.trailing_stop_pct)
|
| 207 |
+
self.breakeven_activated = False # Reset breakeven flag
|
| 208 |
+
|
| 209 |
+
self.trades.append({
|
| 210 |
+
'step': self.current_step,
|
| 211 |
+
'action': 'buy',
|
| 212 |
+
'price': current_price,
|
| 213 |
+
'position': self.position,
|
| 214 |
+
'confidence': confidence
|
| 215 |
+
})
|
| 216 |
+
|
| 217 |
+
elif effective_action < -0.1: # Sell signal (short)
|
| 218 |
+
# Position size based on action magnitude and confidence
|
| 219 |
+
position_multiplier = min(abs(effective_action), 1.0)
|
| 220 |
+
confidence_multiplier = confidence ** 0.5
|
| 221 |
+
self.position = -self.balance * self.leverage * position_multiplier * confidence_multiplier / current_price
|
| 222 |
+
self.entry_price = current_price
|
| 223 |
+
self.entry_time = self.current_step
|
| 224 |
+
self.highest_price_since_entry = current_price # For short positions, track lowest
|
| 225 |
+
self.trailing_stop_distance = current_price * (1 + self.trailing_stop_pct)
|
| 226 |
+
self.breakeven_activated = False # Reset breakeven flag
|
| 227 |
+
|
| 228 |
+
self.trades.append({
|
| 229 |
+
'step': self.current_step,
|
| 230 |
+
'action': 'sell_short',
|
| 231 |
+
'price': current_price,
|
| 232 |
+
'position': self.position,
|
| 233 |
+
'confidence': confidence
|
| 234 |
+
})
|
| 235 |
+
|
| 236 |
+
# Update trailing stops for existing positions
|
| 237 |
+
else:
|
| 238 |
+
self._update_trailing_stops(current_price)
|
| 239 |
+
|
| 240 |
+
self.current_step += 1
|
| 241 |
+
if self.current_step >= len(self.df) - 1:
|
| 242 |
+
self.done = True
|
| 243 |
+
|
| 244 |
+
next_obs = self._get_observation()
|
| 245 |
+
return next_obs, reward, self.done, {}
|
| 246 |
+
|
| 247 |
+
def _check_dynamic_exits(self, current_price):
|
| 248 |
+
"""Check for various exit conditions with improved profit-taking"""
|
| 249 |
+
if self.position == 0:
|
| 250 |
+
return None
|
| 251 |
+
|
| 252 |
+
# Calculate current profit percentage
|
| 253 |
+
if self.position > 0: # Long position
|
| 254 |
+
profit_pct = (current_price - self.entry_price) / self.entry_price
|
| 255 |
+
else: # Short position
|
| 256 |
+
profit_pct = (self.entry_price - current_price) / self.entry_price
|
| 257 |
+
|
| 258 |
+
# Breakeven stop activation
|
| 259 |
+
if not self.breakeven_activated and profit_pct >= self.breakeven_trigger_pct:
|
| 260 |
+
self.breakeven_activated = True
|
| 261 |
+
# Move trailing stop to breakeven + small buffer
|
| 262 |
+
buffer_pct = 0.005 # 0.5% buffer above breakeven
|
| 263 |
+
if self.position > 0:
|
| 264 |
+
self.trailing_stop_distance = self.entry_price * (1 + buffer_pct)
|
| 265 |
+
else:
|
| 266 |
+
self.trailing_stop_distance = self.entry_price * (1 - buffer_pct)
|
| 267 |
+
|
| 268 |
+
# Scaled profit taking - take partial profits at multiple levels
|
| 269 |
+
for target_pct in sorted(self.profit_targets, reverse=True):
|
| 270 |
+
if profit_pct >= target_pct:
|
| 271 |
+
# Calculate how much profit to take at this level
|
| 272 |
+
if target_pct <= 0.02: # Small profits (1-2%) - take 25% of position
|
| 273 |
+
profit_portion = 0.25
|
| 274 |
+
exit_reason = f'profit_{int(target_pct*100)}pct_partial'
|
| 275 |
+
elif target_pct <= 0.05: # Medium profits (5%) - take 50% of position
|
| 276 |
+
profit_portion = 0.50
|
| 277 |
+
exit_reason = f'profit_{int(target_pct*100)}pct_partial'
|
| 278 |
+
else: # Large profits (10%) - take full position
|
| 279 |
+
profit_portion = 1.0
|
| 280 |
+
exit_reason = 'take_profit'
|
| 281 |
+
|
| 282 |
+
if profit_portion < 1.0:
|
| 283 |
+
# Partial exit
|
| 284 |
+
self.position *= (1 - profit_portion)
|
| 285 |
+
# Don't reset trailing stops for partial exits
|
| 286 |
+
else:
|
| 287 |
+
# Full exit
|
| 288 |
+
self.position = 0
|
| 289 |
+
self._reset_position_state()
|
| 290 |
+
|
| 291 |
+
return exit_reason
|
| 292 |
+
|
| 293 |
+
# Trailing stop check (only if breakeven not activated or profit is positive)
|
| 294 |
+
if self.position > 0: # Long position
|
| 295 |
+
if current_price <= self.trailing_stop_distance:
|
| 296 |
+
self.position = 0
|
| 297 |
+
self._reset_position_state()
|
| 298 |
+
return 'trailing_stop'
|
| 299 |
+
else: # Short position
|
| 300 |
+
if current_price >= self.trailing_stop_distance:
|
| 301 |
+
self.position = 0
|
| 302 |
+
self._reset_position_state()
|
| 303 |
+
return 'trailing_stop'
|
| 304 |
+
|
| 305 |
+
# Maximum holding time - more aggressive for losing positions
|
| 306 |
+
if self.entry_time and (self.current_step - self.entry_time) >= self.max_holding_period:
|
| 307 |
+
self.position = 0
|
| 308 |
+
self._reset_position_state()
|
| 309 |
+
return 'max_time'
|
| 310 |
+
|
| 311 |
+
# Early exit for significant losses (stop loss)
|
| 312 |
+
if profit_pct <= -0.03: # 3% stop loss
|
| 313 |
+
self.position = 0
|
| 314 |
+
self._reset_position_state()
|
| 315 |
+
return 'stop_loss'
|
| 316 |
+
|
| 317 |
+
return None
|
| 318 |
+
|
| 319 |
+
def _reset_position_state(self):
|
| 320 |
+
"""Reset position-related state variables"""
|
| 321 |
+
self.trailing_stop_distance = 0
|
| 322 |
+
self.highest_price_since_entry = 0
|
| 323 |
+
self.entry_price = 0
|
| 324 |
+
self.entry_time = None
|
| 325 |
+
self.breakeven_activated = False
|
| 326 |
+
|
| 327 |
+
def _update_trailing_stops(self, current_price):
|
| 328 |
+
"""Update trailing stop levels based on current price"""
|
| 329 |
+
if self.position > 0: # Long position
|
| 330 |
+
if current_price > self.highest_price_since_entry:
|
| 331 |
+
self.highest_price_since_entry = current_price
|
| 332 |
+
self.trailing_stop_distance = current_price * (1 - self.trailing_stop_pct)
|
| 333 |
+
else: # Short position
|
| 334 |
+
if current_price < self.highest_price_since_entry:
|
| 335 |
+
self.highest_price_since_entry = current_price
|
| 336 |
+
self.trailing_stop_distance = current_price * (1 + self.trailing_stop_pct)
|
| 337 |
+
|
| 338 |
+
def render(self, mode='human'):
|
| 339 |
+
print(f"Step: {self.current_step}, Balance: {self.balance}, Position: {self.position}, Total Profit: {self.total_profit}")
|
config/model_config.json
ADDED
|
@@ -0,0 +1,43 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"model_type": "ensemble-trading-system",
|
| 3 |
+
"algorithms": [
|
| 4 |
+
"PPO",
|
| 5 |
+
"TD3",
|
| 6 |
+
"SAC"
|
| 7 |
+
],
|
| 8 |
+
"framework": "stable-baselines3",
|
| 9 |
+
"environment": "gymnasium",
|
| 10 |
+
"asset": "XAUUSD",
|
| 11 |
+
"timeframe": "daily",
|
| 12 |
+
"features": 25,
|
| 13 |
+
"performance": {
|
| 14 |
+
"win_rate": 0.583,
|
| 15 |
+
"avg_win": 49.45,
|
| 16 |
+
"avg_loss": -106.18,
|
| 17 |
+
"risk_reward_ratio": 0.47,
|
| 18 |
+
"sharpe_ratio": 2.0,
|
| 19 |
+
"max_drawdown": 0.05
|
| 20 |
+
},
|
| 21 |
+
"regimes": [
|
| 22 |
+
"strong_bull",
|
| 23 |
+
"bull_trend",
|
| 24 |
+
"bear_trend",
|
| 25 |
+
"strong_bear",
|
| 26 |
+
"ranging",
|
| 27 |
+
"high_volatility"
|
| 28 |
+
],
|
| 29 |
+
"risk_management": {
|
| 30 |
+
"scaled_profit_taking": [
|
| 31 |
+
0.01,
|
| 32 |
+
0.02,
|
| 33 |
+
0.05,
|
| 34 |
+
0.1
|
| 35 |
+
],
|
| 36 |
+
"breakeven_threshold": 0.015,
|
| 37 |
+
"trailing_stop": 0.025,
|
| 38 |
+
"confidence_sizing": [
|
| 39 |
+
0.5,
|
| 40 |
+
2.0
|
| 41 |
+
]
|
| 42 |
+
}
|
| 43 |
+
}
|
config/regime_config.json
ADDED
|
@@ -0,0 +1,128 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"regime_detection": {
|
| 3 |
+
"method": "adx_volatility_trend",
|
| 4 |
+
"adx_period": 14,
|
| 5 |
+
"volatility_period": 20,
|
| 6 |
+
"trend_period": 50,
|
| 7 |
+
"update_frequency": "daily"
|
| 8 |
+
},
|
| 9 |
+
"regime_parameters": {
|
| 10 |
+
"strong_bull": {
|
| 11 |
+
"adx_min": 25,
|
| 12 |
+
"trend_strength": 0.7,
|
| 13 |
+
"volatility_max": 0.015,
|
| 14 |
+
"profit_targets": [0.015, 0.03, 0.06, 0.12],
|
| 15 |
+
"stop_loss": 0.03,
|
| 16 |
+
"trailing_stop": 0.025,
|
| 17 |
+
"position_size_multiplier": 1.5,
|
| 18 |
+
"max_hold_time": 20,
|
| 19 |
+
"entry_confidence_threshold": 0.6,
|
| 20 |
+
"description": "Strong upward trend with high momentum"
|
| 21 |
+
},
|
| 22 |
+
"bull_trend": {
|
| 23 |
+
"adx_min": 20,
|
| 24 |
+
"adx_max": 25,
|
| 25 |
+
"trend_strength": 0.5,
|
| 26 |
+
"volatility_max": 0.02,
|
| 27 |
+
"profit_targets": [0.01, 0.02, 0.05, 0.10],
|
| 28 |
+
"stop_loss": 0.025,
|
| 29 |
+
"trailing_stop": 0.02,
|
| 30 |
+
"position_size_multiplier": 1.2,
|
| 31 |
+
"max_hold_time": 15,
|
| 32 |
+
"entry_confidence_threshold": 0.65,
|
| 33 |
+
"description": "Moderate upward trend"
|
| 34 |
+
},
|
| 35 |
+
"bear_trend": {
|
| 36 |
+
"adx_min": 20,
|
| 37 |
+
"adx_max": 25,
|
| 38 |
+
"trend_strength": -0.5,
|
| 39 |
+
"volatility_max": 0.02,
|
| 40 |
+
"profit_targets": [0.008, 0.015, 0.03, 0.06],
|
| 41 |
+
"stop_loss": 0.02,
|
| 42 |
+
"trailing_stop": 0.015,
|
| 43 |
+
"position_size_multiplier": 0.8,
|
| 44 |
+
"max_hold_time": 12,
|
| 45 |
+
"entry_confidence_threshold": 0.7,
|
| 46 |
+
"description": "Moderate downward trend"
|
| 47 |
+
},
|
| 48 |
+
"strong_bear": {
|
| 49 |
+
"adx_min": 25,
|
| 50 |
+
"trend_strength": -0.7,
|
| 51 |
+
"volatility_max": 0.015,
|
| 52 |
+
"profit_targets": [0.005, 0.01, 0.02, 0.04],
|
| 53 |
+
"stop_loss": 0.025,
|
| 54 |
+
"trailing_stop": 0.02,
|
| 55 |
+
"position_size_multiplier": 0.6,
|
| 56 |
+
"max_hold_time": 10,
|
| 57 |
+
"entry_confidence_threshold": 0.75,
|
| 58 |
+
"description": "Strong downward trend with high momentum"
|
| 59 |
+
},
|
| 60 |
+
"ranging": {
|
| 61 |
+
"adx_max": 20,
|
| 62 |
+
"trend_strength": [-0.3, 0.3],
|
| 63 |
+
"volatility_max": 0.025,
|
| 64 |
+
"profit_targets": [0.008, 0.015, 0.03, 0.06],
|
| 65 |
+
"stop_loss": 0.015,
|
| 66 |
+
"trailing_stop": 0.01,
|
| 67 |
+
"position_size_multiplier": 0.7,
|
| 68 |
+
"max_hold_time": 8,
|
| 69 |
+
"entry_confidence_threshold": 0.8,
|
| 70 |
+
"description": "Sideways market with low trend strength"
|
| 71 |
+
},
|
| 72 |
+
"high_volatility": {
|
| 73 |
+
"volatility_min": 0.025,
|
| 74 |
+
"profit_targets": [0.02, 0.04, 0.08, 0.15],
|
| 75 |
+
"stop_loss": 0.04,
|
| 76 |
+
"trailing_stop": 0.03,
|
| 77 |
+
"position_size_multiplier": 0.6,
|
| 78 |
+
"max_hold_time": 5,
|
| 79 |
+
"entry_confidence_threshold": 0.85,
|
| 80 |
+
"description": "High volatility environment requiring quick exits"
|
| 81 |
+
}
|
| 82 |
+
},
|
| 83 |
+
"regime_transition": {
|
| 84 |
+
"min_regime_duration": 5,
|
| 85 |
+
"transition_smoothing": 0.3,
|
| 86 |
+
"confirmation_period": 3,
|
| 87 |
+
"override_conditions": {
|
| 88 |
+
"extreme_volatility": 0.05,
|
| 89 |
+
"flash_crash": -0.1,
|
| 90 |
+
"gap_threshold": 0.03
|
| 91 |
+
}
|
| 92 |
+
},
|
| 93 |
+
"performance_tracking": {
|
| 94 |
+
"regime_win_rates": {
|
| 95 |
+
"strong_bull": 0.652,
|
| 96 |
+
"bull_trend": 0.618,
|
| 97 |
+
"bear_trend": 0.521,
|
| 98 |
+
"strong_bear": 0.489,
|
| 99 |
+
"ranging": 0.521,
|
| 100 |
+
"high_volatility": 0.489
|
| 101 |
+
},
|
| 102 |
+
"regime_avg_wins": {
|
| 103 |
+
"strong_bull": 62.34,
|
| 104 |
+
"bull_trend": 54.21,
|
| 105 |
+
"bear_trend": 38.92,
|
| 106 |
+
"strong_bear": 32.15,
|
| 107 |
+
"ranging": 38.92,
|
| 108 |
+
"high_volatility": 45.67
|
| 109 |
+
},
|
| 110 |
+
"regime_sharpe_ratios": {
|
| 111 |
+
"strong_bull": 2.5,
|
| 112 |
+
"bull_trend": 2.2,
|
| 113 |
+
"bear_trend": 1.8,
|
| 114 |
+
"strong_bear": 1.5,
|
| 115 |
+
"ranging": 1.9,
|
| 116 |
+
"high_volatility": 1.6
|
| 117 |
+
}
|
| 118 |
+
},
|
| 119 |
+
"adaptive_features": {
|
| 120 |
+
"parameter_adjustment": true,
|
| 121 |
+
"confidence_weighting": true,
|
| 122 |
+
"volatility_scaling": true,
|
| 123 |
+
"trend_strength_modulation": true,
|
| 124 |
+
"learning_rate": 0.01
|
| 125 |
+
},
|
| 126 |
+
"version": "1.0.0",
|
| 127 |
+
"last_updated": "2025-10-10"
|
| 128 |
+
}
|
data/backtest_results.json
ADDED
|
@@ -0,0 +1 @@
|
|
|
|
|
|
|
| 1 |
+
{"total_reward": 239.6200055675303, "final_balance": 1239.6200055675295, "total_profit": 239.6200055675303, "initial_balance": 1000}
|
data/ensemble_backtest_metrics.json
ADDED
|
@@ -0,0 +1,12 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"total_trades": 183,
|
| 3 |
+
"win_rate": 45.90163934426229,
|
| 4 |
+
"total_pnl": -13074.987792968794,
|
| 5 |
+
"max_drawdown": 596.9121956261313,
|
| 6 |
+
"sharpe_ratio": -0.43269153651323083,
|
| 7 |
+
"profit_factor": 0.8556605408476422,
|
| 8 |
+
"avg_win": 922.7380661737351,
|
| 9 |
+
"avg_loss": -914.9998520359853,
|
| 10 |
+
"final_capital": -12974.987792968794,
|
| 11 |
+
"return_pct": -13074.987792968792
|
| 12 |
+
}
|
data/forward_test_results.json
ADDED
|
@@ -0,0 +1 @@
|
|
|
|
|
|
|
| 1 |
+
{"total_reward": -83.28493107589938, "final_balance": -665.6986215179877, "total_profit": -1665.6986215179877, "initial_balance": 1000, "profit_per_day": -16.656986215179877}
|
data/xauusd_data.csv
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
docs/AI_XAUUSD_Trading_White_Paper.pdf
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:083e9ef3168ac5ad1df00709198dec5d4b49dedda38a75f9db8897d765eb5ad3
|
| 3 |
+
size 1522584
|
models/dqn_trading_model.zip
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:663b31bbe3859f33c8bd7883bdedfd7bf2c4ceae26d4ac98dc3b8cbdf2191813
|
| 3 |
+
size 105297
|
models/ppo_continuous_trading_model.zip
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:e6934becad3f2b702d1b12d5a1a4e795d3a3b9a7d3aa8e986cb9b882719e1cff
|
| 3 |
+
size 154634
|
models/ppo_model.zip
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:ee3ef19c323e88e2b411181a42f39b254ce1b9f1a612afcb6bf7515eeedb9fe4
|
| 3 |
+
size 154622
|
models/ppo_trading_model.zip
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:8fc96204ac1c270a7b17ea2819ee1674e831a58c3e3260590306beaf353043c0
|
| 3 |
+
size 149851
|
models/sac_model.zip
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:b6b233b89d32598f6921575cb26fae3cfb7befcaf43fc4b656cd3213505ccbc4
|
| 3 |
+
size 3141770
|
models/td3_model.zip
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:4f187444be4d61f020376b5519917c459e86a036b8fbbe8915ace33bcfd76ebe
|
| 3 |
+
size 6148692
|