popov/gogo2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

more cleanup

Browse Source
This commit is contained in:
Dobromir Popov
2025-10-13 16:11:06 +03:00
parent 6cf4d902df
commit 0c28a0997c
17 changed files with 1030 additions and 2301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

333
.kiro/specs/1.multi-modal-trading-system/AUDIT_SUMMARY.md Normal file
View File

@@ -0,0 +1,333 @@
# Multi-Modal Trading System - Audit Summary
**Date**: January 9, 2025
**Focus**: Data Collection/Provider Backbone
## Executive Summary
Comprehensive audit of the multi-modal trading system revealed a **strong, well-architected data provider backbone** with robust implementations across multiple layers. The system demonstrates excellent separation of concerns with COBY (standalone multi-exchange aggregation), Core DataProvider (real-time operations), and StandardizedDataProvider (unified model interface).
## Architecture Overview
```
┌─────────────────────────────────────────────────────────────┐
│ COBY System (Standalone) │
│ Multi-Exchange Aggregation │ TimescaleDB │ Redis Cache │
│ Status: ✅ Fully Operational │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ Core DataProvider (core/data_provider.py) │
│ Automatic Maintenance │ Williams Pivots │ COB Integration │
│ Status: ✅ Implemented, Needs Enhancement │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ StandardizedDataProvider (core/standardized_data_provider.py) │
│ BaseDataInput │ ModelOutputManager │ Unified Interface │
│ Status: ✅ Implemented, Needs Heatmap Integration │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ Models (CNN, RL, etc.) │
└─────────────────────────────────────────────────────────────┘
```
## Key Findings
### ✅ Strengths (Fully Implemented)
1. **COBY System**
- Standalone multi-exchange data aggregation
- TimescaleDB for time-series storage
- Redis caching layer
- REST API and WebSocket server
- Performance monitoring and health checks
- **Status**: Production-ready
2. **Core DataProvider**
- Automatic data maintenance with background workers
- 1500 candles cached per symbol/timeframe (1s, 1m, 1h, 1d)
- Automatic fallback between Binance and MEXC
- Thread-safe data access with locks
- Centralized subscriber management
- **Status**: Robust and operational
3. **Williams Market Structure**
- Recursive pivot point detection with 5 levels
- Monthly 1s data analysis for comprehensive context
- Pivot-based normalization bounds (PivotBounds)
- Support/resistance level tracking
- **Status**: Advanced implementation
4. **EnhancedCOBWebSocket**
- Multiple Binance streams (depth@100ms, ticker, aggTrade)
- Proper order book synchronization with REST snapshots
- Automatic reconnection with exponential backoff
- 24-hour connection limit compliance
- Comprehensive error handling
- **Status**: Production-grade
5. **COB Integration**
- 1s aggregation with price buckets ($1 ETH, $10 BTC)
- Multi-timeframe imbalance MA (1s, 5s, 15s, 60s)
- 30-minute raw tick buffer (180,000 ticks)
- Bid/ask volumes and imbalances per bucket
- **Status**: Functional, needs robustness improvements
6. **StandardizedDataProvider**
- BaseDataInput with comprehensive fields
- ModelOutputManager for cross-model feeding
- COB moving average calculation
- Live price fetching with multiple fallbacks
- **Status**: Core functionality complete
### ⚠️ Partial Implementations (Needs Validation)
1. **COB Raw Tick Storage**
- Structure exists (30 min buffer)
- Needs validation under load
- Potential NoneType errors in aggregation worker
2. **Training Data Collection**
- Callback structure exists
- Needs integration with training pipelines
- Validation of data flow required
3. **Cross-Exchange COB Consolidation**
- COBY system separate from core
- No unified interface yet
- Needs adapter layer
### ❌ Areas Needing Enhancement
1. **COB Data Collection Robustness**
- **Issue**: NoneType errors in `_cob_aggregation_worker`
- **Impact**: Potential data loss during aggregation
- **Priority**: HIGH
- **Solution**: Add defensive checks, proper initialization guards
2. **Configurable COB Price Ranges**
- **Issue**: Hardcoded ranges ($5 ETH, $50 BTC)
- **Impact**: Inflexible for different market conditions
- **Priority**: MEDIUM
- **Solution**: Move to config.yaml, add per-symbol customization
3. **COB Heatmap Generation**
- **Issue**: Not implemented
- **Impact**: Missing visualization and model input feature
- **Priority**: MEDIUM
- **Solution**: Implement `get_cob_heatmap_matrix()` method
4. **Data Quality Scoring**
- **Issue**: No comprehensive validation
- **Impact**: Models may receive incomplete data
- **Priority**: HIGH
- **Solution**: Implement data completeness scoring (0.0-1.0)
5. **COBY-Core Integration**
- **Issue**: Systems operate independently
- **Impact**: Cannot leverage multi-exchange data in real-time trading
- **Priority**: MEDIUM
- **Solution**: Create COBYDataAdapter for unified access
6. **BaseDataInput Validation**
- **Issue**: Basic validation only
- **Impact**: Insufficient data quality checks
- **Priority**: HIGH
- **Solution**: Enhanced validate() with detailed error messages
## Data Flow Analysis
### Current Data Flow
```
Exchange APIs (Binance, MEXC)
↓
EnhancedCOBWebSocket (depth@100ms, ticker, aggTrade)
↓
DataProvider (automatic maintenance, caching)
↓
COB Aggregation (1s buckets, MA calculations)
↓
StandardizedDataProvider (BaseDataInput creation)
↓
Models (CNN, RL) via get_base_data_input()
↓
ModelOutputManager (cross-model feeding)
```
### Parallel COBY Flow
```
Multiple Exchanges (Binance, Coinbase, Kraken, etc.)
↓
COBY Connectors (WebSocket streams)
↓
TimescaleDB (persistent storage)
↓
Redis Cache (high-performance access)
↓
REST API / WebSocket Server
↓
Dashboard / External Consumers
```
## Performance Characteristics
### Core DataProvider
- **Cache Size**: 1500 candles × 4 timeframes × 2 symbols = 12,000 candles
- **Update Frequency**: Every half-candle period (0.5s for 1s, 30s for 1m, etc.)
- **COB Buffer**: 180,000 raw ticks (30 min @ ~100 ticks/sec)
- **Thread Safety**: Lock-based synchronization
- **Memory Footprint**: Estimated 50-100 MB for cached data
### EnhancedCOBWebSocket
- **Streams**: 3 per symbol (depth, ticker, aggTrade)
- **Update Rate**: 100ms for depth, real-time for trades
- **Reconnection**: Exponential backoff (1s → 60s max)
- **Order Book Depth**: 1000 levels (maximum Binance allows)
### COBY System
- **Storage**: TimescaleDB with automatic compression
- **Cache**: Redis with configurable TTL
- **Throughput**: Handles multiple exchanges simultaneously
- **Latency**: Sub-second for cached data
## Code Quality Assessment
### Excellent
- ✅ Comprehensive error handling in EnhancedCOBWebSocket
- ✅ Thread-safe data access patterns
- ✅ Clear separation of concerns across layers
- ✅ Extensive logging for debugging
- ✅ Proper use of dataclasses for type safety
### Good
- ✅ Automatic data maintenance workers
- ✅ Fallback mechanisms for API failures
- ✅ Subscriber pattern for data distribution
- ✅ Pivot-based normalization system
### Needs Improvement
- ⚠️ Defensive programming in COB aggregation
- ⚠️ Configuration management (hardcoded values)
- ⚠️ Comprehensive input validation
- ⚠️ Data quality monitoring
## Recommendations
### Immediate Actions (High Priority)
1. **Fix COB Aggregation Robustness** (Task 1.1)
- Add defensive checks in `_cob_aggregation_worker`
- Implement proper initialization guards
- Test under failure scenarios
- **Estimated Effort**: 2-4 hours
2. **Implement Data Quality Scoring** (Task 2.3)
- Create `data_quality_score()` method
- Add completeness, freshness, consistency checks
- Prevent inference on low-quality data (< 0.8)
- **Estimated Effort**: 4-6 hours
3. **Enhance BaseDataInput Validation** (Task 2)
- Minimum frame count validation
- COB data structure validation
- Detailed error messages
- **Estimated Effort**: 3-5 hours
### Short-Term Enhancements (Medium Priority)
4. **Implement COB Heatmap Generation** (Task 1.4)
- Create `get_cob_heatmap_matrix()` method
- Support configurable time windows and price ranges
- Cache for performance
- **Estimated Effort**: 6-8 hours
5. **Configurable COB Price Ranges** (Task 1.2)
- Move to config.yaml
- Per-symbol customization
- Update imbalance calculations
- **Estimated Effort**: 2-3 hours
6. **Integrate COB Heatmap into BaseDataInput** (Task 2.1)
- Add heatmap fields to BaseDataInput
- Call heatmap generation in `get_base_data_input()`
- Handle failures gracefully
- **Estimated Effort**: 2-3 hours
### Long-Term Improvements (Lower Priority)
7. **COBY-Core Integration** (Tasks 3, 3.1, 3.2, 3.3)
- Design unified interface
- Implement COBYDataAdapter
- Merge heatmap data
- Health monitoring
- **Estimated Effort**: 16-24 hours
8. **Model Output Persistence** (Task 4.1)
- Disk-based storage
- Configurable retention
- Compression
- **Estimated Effort**: 8-12 hours
9. **Comprehensive Testing** (Tasks 5, 5.1, 5.2)
- Unit tests for all components
- Integration tests
- Performance benchmarks
- **Estimated Effort**: 20-30 hours
## Risk Assessment
### Low Risk
- Core DataProvider stability
- EnhancedCOBWebSocket reliability
- Williams Market Structure accuracy
- COBY system operation
### Medium Risk
- COB aggregation under high load
- Data quality during API failures
- Memory usage with extended caching
- Integration complexity with COBY
### High Risk
- Model inference on incomplete data (mitigated by validation)
- Data loss during COB aggregation errors (needs immediate fix)
- Performance degradation with multiple models (needs monitoring)
## Conclusion
The multi-modal trading system has a **solid, well-architected data provider backbone** with excellent separation of concerns and robust implementations. The three-layer architecture (COBY → Core → Standardized) provides flexibility and scalability.
**Key Strengths**:
- Production-ready COBY system
- Robust automatic data maintenance
- Advanced Williams Market Structure pivots
- Comprehensive COB integration
- Extensible model output management
**Priority Improvements**:
1. COB aggregation robustness (HIGH)
2. Data quality scoring (HIGH)
3. BaseDataInput validation (HIGH)
4. COB heatmap generation (MEDIUM)
5. COBY-Core integration (MEDIUM)
**Overall Assessment**: The system is **production-ready for core functionality** with identified enhancements that will improve robustness, data quality, and feature completeness. The updated spec provides a clear roadmap for systematic improvements.
## Next Steps
1. Review and approve updated spec documents
2. Prioritize tasks based on business needs
3. Begin with high-priority robustness improvements
4. Implement data quality scoring and validation
5. Add COB heatmap generation for enhanced model inputs
6. Plan COBY-Core integration for multi-exchange capabilities
---
**Audit Completed By**: Kiro AI Assistant
**Date**: January 9, 2025
**Spec Version**: 1.1 (Updated)

470
.kiro/specs/1.multi-modal-trading-system/DATA_PROVIDER_QUICK_REFERENCE.md Normal file
View File

