fix trend line training

2025-12-10 14:20:51 +02:00
parent 83bb688158
commit e200600a0a
4 changed files with 600 additions and 3845 deletions
--- a/TREND_LINE_TRAINING_SYSTEM.md
+++ b/TREND_LINE_TRAINING_SYSTEM.md
@@ -0,0 +1,242 @@
+# Trend Line Training System Implementation
+
+## Overview
+Implemented automatic trend line detection and model training system that triggers when 2 Level 2 pivots form after a trend prediction.
+
+## 1. Annotation Storage Fix ✅
+
+### Problem
+Annotations were storing large OHLCV data in JSON files:
+```json
+{
+  "market_context": {
+    "entry_state": {
+      "ohlcv_1s": {
+        "timestamps": ["2025-12-10 09:43:41", "2025-12-10 09:43:42", ...],
+        "open": [3320.1, 3320.2, ...],
+        "high": [3321.0, 3321.1, ...],
+        // ... thousands of data points
+      }
+    }
+  }
+}
+```
+
+### Solution
+**File**: `core/annotation_manager.py`
+
+**Before:**
+```python
+market_context = {
+    'entry_state': entry_market_state or {},
+    'exit_state': exit_market_state or {}
+}
+```
+
+**After:**
+```python
+market_context = {
+    'entry_timestamp': entry_point['timestamp'],
+    'exit_timestamp': exit_point['timestamp'], 
+    'timeframes_available': list((entry_market_state or {}).keys()),
+    'data_stored_in_db': True  # OHLCV data in database, not JSON
+}
+```
+
+### Benefits:
+- ✅ **Smaller JSON files** - Only metadata stored
+- ✅ **Database storage** - OHLCV data stored efficiently in database
+- ✅ **Dynamic loading** - Data fetched when needed for training
+- ✅ **Better performance** - Faster annotation loading
+
+## 2. Trend Line Training System ✅
+
+### Architecture
+**File**: `core/orchestrator.py`
+
+The system implements automatic trend validation and model training:
+
+```
+Model Prediction → Store for Validation → L2 Pivot Detection → Trend Line Creation → Model Training
+```
+
+### Key Components:
+
+#### A. Trend Prediction Storage
+```python
+def store_model_trend_prediction(model_type, symbol, timeframe, predicted_trend, confidence):
+    # Stores trend predictions waiting for validation
+```
+
+#### B. L2 Pivot Event Handling  
+```python
+def _on_pivot_detected(event_data):
+    # Handles L2L and L2H pivot detection events
+    # Checks if pivots validate any stored predictions
+```
+
+#### C. Trend Line Creation
+```python
+def _create_trend_line_and_train(symbol, timeframe, prediction):
+    # Creates trend line from 2 L2 pivots of same type
+    # Compares predicted vs actual trend
+    # Triggers backpropagation training
+```
+
+#### D. Training Integration
+```python
+def _trigger_trend_training(training_data):
+    # Triggers model training with trend validation results
+    # Prioritizes incorrect predictions for learning
+```
+
+### How It Works:
+
+#### 1. **Store Trend Prediction**
+When a model makes a trend prediction:
+```python
+orchestrator.store_model_trend_prediction(
+    model_type='transformer',
+    symbol='ETH/USDT', 
+    timeframe='1m',
+    predicted_trend='up',
+    confidence=0.85
+)
+```
+
+#### 2. **Monitor L2 Pivots**
+System subscribes to L2 pivot events from data provider:
+- Tracks L2L (Level 2 Low) and L2H (Level 2 High) pivots
+- Maintains history of recent pivots per symbol/timeframe
+
+#### 3. **Detect Trend Validation**
+When 2 L2 pivots of same type form after a prediction:
+- **2 L2H pivots** → Creates trend line, determines actual trend direction
+- **2 L2L pivots** → Creates trend line, determines actual trend direction
+
+#### 4. **Create Trend Line**
+Calculates trend line parameters:
+```python
+trend_line = {
+    'slope': calculated_slope,
+    'intercept': calculated_intercept,
+    'start_time': pivot1_timestamp,
+    'end_time': pivot2_timestamp,
+    'price_change': price_difference,
+    'time_duration': time_difference
+}
+```
+
+#### 5. **Validate Prediction**
+Compares predicted vs actual trend:
+- **Correct prediction** → Positive reinforcement training
+- **Incorrect prediction** → High-priority corrective training
+
+#### 6. **Trigger Training**
+Creates training event with validation data:
+```python
+training_event = {
+    'event_type': 'trend_validation',
+    'model_type': model_type,
+    'training_data': validation_results,
+    'training_type': 'backpropagation',
+    'priority': 'high' if incorrect else 'normal'
+}
+```
+
+### Integration Points:
+
+#### A. **Model Integration**
+Models can store trend predictions:
+```python
+# In transformer/CNN/DQN prediction methods
+if trend_prediction_available:
+    orchestrator.store_model_trend_prediction(
+        model_type='transformer',
+        symbol=symbol,
+        timeframe=timeframe,
+        predicted_trend=predicted_trend,
+        confidence=confidence
+    )
+```
+
+#### B. **Data Provider Integration**
+Data provider emits L2 pivot events:
+```python
+# In data provider pivot detection
+if pivot_level == 2:  # L2 pivot detected
+    self.emit_pivot_event({
+        'symbol': symbol,
+        'timeframe': timeframe,
+        'pivot_type': 'L2H' or 'L2L',
+        'timestamp': pivot_timestamp,
+        'price': pivot_price,
+        'strength': pivot_strength
+    })
+```
+
+#### C. **Training System Integration**
+Uses integrated training coordination:
+- Creates training sessions
+- Triggers training events
+- Tracks training progress
+- Stores validation results
+
+### Statistics and Monitoring:
+
+```python
+stats = orchestrator.get_trend_training_stats()
+# Returns:
+# {
+#   'total_predictions': 15,
+#   'validated_predictions': 8, 
+#   'correct_predictions': 6,
+#   'accuracy': 0.75,
+#   'pending_validations': 7
+# }
+```
+
+## 3. Expected Workflow
+
+### Real-Time Operation:
+1. **Model makes trend prediction** → Stored for validation
+2. **Market moves, L2 pivots form** → System monitors
+3. **2nd L2 pivot of same type detected** → Trend line created
+4. **Actual trend determined** → Compared with prediction
+5. **Training triggered** → Model learns from validation
+6. **Stats updated** → Track accuracy over time
+
+### Training Benefits:
+- ✅ **Automatic validation** - No manual intervention needed
+- ✅ **Real market feedback** - Uses actual L2 pivot formations
+- ✅ **Prioritized learning** - Focuses on incorrect predictions
+- ✅ **Continuous improvement** - Models learn from trend accuracy
+- ✅ **Statistical tracking** - Monitor prediction accuracy over time
+
+## 4. Files Modified
+
+### Core System:
+- `core/annotation_manager.py` - Removed OHLCV from JSON storage
+- `core/orchestrator.py` - Added trend line training system
+
+### New Capabilities:
+- Automatic trend validation using L2 pivots
+- Model training triggered by trend line formation
+- Statistical tracking of trend prediction accuracy
+- Integration with existing training coordination system
+
+## 5. Next Steps
+
+### Integration Required:
+1. **Model Integration** - Add trend prediction storage to transformer/CNN/DQN
+2. **Pivot Events** - Ensure data provider emits L2 pivot events
+3. **Training Handlers** - Add trend validation training to model trainers
+4. **Dashboard** - Display trend training statistics
+
+### Testing:
+1. **Store test prediction** - Verify prediction storage works
+2. **Simulate L2 pivots** - Test trend line creation
+3. **Monitor training** - Verify training events are triggered
+4. **Check accuracy** - Monitor prediction accuracy over time
+
+The system is now ready to automatically learn from trend predictions using real L2 pivot formations! 🎯