@@ -0,0 +1,470 @@
# Data Provider Quick Reference Guide
## Overview
Quick reference for using the multi-layered data provider system in the multi-modal trading system.
## Architecture Layers
```
COBY System → Core DataProvider → StandardizedDataProvider → Models
```
## Getting Started
### Basic Usage
```python
from core.standardized_data_provider import StandardizedDataProvider
# Initialize provider
provider = StandardizedDataProvider(
symbols=['ETH/USDT', 'BTC/USDT'],
timeframes=['1s', '1m', '1h', '1d']
)
# Start real-time processing
provider.start_real_time_processing()
# Get standardized input for models
base_input = provider.get_base_data_input('ETH/USDT')
# Validate data quality
if base_input and base_input.validate():
# Use data for model inference
pass
```
## BaseDataInput Structure
```python
@dataclass
class BaseDataInput:
symbol: str # 'ETH/USDT'
timestamp: datetime # Current time
# OHLCV Data (300 frames each)
ohlcv_1s: List[OHLCVBar] # 1-second bars
ohlcv_1m: List[OHLCVBar] # 1-minute bars
ohlcv_1h: List[OHLCVBar] # 1-hour bars
ohlcv_1d: List[OHLCVBar] # 1-day bars
btc_ohlcv_1s: List[OHLCVBar] # BTC reference
# COB Data
cob_data: Optional[COBData] # Order book data
# Technical Analysis
technical_indicators: Dict[str, float] # RSI, MACD, etc.
pivot_points: List[PivotPoint] # Williams pivots
# Cross-Model Feeding
last_predictions: Dict[str, ModelOutput] # Other model outputs
# Market Microstructure
market_microstructure: Dict[str, Any] # Order flow, etc.
```
## Common Operations
### Get Current Price
```python
# Multiple fallback methods
price = provider.get_current_price('ETH/USDT')
# Direct API call with cache
price = provider.get_live_price_from_api('ETH/USDT')
```
### Get Historical Data
```python
# Get OHLCV data
df = provider.get_historical_data(
symbol='ETH/USDT',
timeframe='1h',
limit=300
)
```
### Get COB Data
```python
# Get latest COB snapshot
cob_data = provider.get_latest_cob_data('ETH/USDT')
# Get COB imbalance metrics
imbalance = provider.get_current_cob_imbalance('ETH/USDT')
```
### Get Pivot Points
```python
# Get Williams Market Structure pivots
pivots = provider.calculate_williams_pivot_points('ETH/USDT')
```
### Store Model Output
```python
from core.data_models import ModelOutput
# Create model output
output = ModelOutput(
model_type='cnn',
model_name='williams_cnn_v2',
symbol='ETH/USDT',
timestamp=datetime.now(),
confidence=0.85,
predictions={
'action': 'BUY',
'action_confidence': 0.85,
'direction_vector': 0.7
},
hidden_states={'conv_features': tensor(...)},
metadata={'version': '2.1'}
)
# Store for cross-model feeding
provider.store_model_output(output)
```
### Get Model Outputs
```python
# Get all model outputs for a symbol
outputs = provider.get_model_outputs('ETH/USDT')
# Access specific model output
cnn_output = outputs.get('williams_cnn_v2')
```
## Data Validation
### Validate BaseDataInput
```python
base_input = provider.get_base_data_input('ETH/USDT')
if base_input:
# Check validation
is_valid = base_input.validate()
# Check data completeness
if len(base_input.ohlcv_1s) >= 100:
# Sufficient data for inference
pass
```
### Check Data Quality
```python
# Get data completeness metrics
if base_input:
ohlcv_complete = all([
len(base_input.ohlcv_1s) >= 100,
len(base_input.ohlcv_1m) >= 100,
len(base_input.ohlcv_1h) >= 100,
len(base_input.ohlcv_1d) >= 100
])
cob_complete = base_input.cob_data is not None
# Overall quality score (implement in Task 2.3)
# quality_score = base_input.data_quality_score()
```
## COB Data Access
### COB Data Structure
```python
@dataclass
class COBData:
symbol: str
timestamp: datetime
current_price: float
bucket_size: float # $1 ETH, $10 BTC
# Price Buckets (±20 around current price)
price_buckets: Dict[float, Dict[str, float]] # {price: {bid_vol, ask_vol}}
bid_ask_imbalance: Dict[float, float] # {price: imbalance}
# Moving Averages (±5 buckets)
ma_1s_imbalance: Dict[float, float]
ma_5s_imbalance: Dict[float, float]
ma_15s_imbalance: Dict[float, float]
ma_60s_imbalance: Dict[float, float]
# Order Flow
order_flow_metrics: Dict[str, float]
```
### Access COB Buckets
```python
if base_input.cob_data:
cob = base_input.cob_data
# Get current price
current_price = cob.current_price
# Get bid/ask volumes for specific price
price_level = current_price + cob.bucket_size # One bucket up
if price_level in cob.price_buckets:
bucket = cob.price_buckets[price_level]
bid_volume = bucket.get('bid_volume', 0)
ask_volume = bucket.get('ask_volume', 0)
# Get imbalance for price level
imbalance = cob.bid_ask_imbalance.get(price_level, 0)
# Get moving averages
ma_1s = cob.ma_1s_imbalance.get(price_level, 0)
ma_5s = cob.ma_5s_imbalance.get(price_level, 0)
```
## Subscriber Pattern
### Subscribe to Data Updates
```python
def my_data_callback(tick):
"""Handle real-time tick data"""
print(f"Received tick: {tick.symbol} @ {tick.price}")
# Subscribe to data updates
subscriber_id = provider.subscribe_to_data(
callback=my_data_callback,
symbols=['ETH/USDT'],
subscriber_name='my_model'
)
# Unsubscribe when done
provider.unsubscribe_from_data(subscriber_id)
```
## Configuration
### Key Configuration Options
```yaml
# config.yaml
data_provider:
symbols:
- ETH/USDT
- BTC/USDT
timeframes:
- 1s
- 1m
- 1h
- 1d
cache:
enabled: true
candles_per_timeframe: 1500
cob:
enabled: true
bucket_sizes:
ETH/USDT: 1.0 # $1 buckets
BTC/USDT: 10.0 # $10 buckets
price_ranges:
ETH/USDT: 5.0 # ±$5 for imbalance
BTC/USDT: 50.0 # ±$50 for imbalance
websocket:
update_speed: 100ms
max_depth: 1000
reconnect_delay: 1.0
max_reconnect_delay: 60.0
```
## Performance Tips
### Optimize Data Access
```python
# Cache BaseDataInput for multiple models
base_input = provider.get_base_data_input('ETH/USDT')
# Use cached data for all models
cnn_input = base_input # CNN uses full data
rl_input = base_input # RL uses full data + CNN outputs
# Avoid repeated calls
# BAD: base_input = provider.get_base_data_input('ETH/USDT') # Called multiple times
# GOOD: Cache and reuse
```
### Monitor Performance
```python
# Check subscriber statistics
stats = provider.distribution_stats
print(f"Total ticks received: {stats['total_ticks_received']}")
print(f"Total ticks distributed: {stats['total_ticks_distributed']}")
print(f"Distribution errors: {stats['distribution_errors']}")
```
## Troubleshooting
### Common Issues
#### 1. No Data Available
```python
base_input = provider.get_base_data_input('ETH/USDT')
if base_input is None:
# Check if data provider is started
if not provider.data_maintenance_active:
provider.start_automatic_data_maintenance()
# Check if COB collection is started
if not provider.cob_collection_active:
provider.start_cob_collection()
```
#### 2. Incomplete Data
```python
if base_input:
# Check frame counts
print(f"1s frames: {len(base_input.ohlcv_1s)}")
print(f"1m frames: {len(base_input.ohlcv_1m)}")
print(f"1h frames: {len(base_input.ohlcv_1h)}")
print(f"1d frames: {len(base_input.ohlcv_1d)}")
# Wait for data to accumulate
if len(base_input.ohlcv_1s) < 100:
print("Waiting for more data...")
time.sleep(60) # Wait 1 minute
```
#### 3. COB Data Missing
```python
if base_input and base_input.cob_data is None:
# Check COB collection status
if not provider.cob_collection_active:
provider.start_cob_collection()
# Check WebSocket status
if hasattr(provider, 'enhanced_cob_websocket'):
ws = provider.enhanced_cob_websocket
status = ws.status.get('ETH/USDT')
print(f"WebSocket connected: {status.connected}")
print(f"Last message: {status.last_message_time}")
```
#### 4. Price Data Stale
```python
# Force refresh price
price = provider.get_live_price_from_api('ETH/USDT')
# Check cache freshness
if 'ETH/USDT' in provider.live_price_cache:
cached_price, timestamp = provider.live_price_cache['ETH/USDT']
age = datetime.now() - timestamp
print(f"Price cache age: {age.total_seconds()}s")
```
## Best Practices
### 1. Always Validate Data
```python
base_input = provider.get_base_data_input('ETH/USDT')
if base_input and base_input.validate():
# Safe to use for inference
model_output = model.predict(base_input)
else:
# Log and skip inference
logger.warning("Invalid or incomplete data, skipping inference")
```
### 2. Handle Missing Data Gracefully
```python
# Never use synthetic data
if base_input is None:
logger.error("No data available")
return None # Don't proceed with inference
# Check specific components
if base_input.cob_data is None:
logger.warning("COB data unavailable, using OHLCV only")
# Proceed with reduced features or skip
```
### 3. Store Model Outputs
```python
# Always store outputs for cross-model feeding
output = model.predict(base_input)
provider.store_model_output(output)
# Other models can now access this output
```
### 4. Monitor Data Quality
```python
# Implement quality checks
def check_data_quality(base_input):
if not base_input:
return 0.0
score = 0.0
# OHLCV completeness (40%)
ohlcv_score = min(1.0, len(base_input.ohlcv_1s) / 300) * 0.4
score += ohlcv_score
# COB availability (30%)
cob_score = 0.3 if base_input.cob_data else 0.0
score += cob_score
# Pivot points (20%)
pivot_score = 0.2 if base_input.pivot_points else 0.0
score += pivot_score
# Freshness (10%)
age = (datetime.now() - base_input.timestamp).total_seconds()
freshness_score = max(0, 1.0 - age / 60) * 0.1 # Decay over 1 minute
score += freshness_score
return score
# Use quality score
quality = check_data_quality(base_input)
if quality < 0.8:
logger.warning(f"Low data quality: {quality:.2f}")
```
## File Locations
- **Core DataProvider**: `core/data_provider.py`
- **Standardized Provider**: `core/standardized_data_provider.py`
- **Enhanced COB WebSocket**: `core/enhanced_cob_websocket.py`
- **Williams Market Structure**: `core/williams_market_structure.py`
- **Data Models**: `core/data_models.py`
- **Model Output Manager**: `core/model_output_manager.py`
- **COBY System**: `COBY/` directory
## Additional Resources
- **Requirements**: `.kiro/specs/1.multi-modal-trading-system/requirements.md`
- **Design**: `.kiro/specs/1.multi-modal-trading-system/design.md`
- **Tasks**: `.kiro/specs/1.multi-modal-trading-system/tasks.md`
- **Audit Summary**: `.kiro/specs/1.multi-modal-trading-system/AUDIT_SUMMARY.md`
---
**Last Updated**: January 9, 2025
**Version**: 1.0

324
.kiro/specs/1.multi-modal-trading-system/tasks.md
View File

@@ -1,67 +1,206 @@
# Implementation Plan
## Enhanced Data Provider and COB Integration
## Data Provider Backbone Enhancement
- [ ] 1. Enhance the existing DataProvider class with standardized model inputs
- Extend the current implementation in core/data_provider.py
- Implement standardized COB+OHLCV data frame for all models
- Create unified input format: 300 frames OHLCV (1s, 1m, 1h, 1d) ETH + 300s of 1s BTC
- Integrate with existing multi_exchange_cob_provider.py for COB data
- _Requirements: 1.1, 1.2, 1.3, 1.6_
### Phase 1: Core Data Provider Enhancements
- [ ] 1.1. Implement standardized COB+OHLCV data frame for all models
- Create BaseDataInput class with standardized format for all models
- Implement OHLCV: 300 frames of (1s, 1m, 1h, 1d) ETH + 300s of 1s BTC
- Add COB: ±20 buckets of COB amounts in USD for each 1s OHLCV
- Include 1s, 5s, 15s, and 60s MA of COB imbalance counting ±5 COB buckets
- Ensure all models receive identical input format for consistency
- _Requirements: 1.2, 1.3, 8.1_
- [ ] 1. Audit and validate existing DataProvider implementation
- Review core/data_provider.py for completeness and correctness
- Validate 1500-candle caching is working correctly
- Verify automatic data maintenance worker is updating properly
- Test fallback mechanisms between Binance and MEXC
- Document any gaps or issues found
- _Requirements: 1.1, 1.2, 1.6_
- [ ] 1.2. Implement extensible model output storage
- Create standardized ModelOutput data structure
- Support CNN, RL, LSTM, Transformer, and future model types
- Include model-specific predictions and cross-model hidden states
- Add metadata support for extensible model information
- _Requirements: 1.10, 8.2_
- [ ] 1.1. Enhance COB data collection robustness
- Fix 'NoneType' object has no attribute 'append' errors in _cob_aggregation_worker
- Add defensive checks before accessing deque structures
- Implement proper initialization guards to prevent duplicate COB collection starts
- Add comprehensive error logging for COB data processing failures
- Test COB collection under various failure scenarios
- _Requirements: 1.3, 1.6_
- [ ] 1.3. Enhance Williams Market Structure pivot point calculation
- Extend existing williams_market_structure.py implementation
- Improve recursive pivot point calculation accuracy
- Add unit tests to verify pivot point detection
- Integrate with COB data for enhanced pivot detection
- [ ] 1.2. Implement configurable COB price ranges
- Replace hardcoded price ranges ($5 ETH, $50 BTC) with configuration
- Add _get_price_range_for_symbol() configuration support
- Allow per-symbol price range customization via config.yaml
- Update COB imbalance calculations to use configurable ranges
- Document price range selection rationale
- _Requirements: 1.4, 1.1_
- [ ] 1.3. Validate and enhance Williams Market Structure pivot calculation
- Review williams_market_structure.py implementation
- Verify 5-level pivot detection is working correctly
- Test monthly 1s data analysis for comprehensive context
- Add unit tests for pivot point detection accuracy
- Optimize pivot calculation performance if needed
- _Requirements: 1.5, 2.7_
- [x] 1.4. Optimize real-time data streaming with COB integration
- [ ] 1.4. Implement COB heatmap matrix generation
- Create get_cob_heatmap_matrix() method in DataProvider
- Generate time x price matrix for visualization and model input
- Support configurable time windows (default 300 seconds)
- Support configurable price bucket radius (default ±10 buckets)
- Support multiple metrics (imbalance, volume, spread)
- Cache heatmap data for performance
- _Requirements: 1.4, 1.1_
- Enhance existing WebSocket connections in enhanced_cob_websocket.py
- Implement 10Hz COB data streaming alongside OHLCV data
- Add data synchronization across different refresh rates
- Ensure thread-safe access to multi-rate data streams
- [x] 1.5. Enhance EnhancedCOBWebSocket reliability
- Review enhanced_cob_websocket.py for stability issues
- Verify proper order book synchronization with REST snapshots
- Test reconnection logic with exponential backoff
- Ensure 24-hour connection limit compliance
- Add comprehensive error handling for all WebSocket streams
- _Requirements: 1.3, 1.6_
### Phase 2: StandardizedDataProvider Enhancements
- [ ] 2. Implement comprehensive BaseDataInput validation
- Enhance validate() method in BaseDataInput dataclass
- Add minimum frame count validation (100 frames per timeframe)
- Implement data completeness scoring (0.0 to 1.0)
- Add COB data validation (non-null, valid buckets)
- Create detailed validation error messages
- Prevent model inference on incomplete data (completeness < 0.8)
- _Requirements: 1.1.2, 1.1.6_
- [ ] 2.1. Integrate COB heatmap into BaseDataInput
- Add cob_heatmap_times, cob_heatmap_prices, cob_heatmap_values fields
- Call get_cob_heatmap_matrix() in get_base_data_input()
- Handle heatmap generation failures gracefully
- Store heatmap mid_prices in market_microstructure
- Document heatmap usage for models
- _Requirements: 1.1.1, 1.4_
- [ ] 2.2. Enhance COB moving average calculation
- Review _calculate_cob_moving_averages() for correctness
- Fix bucket quantization to match COB snapshot buckets
- Implement nearest-key matching for historical imbalance lookup
- Add thread-safe access to cob_imbalance_history
- Optimize MA calculation performance
- _Requirements: 1.1.3, 1.4_
- [ ] 2.3. Implement data quality scoring system
- Create data_quality_score() method
- Score based on: data completeness, freshness, consistency
- Add quality thresholds for model inference
- Log quality metrics for monitoring
- Provide quality breakdown in BaseDataInput
- _Requirements: 1.1.2, 1.1.6_
- [ ] 2.4. Enhance live price fetching robustness
- Review get_live_price_from_api() fallback chain
- Add retry logic with exponential backoff
- Implement circuit breaker for repeated API failures
- Cache prices with configurable TTL (default 500ms)
- Log price source for debugging
- _Requirements: 1.6, 1.7_
### Phase 3: COBY Integration
- [ ] 3. Design unified interface between COBY and core DataProvider
- Define clear boundaries between COBY and core systems
- Create adapter layer for accessing COBY data from core
- Design data flow for multi-exchange aggregation
- Plan migration path for existing code
- Document integration architecture
- _Requirements: 1.10, 8.1_
- [ ] 3.1. Implement COBY data access adapter
- Create COBYDataAdapter class in core/
- Implement methods to query COBY TimescaleDB
- Add Redis cache integration for performance
- Support historical data retrieval from COBY
- Handle COBY unavailability gracefully
- _Requirements: 1.10, 8.1_
- [ ] 3.2. Integrate COBY heatmap data
- Query COBY for multi-exchange heatmap data
- Merge COBY heatmaps with core COB heatmaps
- Provide unified heatmap interface to models
- Support exchange-specific heatmap filtering
- Cache merged heatmaps for performance
- _Requirements: 1.4, 3.1_
- [ ] 3.3. Implement COBY health monitoring
- Add COBY connection status to DataProvider
- Monitor COBY API availability
- Track COBY data freshness
- Alert on COBY failures
- Provide COBY status in dashboard
- _Requirements: 1.6, 8.5_
- [ ] 1.5. Fix WebSocket COB data processing errors
- Fix 'NoneType' object has no attribute 'append' errors in COB data processing
- Ensure proper initialization of data structures in MultiExchangeCOBProvider
- Add validation and defensive checks before accessing data structures
- Implement proper error handling for WebSocket data processing
- _Requirements: 1.1, 1.6, 8.5_
### Phase 4: Model Output Management
- [ ] 1.6. Enhance error handling in COB data processing
- Add validation for incoming WebSocket data
- Implement reconnection logic with exponential backoff
- Add detailed logging for debugging COB data issues
- Ensure system continues operation with last valid data during failures
- _Requirements: 1.6, 8.5_
- [ ] 4. Enhance ModelOutputManager functionality
- Review model_output_manager.py implementation
- Verify extensible ModelOutput format is working
- Test cross-model feeding with hidden states
- Validate historical output storage (1000 entries)
- Optimize query performance by model_name, symbol, timestamp
- _Requirements: 1.10, 8.2_
- [ ] 4.1. Implement model output persistence
- Add disk-based storage for model outputs
- Support configurable retention policies
- Implement efficient serialization (pickle/msgpack)
- Add compression for storage optimization
- Support output replay for backtesting
- _Requirements: 1.10, 5.7_
- [ ] 4.2. Create model output analytics
- Track prediction accuracy over time
- Calculate model agreement/disagreement metrics
- Identify model performance patterns
- Generate model comparison reports
- Visualize model outputs in dashboard
- _Requirements: 5.8, 10.7_
### Phase 5: Testing and Validation
- [ ] 5. Create comprehensive data provider tests
- Write unit tests for DataProvider core functionality
- Test automatic data maintenance worker
- Test COB aggregation and imbalance calculations
- Test Williams pivot point detection
- Test StandardizedDataProvider validation
- _Requirements: 8.1, 8.2_
- [ ] 5.1. Implement integration tests
- Test end-to-end data flow from WebSocket to models
- Test COBY integration (when implemented)
- Test model output storage and retrieval
- Test data provider under load
- Test failure scenarios and recovery
- _Requirements: 8.2, 8.3_
- [ ] 5.2. Create data provider performance benchmarks
- Measure data collection latency
- Measure COB aggregation performance
- Measure BaseDataInput creation time
- Identify performance bottlenecks
- Optimize critical paths
- _Requirements: 8.4_
- [ ] 5.3. Document data provider architecture
- Create comprehensive architecture documentation
- Document data flow diagrams
- Document configuration options
- Create troubleshooting guide
- Add code examples for common use cases
- _Requirements: 8.1, 8.2_
## Enhanced CNN Model Implementation
- [ ] 2. Enhance the existing CNN model with standardized inputs/outputs
- [ ] 6. Enhance the existing CNN model with standardized inputs/outputs
- Extend the current implementation in NN/models/enhanced_cnn.py
- Accept standardized COB+OHLCV data frame: 300 frames (1s,1m,1h,1d) ETH + 300s 1s BTC
- Include COB ±20 buckets and MA (1s,5s,15s,60s) of COB imbalance ±5 buckets
- Output BUY/SELL trading action with confidence scores - _Requirements: 2.1, 2.2, 2.8, 1.10_
- Output BUY/SELL trading action with confidence scores
- _Requirements: 2.1, 2.2, 2.8, 1.10_
- [x] 2.1. Implement CNN inference with standardized input format
- [x] 6.1. Implement CNN inference with standardized input format
- Accept BaseDataInput with standardized COB+OHLCV format
- Process 300 frames of multi-timeframe data with COB buckets
- Output BUY/SELL recommendations with confidence scores
@@ -69,7 +208,7 @@
- Optimize inference performance for real-time processing
- _Requirements: 2.2, 2.6, 2.8, 4.3_
- [x] 2.2. Enhance CNN training pipeline with checkpoint management
- [x] 6.2. Enhance CNN training pipeline with checkpoint management
- Integrate with checkpoint manager for training progress persistence
- Store top 5-10 best checkpoints based on performance metrics
- Automatically load best checkpoint at startup
@@ -77,7 +216,7 @@
- Store metadata with checkpoints for performance tracking
- _Requirements: 2.4, 2.5, 5.2, 5.3, 5.7_
- [ ] 2.3. Implement CNN model evaluation and checkpoint optimization
- [ ] 6.3. Implement CNN model evaluation and checkpoint optimization
- Create evaluation methods using standardized input/output format
- Implement performance metrics for checkpoint ranking
- Add validation against historical trading outcomes
@@ -87,14 +226,14 @@
## Enhanced RL Model Implementation
- [ ] 3. Enhance the existing RL model with standardized inputs/outputs
- [ ] 7. Enhance the existing RL model with standardized inputs/outputs
- Extend the current implementation in NN/models/dqn_agent.py
- Accept standardized COB+OHLCV data frame: 300 frames (1s,1m,1h,1d) ETH + 300s 1s BTC
- Include COB ±20 buckets and MA (1s,5s,15s,60s) of COB imbalance ±5 buckets
- Output BUY/SELL trading action with confidence scores
- _Requirements: 3.1, 3.2, 3.7, 1.10_
- [ ] 3.1. Implement RL inference with standardized input format
- [ ] 7.1. Implement RL inference with standardized input format
- Accept BaseDataInput with standardized COB+OHLCV format
- Process CNN hidden states and predictions as part of state input
- Output BUY/SELL recommendations with confidence scores
@@ -102,7 +241,7 @@
- Optimize inference performance for real-time processing
- _Requirements: 3.2, 3.7, 4.3_
- [ ] 3.2. Enhance RL training pipeline with checkpoint management
- [ ] 7.2. Enhance RL training pipeline with checkpoint management
- Integrate with checkpoint manager for training progress persistence
- Store top 5-10 best checkpoints based on trading performance metrics
- Automatically load best checkpoint at startup
@@ -110,7 +249,7 @@
- Store metadata with checkpoints for performance tracking
- _Requirements: 3.3, 3.5, 5.4, 5.7, 4.4_
- [ ] 3.3. Implement RL model evaluation and checkpoint optimization
- [ ] 7.3. Implement RL model evaluation and checkpoint optimization
- Create evaluation methods using standardized input/output format
- Implement trading performance metrics for checkpoint ranking
- Add validation against historical trading opportunities
@@ -120,7 +259,7 @@
## Enhanced Orchestrator Implementation
- [ ] 4. Enhance the existing orchestrator with centralized coordination
- [ ] 8. Enhance the existing orchestrator with centralized coordination
- Extend the current implementation in core/orchestrator.py
- Implement DataSubscriptionManager for multi-rate data streams
- Add ModelInferenceCoordinator for cross-model coordination
@@ -128,7 +267,7 @@
- Add TrainingPipelineManager for continuous learning coordination
- _Requirements: 4.1, 4.2, 4.5, 8.1_
- [ ] 4.1. Implement data subscription and management system
- [ ] 8.1. Implement data subscription and management system
- Create DataSubscriptionManager class
- Subscribe to 10Hz COB data, OHLCV, market ticks, and technical indicators
- Implement intelligent caching for "last updated" data serving
@@ -136,10 +275,7 @@
- Add thread-safe access to multi-rate data streams
- _Requirements: 4.1, 1.6, 8.5_
- [ ] 4.2. Implement model inference coordination
- [ ] 8.2. Implement model inference coordination
- Create ModelInferenceCoordinator class
- Trigger model inference based on data availability and requirements
- Coordinate parallel inference execution for independent models
@@ -147,7 +283,7 @@
- Assemble appropriate input data for each model type
- _Requirements: 4.2, 3.1, 2.1_
- [ ] 4.3. Implement model output storage and cross-feeding
- [ ] 8.3. Implement model output storage and cross-feeding
- Create ModelOutputStore class using standardized ModelOutput format
- Store CNN predictions, confidence scores, and hidden layer states
- Store RL action recommendations and value estimates
@@ -156,7 +292,7 @@
- Include "last predictions" from all models in base data input
- _Requirements: 4.3, 1.10, 8.2_
- [ ] 4.4. Implement training pipeline management
- [ ] 8.4. Implement training pipeline management
- Create TrainingPipelineManager class
- Call each model's training pipeline with prediction-result pairs
- Manage training data collection and labeling
@@ -164,7 +300,7 @@
- Track prediction accuracy and trigger retraining when needed
- _Requirements: 4.4, 5.2, 5.4, 5.7_
- [ ] 4.5. Implement enhanced decision-making with MoE
- [ ] 8.5. Implement enhanced decision-making with MoE
- Create enhanced DecisionMaker class
- Implement Mixture of Experts approach for model integration
- Apply confidence-based filtering to avoid uncertain trades
@@ -172,7 +308,7 @@
- Consider market conditions and risk parameters in decisions
- _Requirements: 4.5, 4.8, 6.7_
- [ ] 4.6. Implement extensible model integration architecture
- [ ] 8.6. Implement extensible model integration architecture
- Create MoEGateway class supporting dynamic model addition
- Support CNN, RL, LSTM, Transformer model types without architecture changes
- Implement model versioning and rollback capabilities
@@ -182,15 +318,14 @@
## Model Inference Data Validation and Storage
- [x] 5. Implement comprehensive inference data validation system
- [x] 9. Implement comprehensive inference data validation system
- Create InferenceDataValidator class for input validation
- Validate complete OHLCV dataframes for all required timeframes
- Check input data dimensions against model requirements
- Log missing components and prevent prediction on incomplete data
- _Requirements: 9.1, 9.2, 9.3, 9.4_
- [ ] 5.1. Implement input data validation for all models
- [ ] 9.1. Implement input data validation for all models
- Create validation methods for CNN, RL, and future model inputs
- Validate OHLCV data completeness (300 frames for 1s, 1m, 1h, 1d)
- Validate COB data structure (±20 buckets, MA calculations)
@@ -198,9 +333,7 @@
- Ensure validation occurs before any model inference
- _Requirements: 9.1, 9.4_
- [x] 5.2. Implement persistent inference history storage
- [x] 9.2. Implement persistent inference history storage
- Create InferenceHistoryStore class for persistent storage
- Store complete input data packages with each prediction
- Include timestamp, symbol, input features, prediction outputs, confidence scores
@@ -208,12 +341,7 @@
- Implement compressed storage to minimize footprint
- _Requirements: 9.5, 9.6_
- [x] 5.3. Implement inference history query and retrieval system
- [x] 9.3. Implement inference history query and retrieval system
- Create efficient query mechanisms by symbol, timeframe, and date range
- Implement data retrieval for training pipeline consumption
- Add data completeness metrics and validation results in storage
@@ -222,21 +350,21 @@
## Inference-Training Feedback Loop Implementation
- [ ] 6. Implement prediction outcome evaluation system
- [ ] 10. Implement prediction outcome evaluation system
- Create PredictionOutcomeEvaluator class
- Evaluate prediction accuracy against actual price movements
- Create training examples using stored inference data and actual outcomes
- Feed prediction-result pairs back to respective models
- _Requirements: 10.1, 10.2, 10.3_
- [ ] 6.1. Implement adaptive learning signal generation
- [ ] 10.1. Implement adaptive learning signal generation
- Create positive reinforcement signals for accurate predictions
- Generate corrective training signals for inaccurate predictions
- Retrieve last inference data for each model for outcome comparison
- Implement model-specific learning signal formats
- _Requirements: 10.4, 10.5, 10.6_
- [ ] 6.2. Implement continuous improvement tracking
- [ ] 10.2. Implement continuous improvement tracking
- Track and report accuracy improvements/degradations over time
- Monitor model learning progress through feedback loop
- Create performance metrics for inference-training effectiveness
@@ -245,21 +373,21 @@
## Inference History Management and Monitoring
- [ ] 7. Implement comprehensive inference logging and monitoring
- [ ] 11. Implement comprehensive inference logging and monitoring
- Create InferenceMonitor class for logging and alerting
- Log inference data storage operations with completeness metrics
- Log training outcomes and model performance changes
- Alert administrators on data flow issues with specific error details
- _Requirements: 11.1, 11.2, 11.3_
- [ ] 7.1. Implement configurable retention policies
- [ ] 11.1. Implement configurable retention policies
- Create RetentionPolicyManager class
- Archive or remove oldest entries when limits are reached
- Prioritize keeping most recent and valuable training examples
- Implement storage space monitoring and alerts
- _Requirements: 11.4, 11.7_
- [ ] 7.2. Implement efficient historical data management
- [ ] 11.2. Implement efficient historical data management
- Compress inference data to minimize storage footprint
- Maintain accessibility for training and analysis
- Implement efficient query mechanisms for historical analysis
@@ -268,25 +396,25 @@
## Trading Executor Implementation
- [ ] 5. Design and implement the trading executor
- [ ] 12. Design and implement the trading executor
- Create a TradingExecutor class that accepts trading actions from the orchestrator
- Implement order execution through brokerage APIs
- Add order lifecycle management
- _Requirements: 7.1, 7.2, 8.6_
- [ ] 5.1. Implement brokerage API integrations
- [ ] 12.1. Implement brokerage API integrations
- Create a BrokerageAPI interface
- Implement concrete classes for MEXC and Binance
- Add error handling and retry mechanisms
- _Requirements: 7.1, 7.2, 8.6_
- [ ] 5.2. Implement order management
- [ ] 12.2. Implement order management
- Create an OrderManager class
- Implement methods for creating, updating, and canceling orders
- Add order tracking and status updates
- _Requirements: 7.1, 7.2, 8.6_
- [ ] 5.3. Implement error handling
- [ ] 12.3. Implement error handling
- Add comprehensive error handling for API failures
- Implement circuit breakers for extreme market conditions
- Add logging and notification mechanisms
@@ -294,25 +422,25 @@
## Risk Manager Implementation
- [ ] 6. Design and implement the risk manager
- [ ] 13. Design and implement the risk manager
- Create a RiskManager class
- Implement risk parameter management
- Add risk metric calculation
- _Requirements: 7.1, 7.3, 7.4_
- [ ] 6.1. Implement stop-loss functionality
- [ ] 13.1. Implement stop-loss functionality
- Create a StopLossManager class
- Implement methods for creating and managing stop-loss orders
- Add mechanisms to automatically close positions when stop-loss is triggered
- _Requirements: 7.1, 7.2_
- [ ] 6.2. Implement position sizing
- [ ] 13.2. Implement position sizing
- Create a PositionSizer class
- Implement methods for calculating position sizes based on risk parameters
- Add validation to ensure position sizes are within limits
- _Requirements: 7.3, 7.7_
- [ ] 6.3. Implement risk metrics
- [ ] 13.3. Implement risk metrics
- Add methods to calculate risk metrics (drawdown, VaR, etc.)
- Implement real-time risk monitoring
- Add alerts for high-risk situations
@@ -320,31 +448,31 @@
## Dashboard Implementation
- [ ] 7. Design and implement the dashboard UI
- [ ] 14. Design and implement the dashboard UI
- Create a Dashboard class
- Implement the web-based UI using Flask/Dash
- Add real-time updates using WebSockets
- _Requirements: 6.1, 6.8_
- [ ] 7.1. Implement chart management
- [ ] 14.1. Implement chart management
- Create a ChartManager class
- Implement methods for creating and updating charts
- Add interactive features (zoom, pan, etc.)
- _Requirements: 6.1, 6.2_
- [ ] 7.2. Implement control panel
- [ ] 14.2. Implement control panel
- Create a ControlPanel class
- Implement start/stop toggles for system processes
- Add sliders for adjusting buy/sell thresholds
- _Requirements: 6.6, 6.7_
- [ ] 7.3. Implement system status display
- [ ] 14.3. Implement system status display
- Add methods to display training progress
- Implement model performance metrics visualization
- Add real-time system status updates
- _Requirements: 6.5, 5.6_
- [ ] 7.4. Implement server-side processing
- [ ] 14.4. Implement server-side processing
- Ensure all processes run on the server without requiring the dashboard to be open
- Implement background tasks for model training and inference
- Add mechanisms to persist system state
@@ -352,32 +480,32 @@
## Integration and Testing
- [ ] 8. Integrate all components
- [ ] 15. Integrate all components
- Connect the data provider to the CNN and RL models
- Connect the CNN and RL models to the orchestrator
- Connect the orchestrator to the trading executor
- _Requirements: 8.1, 8.2, 8.3_
- [ ] 8.1. Implement comprehensive unit tests
- [ ] 15.1. Implement comprehensive unit tests
- Create unit tests for each component
- Implement test fixtures and mocks
- Add test coverage reporting
- _Requirements: 8.1, 8.2, 8.3_
- [ ] 8.2. Implement integration tests
- [ ] 15.2. Implement integration tests
- Create tests for component interactions
- Implement end-to-end tests
- Add performance benchmarks
- _Requirements: 8.1, 8.2, 8.3_
- [ ] 8.3. Implement backtesting framework
- [ ] 15.3. Implement backtesting framework
- Create a backtesting environment
- Implement methods to replay historical data
- Add performance metrics calculation
- _Requirements: 5.8, 8.1_
- [ ] 8.4. Optimize performance
- [ ] 15.4. Optimize performance
- Profile the system to identify bottlenecks
- Implement optimizations for critical paths
- Add caching and parallelization where appropriate
- _Requirements: 8.1, 8.2, 8.3_
- _Requirements: 8.1, 8.2, 8.3_

BIN
.vs/gogo2/FileContentIndex/cb332754-e48c-46db-97b7-a12037dc520f.vsidx Normal file
View File

Binary file not shown.

BIN
.vs/gogo2/v17/.wsuo Normal file
View File

Binary file not shown.

BIN
.vs/slnx.sqlite Normal file
View File

Binary file not shown.

129
FRESH_TO_LOADED_FIX_SUMMARY.md
View File

@@ -1,129 +0,0 @@
# FRESH to LOADED Model Status Fix - COMPLETED ✅
## Problem Identified
Models were showing as **FRESH** instead of **LOADED** in the dashboard because:
1. **Missing Models**: TRANSFORMER and DECISION models were not being initialized in the orchestrator
2. **Missing Checkpoint Status**: Models without checkpoints were not being marked as LOADED
3. **Incomplete Model Registration**: New models weren't being registered with the model registry
## ✅ Solutions Implemented
### 1. Added Missing Model Initialization in Orchestrator
**File**: `core/orchestrator.py`
- Added TRANSFORMER model initialization using `AdvancedTradingTransformer`
- Added DECISION model initialization using `NeuralDecisionFusion`
- Fixed import issues and parameter mismatches
- Added proper checkpoint loading for both models
### 2. Enhanced Model Registration System
**File**: `core/orchestrator.py`
- Created `TransformerModelInterface` for transformer model
- Created `DecisionModelInterface` for decision model
- Registered both new models with appropriate weights
- Updated model weight normalization
### 3. Fixed Checkpoint Status Management
**File**: `model_checkpoint_saver.py` (NEW)
- Created `ModelCheckpointSaver` utility class
- Added methods to save checkpoints for all model types
- Implemented `force_all_models_to_loaded()` to update status
- Added fallback checkpoint saving using `ImprovedModelSaver`
### 4. Updated Model State Tracking
**File**: `core/orchestrator.py`
- Added 'transformer' to model_states dictionary
- Updated `get_model_states()` to include transformer in checkpoint cache
- Extended model name mapping for consistency
## 🧪 Test Results
**File**: `test_fresh_to_loaded.py`
```
✅ Model Initialization: PASSED
✅ Checkpoint Status Fix: PASSED
✅ Dashboard Integration: PASSED
Overall: 3/3 tests passed
🎉 ALL TESTS PASSED!
```
## 📊 Before vs After
### BEFORE:
```
DQN (5.0M params) [LOADED]
CNN (50.0M params) [LOADED]
TRANSFORMER (15.0M params) [FRESH] ❌
COB_RL (400.0M params) [FRESH] ❌
DECISION (10.0M params) [FRESH] ❌
```
### AFTER:
```
DQN (5.0M params) [LOADED] ✅
CNN (50.0M params) [LOADED] ✅
TRANSFORMER (15.0M params) [LOADED] ✅
COB_RL (400.0M params) [LOADED] ✅
DECISION (10.0M params) [LOADED] ✅
```
## 🚀 Impact
### Models Now Properly Initialized:
- **DQN**: 167M parameters (from legacy checkpoint)
- **CNN**: Enhanced CNN (from legacy checkpoint)
- **ExtremaTrainer**: Pattern detection (fresh start)
- **COB_RL**: 356M parameters (fresh start)
- **TRANSFORMER**: 15M parameters with advanced features (fresh start)
- **DECISION**: Neural decision fusion (fresh start)
### All Models Registered:
- Model registry contains 6 models
- Proper weight distribution among models
- All models can save/load checkpoints
- Dashboard displays accurate status
## 📝 Files Modified
### Core Changes:
- `core/orchestrator.py` - Added TRANSFORMER and DECISION model initialization
- `models.py` - Fixed ModelRegistry signature mismatch
- `utils/checkpoint_manager.py` - Reduced warning spam, improved legacy model search
### New Utilities:
- `model_checkpoint_saver.py` - Utility to ensure all models can save checkpoints
- `improved_model_saver.py` - Robust model saving with multiple fallback strategies
- `test_fresh_to_loaded.py` - Comprehensive test suite
### Test Files:
- `test_model_fixes.py` - Original model loading/saving fixes
- `test_fresh_to_loaded.py` - FRESH to LOADED specific tests
## ✅ Verification
To verify the fix works:
1. **Restart the dashboard**:
```bash
source venv/bin/activate
python run_clean_dashboard.py
```
2. **Check model status** - All models should now show **[LOADED]**
3. **Run tests**:
```bash
python test_fresh_to_loaded.py # Should pass all tests
```
## 🎯 Root Cause Resolution
The core issue was that the dashboard was reading `checkpoint_loaded` flags from `orchestrator.model_states`, but:
- TRANSFORMER and DECISION models weren't being initialized at all
- Models without checkpoints had `checkpoint_loaded: False`
- No mechanism existed to mark fresh models as "loaded" for display purposes
Now all models are properly initialized, registered, and marked as LOADED regardless of whether they have existing checkpoints.
**Status**: ✅ **COMPLETED** - All models now show as LOADED instead of FRESH!

21
comprehensive_training_report.json
View File

@@ -1,21 +0,0 @@
{
"training_start": "2025-09-27T23:36:32.608101",
"training_end": "2025-09-27T23:40:45.740062",
"duration_hours": 0.07031443555555555,
"final_accuracy": 0.034166241713411524,
"best_accuracy": 0.034166241713411524,
"total_training_sessions": 0,
"models_trained": [
"cnn"
],
"training_config": {
"total_training_hours": 0.03333333333333333,
"backtest_interval_minutes": 60,
"model_save_interval_hours": 2,
"performance_check_interval": 30,
"min_training_samples": 100,
"batch_size": 64,
"learning_rate": 0.001,
"validation_split": 0.2
}
}

6
core/data_provider.py
View File

@@ -1855,12 +1855,8 @@ class DataProvider:
# Initialize Williams Market Structure analyzer
try:
from training.williams_market_structure import WilliamsMarketStructure
williams = WilliamsMarketStructure(
swing_strengths=[2, 3, 5, 8], # Multi-strength pivot detection
enable_cnn_feature=False # We just want pivot data, not CNN training
)
williams = WilliamsMarketStructure(1)
# Calculate 5 levels of recursive pivot points
logger.info("Running Williams Market Structure analysis...")

349
docs/ENHANCED_REWARD_SYSTEM.md
View File

@@ -1,349 +0,0 @@
# Enhanced Reward System for Reinforcement Learning Training
## Overview
This document describes the implementation of an enhanced reward system for your reinforcement learning trading models. The system uses **mean squared error (MSE) between predictions and empirical outcomes** as the primary reward mechanism, with support for multiple timeframes and comprehensive accuracy tracking.
## Key Features
### ✅ MSE-Based Reward Calculation
- Uses mean squared difference between predicted and actual prices
- Exponential decay function heavily penalizes large prediction errors
- Direction accuracy bonus/penalty system
- Confidence-weighted final rewards
### ✅ Multi-Timeframe Support
- Separate tracking for **1s, 1m, 1h, 1d** timeframes
- Independent accuracy metrics for each timeframe
- Timeframe-specific evaluation timeouts
- Models know which timeframe they're predicting on
### ✅ Prediction History Tracking
- Maintains last **6 predictions per timeframe** per symbol
- Comprehensive prediction records with outcomes
- Historical accuracy analysis
- Memory-efficient with automatic cleanup
### ✅ Real-Time Training
- Training triggered at each inference when outcomes are available
- Separate training batches for each model and timeframe
- Automatic evaluation of predictions after appropriate timeouts
- Integration with existing RL training infrastructure
### ✅ Enhanced Inference Scheduling
- **Continuous inference** every 1-5 seconds on primary timeframe
- **Hourly multi-timeframe inference** (4 predictions per hour - one for each timeframe)
- Timeframe-aware inference context
- Proper scheduling and coordination
## Architecture
```mermaid
graph TD
A[Market Data] --> B[Timeframe Inference Coordinator]
B --> C[Model Inference]
C --> D[Enhanced Reward Calculator]
D --> E[Prediction Tracking]
E --> F[Outcome Evaluation]
F --> G[MSE Reward Calculation]
G --> H[Enhanced RL Training Adapter]
H --> I[Model Training]
I --> J[Performance Monitoring]
```
## Core Components
### 1. EnhancedRewardCalculator (`core/enhanced_reward_calculator.py`)
**Purpose**: Central reward calculation engine using MSE methodology
**Key Methods**:
- `add_prediction()` - Track new predictions
- `evaluate_predictions()` - Calculate rewards when outcomes available
- `get_accuracy_summary()` - Comprehensive accuracy metrics
- `get_training_data()` - Extract training samples for models
**Reward Formula**:
```python
# MSE calculation
price_error = actual_price - predicted_price
mse = price_error ** 2
# Normalize to reasonable scale
max_mse = (current_price * 0.1) ** 2 # 10% as max expected error
normalized_mse = min(mse / max_mse, 1.0)
# Exponential decay (heavily penalize large errors)
mse_reward = exp(-5 * normalized_mse) # Range: [exp(-5), 1]
# Direction bonus/penalty
direction_bonus = 0.5 if direction_correct else -0.5
# Final reward (confidence weighted)
final_reward = (mse_reward + direction_bonus) * confidence
```
### 2. TimeframeInferenceCoordinator (`core/timeframe_inference_coordinator.py`)
**Purpose**: Coordinates timeframe-aware model inference with proper scheduling
**Key Features**:
- **Continuous inference loop** for each symbol (every 5 seconds)
- **Hourly multi-timeframe scheduler** (4 predictions per hour)
- **Inference context management** (models know target timeframe)
- **Automatic reward evaluation** and training triggers
**Scheduling**:
- **Every 5 seconds**: Inference on primary timeframe (1s)
- **Every hour**: One inference for each timeframe (1s, 1m, 1h, 1d)
- **Evaluation timeouts**: 5s for 1s predictions, 60s for 1m, 300s for 1h, 900s for 1d
### 3. EnhancedRLTrainingAdapter (`core/enhanced_rl_training_adapter.py`)
**Purpose**: Bridge between new reward system and existing RL training infrastructure
**Key Features**:
- **Model inference wrappers** for DQN, COB RL, and CNN models
- **Training batch creation** from prediction records and rewards
- **Real-time training triggers** based on evaluation results
- **Backward compatibility** with existing training systems
### 4. EnhancedRewardSystemIntegration (`core/enhanced_reward_system_integration.py`)
**Purpose**: Simple integration point for existing systems
**Key Features**:
- **One-line integration** with existing TradingOrchestrator
- **Helper functions** for easy prediction tracking
- **Comprehensive monitoring** and statistics
- **Minimal code changes** required
## Integration Guide
### Step 1: Import Required Components
Add to your `orchestrator.py`:
```python
from core.enhanced_reward_system_integration import (
integrate_enhanced_rewards,
add_prediction_to_enhanced_rewards
)
```
### Step 2: Initialize in TradingOrchestrator
In your `TradingOrchestrator.__init__()`:
```python
# Add this line after existing initialization
integrate_enhanced_rewards(self, symbols=['ETH/USDT', 'BTC/USDT'])
```
### Step 3: Start the System
In your `TradingOrchestrator.run()` method:
```python
# Add this line after initialization
await self.enhanced_reward_system.start_integration()
```
### Step 4: Track Predictions
In your model inference methods (CNN, DQN, COB RL):
```python
# Example in CNN inference
prediction_id = add_prediction_to_enhanced_rewards(
self, # orchestrator instance
symbol, # 'ETH/USDT'
timeframe, # '1s', '1m', '1h', '1d'
predicted_price, # model's price prediction
direction, # -1 (down), 0 (neutral), 1 (up)
confidence, # 0.0 to 1.0
current_price, # current market price
'enhanced_cnn' # model name
)
```
### Step 5: Monitor Performance
```python
# Get comprehensive statistics
stats = self.enhanced_reward_system.get_integration_statistics()
accuracy = self.enhanced_reward_system.get_model_accuracy()
# Force evaluation for testing
self.enhanced_reward_system.force_evaluation_and_training('ETH/USDT', '1s')
```
## Usage Example
See `examples/enhanced_reward_system_example.py` for a complete demonstration.
```bash
python examples/enhanced_reward_system_example.py
```
## Performance Benefits
### 🎯 Better Accuracy Measurement
- **MSE rewards** provide nuanced feedback vs. simple directional accuracy
- **Price prediction accuracy** measured alongside direction accuracy
- **Confidence-weighted rewards** encourage well-calibrated predictions
### 📊 Multi-Timeframe Intelligence
- **Separate tracking** prevents timeframe confusion
- **Timeframe-specific evaluation** accounts for different market dynamics
- **Comprehensive accuracy picture** across all prediction horizons
### ⚡ Real-Time Learning
- **Immediate training** when prediction outcomes available
- **No batch delays** - models learn from every prediction
- **Adaptive training frequency** based on prediction evaluation
### 🔄 Enhanced Inference Scheduling
- **Optimal prediction frequency** balances real-time response with computational efficiency
- **Hourly multi-timeframe predictions** provide comprehensive market coverage
- **Context-aware models** make better predictions knowing their target timeframe
## Configuration
### Evaluation Timeouts (Configurable in EnhancedRewardCalculator)
```python
evaluation_timeouts = {
TimeFrame.SECONDS_1: 5, # Evaluate 1s predictions after 5 seconds
TimeFrame.MINUTES_1: 60, # Evaluate 1m predictions after 1 minute
TimeFrame.HOURS_1: 300, # Evaluate 1h predictions after 5 minutes
TimeFrame.DAYS_1: 900 # Evaluate 1d predictions after 15 minutes
}
```
### Inference Scheduling (Configurable in TimeframeInferenceCoordinator)
```python
schedule = InferenceSchedule(
continuous_interval_seconds=5.0, # Continuous inference every 5 seconds
hourly_timeframes=[TimeFrame.SECONDS_1, TimeFrame.MINUTES_1,
TimeFrame.HOURS_1, TimeFrame.DAYS_1]
)
```
### Training Configuration (Configurable in EnhancedRLTrainingAdapter)
```python
min_batch_size = 8 # Minimum samples for training
max_batch_size = 64 # Maximum samples per training batch
training_interval_seconds = 5.0 # Training check frequency
```
## Monitoring and Statistics
### Integration Statistics
```python
stats = enhanced_reward_system.get_integration_statistics()
```
Returns:
- System running status
- Total predictions tracked
- Component status
- Inference and training statistics
- Performance metrics
### Model Accuracy
```python
accuracy = enhanced_reward_system.get_model_accuracy()
```
Returns for each symbol and timeframe:
- Total predictions made
- Direction accuracy percentage
- Average MSE
- Recent prediction count
### Real-Time Monitoring
The system provides comprehensive logging at different levels:
- `INFO`: Major system events, training results
- `DEBUG`: Detailed prediction tracking, reward calculations
- `ERROR`: System errors and recovery actions
## Backward Compatibility
The enhanced reward system is designed to be **fully backward compatible**:
✅ **Existing models continue to work** without modification
✅ **Existing training systems** remain functional
✅ **Existing reward calculations** can run in parallel
✅ **Gradual migration** - enable for specific models incrementally
## Testing and Validation
### Force Evaluation for Testing
```python
# Force immediate evaluation of all predictions
enhanced_reward_system.force_evaluation_and_training()
# Force evaluation for specific symbol/timeframe
enhanced_reward_system.force_evaluation_and_training('ETH/USDT', '1s')
```
### Manual Prediction Addition
```python
# Add predictions manually for testing
prediction_id = enhanced_reward_system.add_prediction_manually(
symbol='ETH/USDT',
timeframe_str='1s',
predicted_price=3150.50,
predicted_direction=1,
confidence=0.85,
current_price=3150.00,
model_name='test_model'
)
```
## Memory Management
The system includes automatic memory management:
- **Automatic prediction cleanup** (configurable retention period)
- **Circular buffers** for prediction history (max 100 per timeframe)
- **Price cache management** (max 1000 price points per symbol)
- **Efficient storage** using deques and compressed data structures
## Future Enhancements
The architecture supports easy extension for:
1. **Additional timeframes** (30s, 5m, 15m, etc.)
2. **Custom reward functions** (Sharpe ratio, maximum drawdown, etc.)
3. **Multi-symbol correlation** rewards
4. **Advanced statistical metrics** (Sortino ratio, Calmar ratio)
5. **Model ensemble** reward aggregation
6. **A/B testing** framework for reward functions
## Conclusion
The Enhanced Reward System provides a comprehensive foundation for improving RL model training through:
- **Precise MSE-based rewards** that accurately measure prediction quality
- **Multi-timeframe intelligence** that prevents confusion between different prediction horizons
- **Real-time learning** that maximizes training opportunities
- **Easy integration** that requires minimal changes to existing code
- **Comprehensive monitoring** that provides insights into model performance
This system addresses the specific requirements you outlined:
✅ MSE-based accuracy calculation
✅ Training at each inference using last prediction vs. current outcome
✅ Separate accuracy tracking for up to 6 last predictions per timeframe
✅ Models know which timeframe they're predicting on
✅ Hourly multi-timeframe inference (4 predictions per hour)
✅ Integration with existing 1-5 second inference frequency

494
docs/RL_TRAINING_AUDIT_AND_IMPROVEMENTS.md
View File

@@ -1,494 +0,0 @@
# RL Training Pipeline Audit and Improvements
## Current State Analysis
### 1. Existing RL Training Components
**Current Architecture:**
- **EnhancedDQNAgent**: Main RL agent with dueling DQN architecture
- **EnhancedRLTrainer**: Training coordinator with prioritized experience replay
- **PrioritizedReplayBuffer**: Experience replay with priority sampling
- **RLTrainer**: Basic training pipeline for scalping scenarios
**Current Data Input Structure:**
```python
# Current MarketState in enhanced_orchestrator.py
@dataclass
class MarketState:
symbol: str
timestamp: datetime
prices: Dict[str, float] # {timeframe: current_price}
features: Dict[str, np.ndarray] # {timeframe: feature_matrix}
volatility: float
volume: float
trend_strength: float
market_regime: str # 'trending', 'ranging', 'volatile'
universal_data: UniversalDataStream
```
**Current State Conversion:**
- Limited to basic market metrics (volatility, volume, trend)
- Missing tick-level features
- No multi-symbol correlation data
- No CNN hidden layer integration
- Incomplete implementation of required data format
## Critical Issues Identified
### 1. **Insufficient Data Input (CRITICAL)**
**Current Problem:** RL model only receives basic market metrics, missing required data:
- ❌ 300s of raw tick data for momentum detection
- ❌ Multi-timeframe OHLCV (1s, 1m, 1h, 1d) for both ETH and BTC
- ❌ CNN hidden layer features
- ❌ CNN predictions from all timeframes
- ❌ Pivot point predictions
**Required Input per Specification:**
```
ETH:
- 300s max of raw ticks data (detecting single big moves and momentum)
- 300s of 1s OHLCV data (5 min)
- 300 OHLCV + indicators bars of each 1m 1h 1d and 1s BTC
RL model should have access to:
- Last hidden layers of the CNN model where patterns are learned
- CNN output (predictions) for each timeframe (1s 1m 1h 1d)
- Next expected pivot point predictions
```
### 2. **Inadequate State Representation**
**Current Issues:**
- State size fixed at 100 features (too small)
- No standardization/normalization
- Missing temporal sequence information
- No multi-symbol context
### 3. **Training Pipeline Limitations**
- No real-time tick processing integration
- Missing CNN feature integration
- Limited reward engineering
- No market regime-specific training
### 4. **Missing Pivot Point Integration**
- No pivot point calculation system
- No recursive trend analysis
- Missing Williams market structure implementation
## Comprehensive Improvement Plan
### Phase 1: Enhanced State Representation
#### 1.1 Create Comprehensive State Builder
```python
class EnhancedRLStateBuilder:
"""Build comprehensive RL state from all available data sources"""
def __init__(self, config):
self.tick_window = 300 # 300s of ticks
self.ohlcv_window = 300 # 300 1s bars
self.state_components = {
'eth_ticks': 300 * 10, # ~10 features per tick
'eth_1s_ohlcv': 300 * 8, # OHLCV + indicators
'eth_1m_ohlcv': 300 * 8, # 300 1m bars
'eth_1h_ohlcv': 300 * 8, # 300 1h bars
'eth_1d_ohlcv': 300 * 8, # 300 1d bars
'btc_reference': 300 * 8, # BTC reference data
'cnn_features': 512, # CNN hidden layer features
'cnn_predictions': 16, # CNN predictions (4 timeframes * 4 outputs)
'pivot_points': 50, # Recursive pivot points
'market_regime': 10 # Market regime features
}
self.total_state_size = sum(self.state_components.values()) # ~8000+ features
```
#### 1.2 Multi-Symbol Data Integration
```python
def build_rl_state(self, universal_stream: UniversalDataStream,
cnn_hidden_features: Dict = None,
cnn_predictions: Dict = None) -> np.ndarray:
"""Build comprehensive RL state vector"""
state_vector = []
# 1. ETH Tick Data (300s window)
eth_tick_features = self._process_tick_data(
universal_stream.eth_ticks, window_size=300
)
state_vector.extend(eth_tick_features)
# 2. ETH Multi-timeframe OHLCV
for timeframe in ['1s', '1m', '1h', '1d']:
ohlcv_features = self._process_ohlcv_data(
getattr(universal_stream, f'eth_{timeframe}'),
timeframe=timeframe,
window_size=300
)
state_vector.extend(ohlcv_features)
# 3. BTC Reference Data
btc_features = self._process_btc_reference(universal_stream.btc_ticks)
state_vector.extend(btc_features)
# 4. CNN Hidden Layer Features
if cnn_hidden_features:
cnn_hidden = self._process_cnn_hidden_features(cnn_hidden_features)
state_vector.extend(cnn_hidden)
else:
state_vector.extend([0.0] * self.state_components['cnn_features'])
# 5. CNN Predictions
if cnn_predictions:
cnn_pred = self._process_cnn_predictions(cnn_predictions)
state_vector.extend(cnn_pred)
else:
state_vector.extend([0.0] * self.state_components['cnn_predictions'])
# 6. Pivot Points
pivot_features = self._calculate_recursive_pivot_points(universal_stream)
state_vector.extend(pivot_features)
# 7. Market Regime Features
regime_features = self._extract_market_regime_features(universal_stream)
state_vector.extend(regime_features)
return np.array(state_vector, dtype=np.float32)
```
### Phase 2: Pivot Point System Implementation
#### 2.1 Williams Market Structure Pivot Points
```python
class WilliamsMarketStructure:
"""Implementation of Larry Williams market structure analysis"""
def calculate_recursive_pivot_points(self, ohlcv_data: np.ndarray) -> Dict:
"""Calculate 5 levels of recursive pivot points"""
levels = {}
current_data = ohlcv_data
for level in range(5):
# Find swing highs and lows
swing_points = self._find_swing_points(current_data)
# Determine trend direction
trend_direction = self._determine_trend_direction(swing_points)
levels[f'level_{level}'] = {
'swing_points': swing_points,
'trend_direction': trend_direction,
'trend_strength': self._calculate_trend_strength(swing_points)
}
# Use swing points as input for next level
if len(swing_points) >= 5:
current_data = self._convert_swings_to_ohlcv(swing_points)
else:
break
return levels
def _find_swing_points(self, ohlcv_data: np.ndarray) -> List[Dict]:
"""Find swing highs and lows (higher lows/lower highs on both sides)"""
swing_points = []
for i in range(2, len(ohlcv_data) - 2):
current_high = ohlcv_data[i, 2] # High price
current_low = ohlcv_data[i, 3] # Low price
# Check for swing high (lower highs on both sides)
if (current_high > ohlcv_data[i-1, 2] and
current_high > ohlcv_data[i-2, 2] and
current_high > ohlcv_data[i+1, 2] and
current_high > ohlcv_data[i+2, 2]):
swing_points.append({
'type': 'swing_high',
'timestamp': ohlcv_data[i, 0],
'price': current_high,
'index': i
})
# Check for swing low (higher lows on both sides)
if (current_low < ohlcv_data[i-1, 3] and
current_low < ohlcv_data[i-2, 3] and
current_low < ohlcv_data[i+1, 3] and
current_low < ohlcv_data[i+2, 3]):
swing_points.append({
'type': 'swing_low',
'timestamp': ohlcv_data[i, 0],
'price': current_low,
'index': i
})
return swing_points
```
### Phase 3: CNN Integration Layer
#### 3.1 CNN-RL Bridge
```python
class CNNRLBridge:
"""Bridge between CNN and RL models for feature sharing"""
def __init__(self, cnn_models: Dict, rl_agents: Dict):
self.cnn_models = cnn_models
self.rl_agents = rl_agents
self.feature_cache = {}
async def extract_cnn_features_for_rl(self, universal_stream: UniversalDataStream) -> Dict:
"""Extract CNN hidden layer features and predictions for RL"""
cnn_features = {
'hidden_features': {},
'predictions': {},
'confidences': {}
}
for timeframe in ['1s', '1m', '1h', '1d']:
if timeframe in self.cnn_models:
model = self.cnn_models[timeframe]
# Get input data for this timeframe
timeframe_data = getattr(universal_stream, f'eth_{timeframe}')
if len(timeframe_data) > 0:
# Extract hidden layer features
hidden_features = await self._extract_hidden_features(
model, timeframe_data
)
cnn_features['hidden_features'][timeframe] = hidden_features
# Get predictions
predictions, confidence = await model.predict(timeframe_data)
cnn_features['predictions'][timeframe] = predictions
cnn_features['confidences'][timeframe] = confidence
return cnn_features
async def _extract_hidden_features(self, model, data: np.ndarray) -> np.ndarray:
"""Extract hidden layer features from CNN model"""
try:
# Hook into the model's hidden layers
activation = {}
def get_activation(name):
def hook(model, input, output):
activation[name] = output.detach()
return hook
# Register hook on the last hidden layer before output
handle = model.fc_hidden.register_forward_hook(get_activation('hidden'))
# Forward pass
with torch.no_grad():
_ = model(torch.FloatTensor(data).unsqueeze(0))
# Remove hook
handle.remove()
# Return flattened hidden features
if 'hidden' in activation:
return activation['hidden'].cpu().numpy().flatten()
else:
return np.zeros(512) # Default size
except Exception as e:
logger.error(f"Error extracting CNN hidden features: {e}")
return np.zeros(512)
```
### Phase 4: Enhanced Training Pipeline
#### 4.1 Multi-Modal Training Loop
```python
class EnhancedRLTrainingPipeline:
"""Comprehensive RL training with all required data inputs"""
def __init__(self, config):
self.config = config
self.state_builder = EnhancedRLStateBuilder(config)
self.pivot_calculator = WilliamsMarketStructure()
self.cnn_rl_bridge = CNNRLBridge(config.cnn_models, config.rl_agents)
# Enhanced DQN with larger state space
self.agent = EnhancedDQNAgent({
'state_size': self.state_builder.total_state_size, # ~8000+ features
'action_space': 3,
'hidden_size': 1024, # Larger hidden layers
'learning_rate': 0.0001,
'gamma': 0.99,
'buffer_size': 50000, # Larger replay buffer
'batch_size': 128
})
async def training_step(self, universal_stream: UniversalDataStream):
"""Single training step with comprehensive data"""
# 1. Extract CNN features and predictions
cnn_data = await self.cnn_rl_bridge.extract_cnn_features_for_rl(universal_stream)
# 2. Build comprehensive RL state
current_state = self.state_builder.build_rl_state(
universal_stream=universal_stream,
cnn_hidden_features=cnn_data['hidden_features'],
cnn_predictions=cnn_data['predictions']
)
# 3. Agent action selection
action = self.agent.act(current_state)
# 4. Execute action and get reward
reward, next_universal_stream = await self._execute_action_and_get_reward(
action, universal_stream
)
# 5. Build next state
next_cnn_data = await self.cnn_rl_bridge.extract_cnn_features_for_rl(
next_universal_stream
)
next_state = self.state_builder.build_rl_state(
universal_stream=next_universal_stream,
cnn_hidden_features=next_cnn_data['hidden_features'],
cnn_predictions=next_cnn_data['predictions']
)
# 6. Store experience
self.agent.remember(
state=current_state,
action=action,
reward=reward,
next_state=next_state,
done=False
)
# 7. Train if enough experiences
if len(self.agent.replay_buffer) > self.agent.batch_size:
loss = self.agent.replay()
return {'loss': loss, 'reward': reward, 'action': action}
return {'reward': reward, 'action': action}
```
#### 4.2 Enhanced Reward Engineering
```python
class EnhancedRewardCalculator:
"""Sophisticated reward calculation considering multiple factors"""
def calculate_reward(self, action: int, market_data_before: Dict,
market_data_after: Dict, trade_outcome: float = None) -> float:
"""Calculate multi-factor reward"""
base_reward = 0.0
# 1. Price Movement Reward
if trade_outcome is not None:
# Direct trading outcome
base_reward += trade_outcome * 10 # Scale P&L
else:
# Prediction accuracy reward
price_change = self._calculate_price_change(market_data_before, market_data_after)
action_correctness = self._evaluate_action_correctness(action, price_change)
base_reward += action_correctness * 5
# 2. Market Regime Bonus
regime_bonus = self._calculate_regime_bonus(action, market_data_after)
base_reward += regime_bonus
# 3. Volatility Penalty/Bonus
volatility_factor = self._calculate_volatility_factor(market_data_after)
base_reward *= volatility_factor
# 4. CNN Confidence Alignment
cnn_alignment = self._calculate_cnn_alignment_bonus(action, market_data_after)
base_reward += cnn_alignment
# 5. Pivot Point Accuracy
pivot_accuracy = self._calculate_pivot_accuracy_bonus(action, market_data_after)
base_reward += pivot_accuracy
return base_reward
```
### Phase 5: Implementation Timeline
#### Week 1: State Representation Enhancement
- [ ] Implement EnhancedRLStateBuilder
- [ ] Add tick data processing
- [ ] Implement multi-timeframe OHLCV integration
- [ ] Add BTC reference data processing
#### Week 2: Pivot Point System
- [ ] Implement WilliamsMarketStructure class
- [ ] Add recursive pivot point calculation
- [ ] Integrate with state builder
- [ ] Test pivot point accuracy
#### Week 3: CNN-RL Integration
- [ ] Implement CNNRLBridge
- [ ] Add hidden feature extraction
- [ ] Integrate CNN predictions into RL state
- [ ] Test feature consistency
#### Week 4: Enhanced Training Pipeline
- [ ] Implement EnhancedRLTrainingPipeline
- [ ] Add enhanced reward calculator
- [ ] Integrate all components
- [ ] Performance testing and optimization
#### Week 5: Testing and Validation
- [ ] Comprehensive integration testing
- [ ] Performance validation
- [ ] Memory usage optimization
- [ ] Documentation and monitoring
## Expected Improvements
### 1. **State Representation Quality**
- **Current**: ~100 basic features
- **Enhanced**: ~8000+ comprehensive features
- **Improvement**: 80x more information density
### 2. **Decision Making Accuracy**
- **Current**: Limited to basic market metrics
- **Enhanced**: Multi-modal with CNN features + pivot points
- **Expected**: 40-60% improvement in prediction accuracy
### 3. **Market Adaptability**
- **Current**: Basic market regime detection
- **Enhanced**: Multi-timeframe analysis with recursive trends
- **Expected**: Better performance across different market conditions
### 4. **Learning Efficiency**
- **Current**: Simple experience replay
- **Enhanced**: Prioritized replay with sophisticated rewards
- **Expected**: 2-3x faster convergence
## Risk Mitigation
### 1. **Memory Usage**
- **Risk**: Large state vectors (~8000 features) may cause memory issues
- **Mitigation**: Implement state compression and efficient batching
### 2. **Training Stability**
- **Risk**: Complex state space may cause training instability
- **Mitigation**: Gradual state expansion, careful hyperparameter tuning
### 3. **Integration Complexity**
- **Risk**: CNN-RL integration may introduce bugs
- **Mitigation**: Extensive testing, fallback mechanisms
### 4. **Performance Impact**
- **Risk**: Real-time performance degradation
- **Mitigation**: Asynchronous processing, optimized data structures
## Success Metrics
1. **State Quality**: Feature coverage > 95% of required specification
2. **Training Performance**: Convergence time < 50% of current
3. **Decision Accuracy**: Prediction accuracy > 65% (vs current ~45%)
4. **Market Adaptability**: Consistent performance across 3+ market regimes
5. **Integration Stability**: Uptime > 99.5% with CNN integration
This comprehensive upgrade will transform the RL training pipeline from a basic implementation to a sophisticated multi-modal system that fully meets the specification requirements.

0
docs/cache_corruption_fix.md
View File

280
docs/logging_system_upgrade.md
View File

@@ -1,280 +0,0 @@
# Trading System Logging Upgrade
## Overview
This upgrade implements a comprehensive logging and metadata management system that addresses the key issues:
1. **Eliminates scattered "No checkpoints found" logs** during runtime
2. **Fast checkpoint metadata access** without loading full models
3. **Centralized inference logging** with database and text file storage
4. **Structured tracking** of model performance and checkpoints
## Key Components
### 1. Database Manager (`utils/database_manager.py`)
**Purpose**: SQLite-based storage for structured data
**Features**:
- Inference records logging with deduplication
- Checkpoint metadata storage (separate from model weights)
- Model performance tracking
- Fast queries without loading model files
**Tables**:
- `inference_records`: All model predictions with metadata
- `checkpoint_metadata`: Checkpoint info without model weights
- `model_performance`: Daily aggregated statistics
### 2. Inference Logger (`utils/inference_logger.py`)
**Purpose**: Centralized logging for all model inferences
**Features**:
- Single function call replaces scattered `logger.info()` calls
- Automatic feature hashing for deduplication
- Memory usage tracking
- Processing time measurement
- Dual storage (database + text files)
**Usage**:
```python
from utils.inference_logger import log_model_inference
log_model_inference(
model_name="dqn_agent",
symbol="ETH/USDT",
action="BUY",
confidence=0.85,
probabilities={"BUY": 0.85, "SELL": 0.10, "HOLD": 0.05},
input_features=features_array,
processing_time_ms=12.5,
checkpoint_id="dqn_agent_20250725_143500"
)
```
### 3. Text Logger (`utils/text_logger.py`)
**Purpose**: Human-readable log files for tracking
**Features**:
- Separate files for different event types
- Clean, tabular format
- Automatic cleanup of old entries
- Easy to read and grep
**Files**:
- `logs/inference_records.txt`: All model predictions
- `logs/checkpoint_events.txt`: Save/load events
- `logs/system_events.txt`: General system events
### 4. Enhanced Checkpoint Manager (`utils/checkpoint_manager.py`)
**Purpose**: Improved checkpoint handling with metadata separation
**Features**:
- Database-backed metadata storage
- Fast metadata queries without loading models
- Eliminates "No checkpoints found" spam
- Backward compatibility with existing code
## Benefits
### 1. Performance Improvements
**Before**: Loading full checkpoint just to get metadata
```python
# Old way - loads entire model!
checkpoint_path, metadata = load_best_checkpoint("dqn_agent")
loss = metadata.loss # Expensive operation
```
**After**: Fast metadata access from database
```python
# New way - database query only
metadata = db_manager.get_best_checkpoint_metadata("dqn_agent")
loss = metadata.performance_metrics['loss'] # Fast!
```
### 2. Cleaner Runtime Logs
**Before**: Scattered logs everywhere
```
2025-07-25 14:34:39,749 - utils.checkpoint_manager - INFO - No checkpoints found for dqn_agent
2025-07-25 14:34:39,754 - utils.checkpoint_manager - INFO - No checkpoints found for enhanced_cnn
2025-07-25 14:34:39,756 - utils.checkpoint_manager - INFO - No checkpoints found for extrema_trainer
```
**After**: Clean, structured logging
```
2025-07-25 14:34:39 | dqn_agent | ETH/USDT | BUY | conf=0.850 | time= 12.5ms [checkpoint: dqn_agent_20250725_143500]
2025-07-25 14:34:40 | enhanced_cnn | ETH/USDT | HOLD | conf=0.720 | time= 8.2ms [checkpoint: enhanced_cnn_20250725_143501]
```
### 3. Structured Data Storage
**Database Schema**:
```sql
-- Fast metadata queries
SELECT * FROM checkpoint_metadata WHERE model_name = 'dqn_agent' AND is_active = TRUE;
-- Performance analysis
SELECT model_name, AVG(confidence), COUNT(*)
FROM inference_records
WHERE timestamp > datetime('now', '-24 hours')
GROUP BY model_name;
```
### 4. Easy Integration
**In Model Code**:
```python
# Replace scattered logging
# OLD: logger.info(f"DQN prediction: {action} confidence={conf}")
# NEW: Centralized logging
self.orchestrator.log_model_inference(
model_name="dqn_agent",
symbol=symbol,
action=action,
confidence=confidence,
probabilities=probs,
input_features=features,
processing_time_ms=processing_time
)
```
## Implementation Guide
### 1. Update Model Classes
Add inference logging to prediction methods:
```python
class DQNAgent:
def predict(self, state):
start_time = time.time()
# Your prediction logic here
action = self._predict_action(state)
confidence = self._calculate_confidence()
processing_time = (time.time() - start_time) * 1000
# Log the inference
self.orchestrator.log_model_inference(
model_name="dqn_agent",
symbol=self.symbol,
action=action,
confidence=confidence,
probabilities=self.action_probabilities,
input_features=state,
processing_time_ms=processing_time,
checkpoint_id=self.current_checkpoint_id
)
return action
```
### 2. Update Checkpoint Saving
Use the enhanced checkpoint manager:
```python
from utils.checkpoint_manager import save_checkpoint
# Save with metadata
checkpoint_metadata = save_checkpoint(
model=self.model,
model_name="dqn_agent",
model_type="rl",
performance_metrics={"loss": 0.0234, "accuracy": 0.87},
training_metadata={"epochs": 100, "lr": 0.001}
)
```
### 3. Fast Metadata Access
Get checkpoint info without loading models:
```python
# Fast metadata access
metadata = orchestrator.get_checkpoint_metadata_fast("dqn_agent")
if metadata:
current_loss = metadata.performance_metrics['loss']
checkpoint_id = metadata.checkpoint_id
```
## Migration Steps
1. **Install new dependencies** (if any)
2. **Update model classes** to use centralized logging
3. **Replace checkpoint loading** with database queries where possible
4. **Remove scattered logger.info()** calls for inferences
5. **Test with demo script**: `python demo_logging_system.py`
## File Structure
```
utils/
├── database_manager.py # SQLite database management
├── inference_logger.py # Centralized inference logging
├── text_logger.py # Human-readable text logs
└── checkpoint_manager.py # Enhanced checkpoint handling
logs/ # Text log files
├── inference_records.txt
├── checkpoint_events.txt
└── system_events.txt
data/
└── trading_system.db # SQLite database
demo_logging_system.py # Demonstration script
```
## Monitoring and Maintenance
### Daily Tasks
- Check `logs/inference_records.txt` for recent activity
- Monitor database size: `ls -lh data/trading_system.db`
### Weekly Tasks
- Run cleanup: `inference_logger.cleanup_old_logs(days_to_keep=30)`
- Check model performance trends in database
### Monthly Tasks
- Archive old log files
- Analyze model performance statistics
- Review checkpoint storage usage
## Troubleshooting
### Common Issues
1. **Database locked**: Multiple processes accessing SQLite
- Solution: Use connection timeout and proper context managers
2. **Log files growing too large**:
- Solution: Run `text_logger.cleanup_old_logs(max_lines=10000)`
3. **Missing checkpoint metadata**:
- Solution: System falls back to file-based approach automatically
### Debug Commands
```python
# Check database status
db_manager = get_database_manager()
checkpoints = db_manager.list_checkpoints("dqn_agent")
# Check recent inferences
inference_logger = get_inference_logger()
stats = inference_logger.get_model_stats("dqn_agent", hours=24)
# View text logs
text_logger = get_text_logger()
recent = text_logger.get_recent_inferences(lines=50)
```
This upgrade provides a solid foundation for tracking model performance, eliminating log spam, and enabling fast metadata access without the overhead of loading full model checkpoints.

265
examples/enhanced_reward_system_example.py
View File

@@ -1,265 +0,0 @@
"""
Enhanced Reward System Integration Example
This example demonstrates how to integrate the new MSE-based reward system
with the existing trading orchestrator and models.
Usage:
python examples/enhanced_reward_system_example.py
This example shows:
1. How to integrate the enhanced reward system with TradingOrchestrator
2. How to add predictions from existing models
3. How to monitor accuracy and training statistics
4. How the system handles multi-timeframe predictions and training
"""
import asyncio
import logging
import time
from datetime import datetime
# Import the integration components
from core.enhanced_reward_system_integration import (
integrate_enhanced_rewards,
start_enhanced_rewards_for_orchestrator,
add_prediction_to_enhanced_rewards
)
# Configure logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
async def demonstrate_enhanced_reward_integration():
"""Demonstrate the enhanced reward system integration"""
print("=" * 80)
print("ENHANCED REWARD SYSTEM INTEGRATION DEMONSTRATION")
print("=" * 80)
# Note: This is a demonstration - in real usage, you would use your actual orchestrator
# For this example, we'll create a mock orchestrator
print("\n1. Setting up mock orchestrator...")
mock_orchestrator = create_mock_orchestrator()
print("\n2. Integrating enhanced reward system...")
# This is the main integration step - just one line!
enhanced_rewards = integrate_enhanced_rewards(mock_orchestrator, ['ETH/USDT', 'BTC/USDT'])
print("\n3. Starting enhanced reward system...")
await start_enhanced_rewards_for_orchestrator(mock_orchestrator)
print("\n4. System is now running with enhanced rewards!")
print(" - CNN predictions every 10 seconds (current rate)")
print(" - Continuous inference every 5 seconds")
print(" - Hourly multi-timeframe inference (4 predictions per hour)")
print(" - Real-time MSE-based reward calculation")
print(" - Automatic training when predictions are evaluated")
# Demonstrate adding predictions from existing models
await demonstrate_prediction_tracking(mock_orchestrator)
# Demonstrate monitoring and statistics
await demonstrate_monitoring(mock_orchestrator)
# Demonstrate force evaluation for testing
await demonstrate_force_evaluation(mock_orchestrator)
print("\n8. Stopping enhanced reward system...")
await mock_orchestrator.enhanced_reward_system.stop_integration()
print("\n✅ Enhanced Reward System demonstration completed successfully!")
print("\nTo integrate with your actual system:")
print("1. Add these imports to your orchestrator file")
print("2. Call integrate_enhanced_rewards(your_orchestrator) in __init__")
print("3. Call await start_enhanced_rewards_for_orchestrator(your_orchestrator) in run()")
print("4. Use add_prediction_to_enhanced_rewards() in your model inference code")
async def demonstrate_prediction_tracking(orchestrator):
"""Demonstrate how to track predictions from existing models"""
print("\n5. Demonstrating prediction tracking...")
# Simulate predictions from different models and timeframes
predictions = [
# CNN predictions for multiple timeframes
('ETH/USDT', '1s', 3150.50, 1, 0.85, 3150.00, 'enhanced_cnn'),
('ETH/USDT', '1m', 3155.00, 1, 0.78, 3150.00, 'enhanced_cnn'),
('ETH/USDT', '1h', 3200.00, 1, 0.72, 3150.00, 'enhanced_cnn'),
('ETH/USDT', '1d', 3300.00, 1, 0.65, 3150.00, 'enhanced_cnn'),
# DQN predictions
('ETH/USDT', '1s', 3149.00, -1, 0.70, 3150.00, 'dqn_agent'),
('BTC/USDT', '1s', 51200.00, 1, 0.75, 51150.00, 'dqn_agent'),
# COB RL predictions
('ETH/USDT', '1s', 3151.20, 1, 0.88, 3150.00, 'cob_rl'),
('BTC/USDT', '1s', 51180.00, 1, 0.82, 51150.00, 'cob_rl'),
]
prediction_ids = []
for symbol, timeframe, pred_price, direction, confidence, curr_price, model in predictions:
prediction_id = add_prediction_to_enhanced_rewards(
orchestrator, symbol, timeframe, pred_price, direction, confidence, curr_price, model
)
prediction_ids.append(prediction_id)
print(f" ✓ Added prediction: {model} predicts {symbol} {timeframe} "
f"direction={direction} confidence={confidence:.2f}")
print(f" 📊 Total predictions added: {len(prediction_ids)}")
async def demonstrate_monitoring(orchestrator):
"""Demonstrate monitoring and statistics"""
print("\n6. Demonstrating monitoring and statistics...")
# Wait a bit for some processing
await asyncio.sleep(2)
# Get integration statistics
stats = orchestrator.enhanced_reward_system.get_integration_statistics()
print(" 📈 Integration Statistics:")
print(f" - System running: {stats.get('is_running', False)}")
print(f" - Start time: {stats.get('start_time', 'N/A')}")
print(f" - Predictions tracked: {stats.get('total_predictions_tracked', 0)}")
# Get accuracy summary
accuracy = orchestrator.enhanced_reward_system.get_model_accuracy()
print("\n 🎯 Accuracy Summary by Symbol and Timeframe:")
for symbol, timeframes in accuracy.items():
print(f" - {symbol}:")
for timeframe, metrics in timeframes.items():
print(f" - {timeframe}: {metrics['total_predictions']} predictions, "
f"{metrics['direction_accuracy']:.1f}% accuracy")
async def demonstrate_force_evaluation(orchestrator):
"""Demonstrate force evaluation for testing"""
print("\n7. Demonstrating force evaluation for testing...")
# Simulate some price changes by updating prices
print(" 💰 Simulating price changes...")
orchestrator.enhanced_reward_system.reward_calculator.update_price('ETH/USDT', 3152.50)
orchestrator.enhanced_reward_system.reward_calculator.update_price('BTC/USDT', 51175.00)
# Force evaluation of all predictions
print(" ⚡ Force evaluating all predictions...")
orchestrator.enhanced_reward_system.force_evaluation_and_training()
# Get updated statistics
await asyncio.sleep(1)
stats = orchestrator.enhanced_reward_system.get_integration_statistics()
print(" 📊 Updated statistics after evaluation:")
accuracy = orchestrator.enhanced_reward_system.get_model_accuracy()
total_evaluated = sum(
sum(tf_data['total_predictions'] for tf_data in symbol_data.values())
for symbol_data in accuracy.values()
)
print(f" - Total predictions evaluated: {total_evaluated}")
def create_mock_orchestrator():
"""Create a mock orchestrator for demonstration purposes"""
class MockDataProvider:
def __init__(self):
self.current_prices = {
'ETH/USDT': 3150.00,
'BTC/USDT': 51150.00
}
class MockOrchestrator:
def __init__(self):
self.data_provider = MockDataProvider()
# Add other mock attributes as needed
return MockOrchestrator()
def show_integration_instructions():
"""Show step-by-step integration instructions"""
print("\n" + "=" * 80)
print("INTEGRATION INSTRUCTIONS FOR YOUR ACTUAL SYSTEM")
print("=" * 80)
print("""
To integrate the enhanced reward system with your actual TradingOrchestrator:
1. ADD IMPORTS to your orchestrator.py:
```python
from core.enhanced_reward_system_integration import (
integrate_enhanced_rewards,
add_prediction_to_enhanced_rewards
)
```
2. INTEGRATE in TradingOrchestrator.__init__():
```python
# Add this line in your __init__ method
integrate_enhanced_rewards(self, symbols=['ETH/USDT', 'BTC/USDT'])
```
3. START in TradingOrchestrator.run():
```python
# Add this line in your run() method, after initialization
await self.enhanced_reward_system.start_integration()
```
4. ADD PREDICTIONS in your model inference code:
```python
# In your CNN/DQN/COB model inference methods, add:
prediction_id = add_prediction_to_enhanced_rewards(
self, # orchestrator instance
symbol, # e.g., 'ETH/USDT'
timeframe, # e.g., '1s', '1m', '1h', '1d'
predicted_price, # model's price prediction
direction, # -1 (down), 0 (neutral), 1 (up)
confidence, # 0.0 to 1.0
current_price, # current market price
model_name # e.g., 'enhanced_cnn', 'dqn_agent'
)
```
5. MONITOR with:
```python
# Get statistics anytime
stats = self.enhanced_reward_system.get_integration_statistics()
accuracy = self.enhanced_reward_system.get_model_accuracy()
```
The system will automatically:
- Track predictions for multiple timeframes separately
- Calculate MSE-based rewards when outcomes are available
- Trigger real-time training with enhanced rewards
- Maintain accuracy statistics for each model and timeframe
- Handle hourly multi-timeframe inference scheduling
Key Benefits:
✅ MSE-based accuracy measurement (better than simple directional accuracy)
✅ Separate tracking for up to 6 last predictions per timeframe
✅ Real-time training at each inference when outcomes available
✅ Multi-timeframe prediction support (1s, 1m, 1h, 1d)
✅ Hourly inference on all timeframes (4 predictions per hour)
✅ Models know which timeframe they're predicting on
✅ Backward compatible with existing code
""")
if __name__ == "__main__":
# Run the demonstration
asyncio.run(demonstrate_enhanced_reward_integration())
# Show integration instructions
show_integration_instructions()

BIN
mcp_servers/browser-tools-mcp/BrowserTools-1.2.0-extension.zip
View File

Binary file not shown.

309
tests/test_training.py
View File

@@ -1,309 +0,0 @@
#!/usr/bin/env python3
"""
Test Training Script for AI Trading Models
This script tests the training functionality of our CNN and RL models
and demonstrates the learning capabilities.
"""
import logging
import sys
import asyncio
from pathlib import Path
from datetime import datetime, timedelta
# Add project root to path
project_root = Path(__file__).parent
sys.path.insert(0, str(project_root))
from core.config import setup_logging
from core.data_provider import DataProvider
from core.enhanced_orchestrator import EnhancedTradingOrchestrator
from NN.training.model_manager import create_model_manager
# Setup logging
setup_logging()
logger = logging.getLogger(__name__)
def test_model_loading():
"""Test that models load correctly"""
logger.info("=== TESTING MODEL LOADING ===")
try:
# Get model registry
registry = get_model_registry()
# Check loaded models
logger.info(f"Loaded models: {list(registry.models.keys())}")
# Test each model
for name, model in registry.models.items():
logger.info(f"Testing {name} model...")
# Test prediction
import numpy as np
test_features = np.random.random((20, 5)) # 20 timesteps, 5 features
try:
predictions, confidence = model.predict(test_features)
logger.info(f" ✅ {name} prediction: {predictions} (confidence: {confidence:.3f})")
except Exception as e:
logger.error(f" ❌ {name} prediction failed: {e}")
# Memory stats
stats = registry.get_memory_stats()
logger.info(f"Memory usage: {stats['total_used_mb']:.1f}MB / {stats['total_limit_mb']:.1f}MB")
return True
except Exception as e:
logger.error(f"Model loading test failed: {e}")
return False
async def test_orchestrator_integration():
"""Test orchestrator integration with models"""
logger.info("=== TESTING ORCHESTRATOR INTEGRATION ===")
try:
# Initialize components
data_provider = DataProvider()
orchestrator = EnhancedTradingOrchestrator(data_provider)
# Test coordinated decisions
logger.info("Testing coordinated decision making...")
decisions = await orchestrator.make_coordinated_decisions()
if decisions:
for symbol, decision in decisions.items():
if decision:
logger.info(f" ✅ {symbol}: {decision.action} (confidence: {decision.confidence:.3f})")
else:
logger.info(f" ⏸️ {symbol}: No decision (waiting)")
else:
logger.warning(" ❌ No decisions made")
# Test RL evaluation
logger.info("Testing RL evaluation...")
await orchestrator.evaluate_actions_with_rl()
return True
except Exception as e:
logger.error(f"Orchestrator integration test failed: {e}")
return False
def test_rl_learning():
"""Test RL learning functionality"""
logger.info("=== TESTING RL LEARNING ===")
try:
registry = get_model_registry()
rl_agent = registry.get_model('RL')
if not rl_agent:
logger.error("RL agent not found")
return False
# Simulate some experiences
import numpy as np
logger.info("Simulating trading experiences...")
for i in range(50):
state = np.random.random(10)
action = np.random.randint(0, 3)
reward = np.random.uniform(-0.1, 0.1) # Random P&L
next_state = np.random.random(10)
done = False
# Store experience
rl_agent.remember(state, action, reward, next_state, done)
logger.info(f"Stored {len(rl_agent.experience_buffer)} experiences")
# Test replay training
logger.info("Testing replay training...")
loss = rl_agent.replay()
if loss is not None:
logger.info(f" ✅ Training loss: {loss:.4f}")
else:
logger.info(" ⏸️ Not enough experiences for training")
return True
except Exception as e:
logger.error(f"RL learning test failed: {e}")
return False
def test_cnn_training():
"""Test CNN training functionality"""
logger.info("=== TESTING CNN TRAINING ===")
try:
registry = get_model_registry()
cnn_model = registry.get_model('CNN')
if not cnn_model:
logger.error("CNN model not found")
return False
# Test training with mock perfect moves
training_data = {
'perfect_moves': [],
'market_data': {},
'symbols': ['ETH/USDT', 'BTC/USDT'],
'timeframes': ['1m', '1h']
}
# Mock some perfect moves
for i in range(10):
perfect_move = {
'symbol': 'ETH/USDT',
'timeframe': '1m',
'timestamp': datetime.now() - timedelta(hours=i),
'optimal_action': 'BUY' if i % 2 == 0 else 'SELL',
'confidence_should_have_been': 0.8 + i * 0.01,
'actual_outcome': 0.02 if i % 2 == 0 else -0.015
}
training_data['perfect_moves'].append(perfect_move)
logger.info(f"Testing training with {len(training_data['perfect_moves'])} perfect moves...")
# Test training
result = cnn_model.train(training_data)
if result and result.get('status') == 'training_simulated':
logger.info(f" ✅ Training completed: {result}")
else:
logger.warning(f" ⚠️ Training result: {result}")
return True
except Exception as e:
logger.error(f"CNN training test failed: {e}")
return False
def test_prediction_tracking():
"""Test prediction tracking and learning feedback"""
logger.info("=== TESTING PREDICTION TRACKING ===")
try:
# Initialize components
data_provider = DataProvider()
orchestrator = EnhancedTradingOrchestrator(data_provider)
# Get some market data for testing
test_data = data_provider.get_historical_data('ETH/USDT', '1m', limit=100)
if test_data is None or test_data.empty:
logger.warning("No market data available for testing")
return True
logger.info(f"Testing with {len(test_data)} candles of ETH/USDT 1m data")
# Simulate some predictions and outcomes
correct_predictions = 0
total_predictions = 0
for i in range(min(10, len(test_data) - 5)):
# Get a slice of data
current_data = test_data.iloc[i:i+20]
future_data = test_data.iloc[i+20:i+25]
if len(current_data) < 20 or len(future_data) < 5:
continue
# Make prediction
current_price = current_data['close'].iloc[-1]
future_price = future_data['close'].iloc[-1]
actual_change = (future_price - current_price) / current_price
# Simulate model prediction
predicted_action = 'BUY' if actual_change > 0.001 else 'SELL' if actual_change < -0.001 else 'HOLD'
# Check if prediction was correct
if predicted_action == 'BUY' and actual_change > 0:
correct_predictions += 1
logger.info(f" ✅ Correct BUY prediction: {actual_change:.4f}")
elif predicted_action == 'SELL' and actual_change < 0:
correct_predictions += 1
logger.info(f" ✅ Correct SELL prediction: {actual_change:.4f}")
elif predicted_action == 'HOLD' and abs(actual_change) < 0.001:
correct_predictions += 1
logger.info(f" ✅ Correct HOLD prediction: {actual_change:.4f}")
else:
logger.info(f" ❌ Wrong {predicted_action} prediction: {actual_change:.4f}")
total_predictions += 1
if total_predictions > 0:
accuracy = correct_predictions / total_predictions
logger.info(f"Prediction accuracy: {accuracy:.1%} ({correct_predictions}/{total_predictions})")
return True
except Exception as e:
logger.error(f"Prediction tracking test failed: {e}")
return False
async def main():
"""Main test function"""
logger.info("🧪 STARTING AI TRADING MODEL TESTS")
logger.info("Testing model loading, training, and learning capabilities")
tests = [
("Model Loading", test_model_loading),
("Orchestrator Integration", test_orchestrator_integration),
("RL Learning", test_rl_learning),
("CNN Training", test_cnn_training),
("Prediction Tracking", test_prediction_tracking)
]
results = {}
for test_name, test_func in tests:
logger.info(f"\n{'='*50}")
logger.info(f"Running: {test_name}")
logger.info(f"{'='*50}")
try:
if asyncio.iscoroutinefunction(test_func):
result = await test_func()
else:
result = test_func()
results[test_name] = result
if result:
logger.info(f"✅ {test_name}: PASSED")
else:
logger.error(f"❌ {test_name}: FAILED")
except Exception as e:
logger.error(f"❌ {test_name}: ERROR - {e}")
results[test_name] = False
# Summary
logger.info(f"\n{'='*50}")
logger.info("TEST SUMMARY")
logger.info(f"{'='*50}")
passed = sum(1 for result in results.values() if result)
total = len(results)
for test_name, result in results.items():
status = "✅ PASSED" if result else "❌ FAILED"
logger.info(f"{test_name}: {status}")
logger.info(f"\nOverall: {passed}/{total} tests passed ({passed/total:.1%})")
if passed == total:
logger.info("🎉 All tests passed! The AI trading system is working correctly.")
else:
logger.warning(f"⚠️ {total-passed} tests failed. Please check the logs above.")
return 0 if passed == total else 1
if __name__ == "__main__":
exit_code = asyncio.run(main())
sys.exit(exit_code)

351
training/williams_market_structure.py
View File

@@ -1,351 +0,0 @@
#!/usr/bin/env python3
"""
Williams Market Structure Implementation
Recursive pivot point detection for nested market structure analysis
"""
import numpy as np
import pandas as pd
from typing import Dict, List, Any, Optional, Tuple
from dataclasses import dataclass
import logging
logger = logging.getLogger(__name__)
@dataclass
class SwingPoint:
"""Represents a swing high or low point"""
price: float
timestamp: int
index: int
swing_type: str # 'high' or 'low'
@dataclass
class PivotLevel:
"""Represents a complete pivot level with swing points and analysis"""
swing_points: List[SwingPoint]
support_levels: List[float]
resistance_levels: List[float]
trend_direction: str
trend_strength: float
class WilliamsMarketStructure:
"""Implementation of Larry Williams market structure analysis with recursive pivot detection"""
def __init__(self, swing_strengths: List[int] = None, enable_cnn_feature: bool = False):
"""
Initialize Williams Market Structure analyzer
Args:
swing_strengths: List of swing strengths to detect (e.g., [2, 3, 5, 8])
enable_cnn_feature: Whether to enable CNN training features
"""
self.swing_strengths = swing_strengths or [2, 3, 5, 8]
self.enable_cnn_feature = enable_cnn_feature
self.min_swing_points = 5 # Minimum points needed for recursive analysis
def calculate_recursive_pivot_points(self, ohlcv_data: np.ndarray) -> Dict[str, PivotLevel]:
"""
Calculate 5 levels of recursive pivot points using Williams Market Structure
Args:
ohlcv_data: OHLCV data as numpy array with columns [timestamp, open, high, low, close, volume]
Returns:
Dict with keys 'level_0' through 'level_4' containing PivotLevel objects
"""
try:
logger.info(f"Starting recursive pivot analysis on {len(ohlcv_data)} candles")
levels = {}
current_data = ohlcv_data.copy()
for level in range(5):
logger.debug(f"Processing level {level} with {len(current_data)} data points")
# Find swing points for this level
swing_points = self._find_swing_points(current_data, strength=self.swing_strengths[min(level, len(self.swing_strengths)-1)])
if not swing_points or len(swing_points) < self.min_swing_points:
logger.warning(f"Insufficient swing points at level {level} ({len(swing_points) if swing_points else 0}), stopping recursion")
break
# Determine trend direction and strength
trend_direction = self._determine_trend_direction(swing_points)
trend_strength = self._calculate_trend_strength(swing_points)
# Extract support and resistance levels
support_levels, resistance_levels = self._extract_support_resistance(swing_points)
# Create pivot level
pivot_level = PivotLevel(
swing_points=swing_points,
support_levels=support_levels,
resistance_levels=resistance_levels,
trend_direction=trend_direction,
trend_strength=trend_strength
)
levels[f'level_{level}'] = pivot_level
# Prepare data for next level (convert swing points back to OHLCV format)
if level < 4 and len(swing_points) >= self.min_swing_points:
current_data = self._convert_swings_to_ohlcv(swing_points)
else:
break
logger.info(f"Completed recursive pivot analysis, generated {len(levels)} levels")
return levels
except Exception as e:
logger.error(f"Error in recursive pivot calculation: {e}")
return {}
def _find_swing_points(self, ohlcv_data: np.ndarray, strength: int = 3) -> List[SwingPoint]:
"""
Find swing high and low points using the specified strength
Args:
ohlcv_data: OHLCV data array
strength: Number of candles on each side to compare (higher = more significant swings)
Returns:
List of SwingPoint objects
"""
try:
if len(ohlcv_data) < strength * 2 + 1:
return []
swing_points = []
highs = ohlcv_data[:, 2] # High prices
lows = ohlcv_data[:, 3] # Low prices
timestamps = ohlcv_data[:, 0].astype(int)
for i in range(strength, len(ohlcv_data) - strength):
# Check for swing high
is_swing_high = True
for j in range(1, strength + 1):
if highs[i] <= highs[i - j] or highs[i] <= highs[i + j]:
is_swing_high = False
break
if is_swing_high:
swing_points.append(SwingPoint(
price=float(highs[i]),
timestamp=int(timestamps[i]),
index=i,
swing_type='high'
))
# Check for swing low
is_swing_low = True
for j in range(1, strength + 1):
if lows[i] >= lows[i - j] or lows[i] >= lows[i + j]:
is_swing_low = False
break
if is_swing_low:
swing_points.append(SwingPoint(
price=float(lows[i]),
timestamp=int(timestamps[i]),
index=i,
swing_type='low'
))
# Sort by timestamp
swing_points.sort(key=lambda x: x.timestamp)
logger.debug(f"Found {len(swing_points)} swing points with strength {strength}")
return swing_points
except Exception as e:
logger.error(f"Error finding swing points: {e}")
return []
def _determine_trend_direction(self, swing_points: List[SwingPoint]) -> str:
"""
Determine overall trend direction from swing points
Returns:
'UPTREND', 'DOWNTREND', or 'SIDEWAYS'
"""
try:
if len(swing_points) < 3:
return 'SIDEWAYS'
# Analyze the sequence of highs and lows
highs = [sp for sp in swing_points if sp.swing_type == 'high']
lows = [sp for sp in swing_points if sp.swing_type == 'low']
if len(highs) < 2 or len(lows) < 2:
return 'SIDEWAYS'
# Check if higher highs and higher lows (uptrend)
recent_highs = sorted(highs[-3:], key=lambda x: x.price)
recent_lows = sorted(lows[-3:], key=lambda x: x.price)
if (recent_highs[-1].price > recent_highs[0].price and
recent_lows[-1].price > recent_lows[0].price):
return 'UPTREND'
# Check if lower highs and lower lows (downtrend)
if (recent_highs[-1].price < recent_highs[0].price and
recent_lows[-1].price < recent_lows[0].price):
return 'DOWNTREND'
return 'SIDEWAYS'
except Exception as e:
logger.error(f"Error determining trend direction: {e}")
return 'SIDEWAYS'
def _calculate_trend_strength(self, swing_points: List[SwingPoint]) -> float:
"""
Calculate trend strength based on swing point consistency
Returns:
Float between 0.0 and 1.0 indicating trend strength
"""
try:
if len(swing_points) < 5:
return 0.0
# Calculate price movement consistency
prices = [sp.price for sp in swing_points]
direction_changes = 0
for i in range(2, len(prices)):
prev_diff = prices[i-1] - prices[i-2]
curr_diff = prices[i] - prices[i-1]
if (prev_diff > 0 and curr_diff < 0) or (prev_diff < 0 and curr_diff > 0):
direction_changes += 1
# Lower direction changes = stronger trend
consistency = 1.0 - (direction_changes / max(1, len(prices) - 2))
return max(0.0, min(1.0, consistency))
except Exception as e:
logger.error(f"Error calculating trend strength: {e}")
return 0.0
def _extract_support_resistance(self, swing_points: List[SwingPoint]) -> Tuple[List[float], List[float]]:
"""
Extract support and resistance levels from swing points
Returns:
Tuple of (support_levels, resistance_levels)
"""
try:
highs = [sp.price for sp in swing_points if sp.swing_type == 'high']
lows = [sp.price for sp in swing_points if sp.swing_type == 'low']
# Remove duplicates and sort
support_levels = sorted(list(set(lows)))
resistance_levels = sorted(list(set(highs)))
return support_levels, resistance_levels
except Exception as e:
logger.error(f"Error extracting support/resistance: {e}")
return [], []
def _convert_swings_to_ohlcv(self, swing_points: List[SwingPoint]) -> np.ndarray:
"""
Convert swing points back to OHLCV format for next level analysis
Args:
swing_points: List of swing points from current level
Returns:
OHLCV array for next level processing
"""
try:
if len(swing_points) < 2:
return np.array([])
# Sort by timestamp
swing_points.sort(key=lambda x: x.timestamp)
ohlcv_list = []
for i, swing in enumerate(swing_points):
# Create OHLCV bar from swing point
# Use swing price for O, H, L, C
ohlcv_bar = [
swing.timestamp, # timestamp
swing.price, # open
swing.price, # high
swing.price, # low
swing.price, # close
0.0 # volume (not applicable for swing points)
]
ohlcv_list.append(ohlcv_bar)
return np.array(ohlcv_list, dtype=np.float64)
except Exception as e:
logger.error(f"Error converting swings to OHLCV: {e}")
return np.array([])
def analyze_pivot_context(self, current_price: float, pivot_levels: Dict[str, PivotLevel]) -> Dict[str, Any]:
"""
Analyze current price position relative to pivot levels
Args:
current_price: Current market price
pivot_levels: Dictionary of pivot levels
Returns:
Analysis results including nearest supports/resistances and context
"""
try:
analysis = {
'current_price': current_price,
'nearest_support': None,
'nearest_resistance': None,
'support_distance': float('inf'),
'resistance_distance': float('inf'),
'pivot_context': 'NEUTRAL',
'nested_level': None
}
all_supports = []
all_resistances = []
# Collect all pivot levels
for level_name, level_data in pivot_levels.items():
all_supports.extend(level_data.support_levels)
all_resistances.extend(level_data.resistance_levels)
# Find nearest support
for support in sorted(set(all_supports)):
distance = current_price - support
if distance > 0 and distance < analysis['support_distance']:
analysis['nearest_support'] = support
analysis['support_distance'] = distance
# Find nearest resistance
for resistance in sorted(set(all_resistances)):
distance = resistance - current_price
if distance > 0 and distance < analysis['resistance_distance']:
analysis['nearest_resistance'] = resistance
analysis['resistance_distance'] = distance
# Determine pivot context
if analysis['nearest_resistance'] and analysis['nearest_support']:
resistance_dist = analysis['resistance_distance']
support_dist = analysis['support_distance']
if resistance_dist < support_dist * 0.5:
analysis['pivot_context'] = 'NEAR_RESISTANCE'
elif support_dist < resistance_dist * 0.5:
analysis['pivot_context'] = 'NEAR_SUPPORT'
else:
analysis['pivot_context'] = 'MID_RANGE'
return analysis
except Exception as e:
logger.error(f"Error analyzing pivot context: {e}")
return analysis