This system uses EXCLUSIVELY real market data from cryptocurrency exchanges. NO synthetic, generated, or simulated data is allowed for training, testing, or inference.

Strictly Forbidden:

Any form of synthetic or generated data
Mock or simulated market conditions
Dummy data for testing or development
Random price generation or manipulation

Policy Compliance:

All data must come from live exchange APIs
Historical data must be authentic exchange records
Real-time feeds must be direct from exchange WebSockets
Zero tolerance for synthetic data in any form

See REAL_MARKET_DATA_POLICY.md for complete details and compliance guidelines.

Features

Multi-timeframe Analysis: 1s, 1m, 5m, 1h, 4h, 1d scalping focus
CNN Pattern Recognition: Real market pattern detection with temporal attention
RL Trading Agent: Reinforcement learning with real historical backtesting
Real-time Data: Live market data from Binance API
Web Dashboard: Real-time monitoring and visualization
Modular Architecture: Clean separation of concerns

Quick Start

1. Install Dependencies

pip install -r requirements.txt

2. Configure Settings

Edit config.yaml to set your preferences:

symbols: ["ETH/USDT", "BTC/USDT"]
timeframes: ["1s", "1m", "5m", "1h", "4h"]
training:
  use_only_real_data: true  # CRITICAL: Never change this

3. Launch Real-time Dashboard & Training

# Full system with live training
python main_dashboard.py --port 8051

# Dashboard only (no training)
python main_dashboard.py --port 8051 --no-training

4. Run Backtesting & Bulk Training

# 30-day backtest
python main_backtest.py --start 2024-01-01 --end 2024-01-31

# Custom symbol and window
python main_backtest.py --start 2024-01-01 --end 2024-12-31 --symbol BTC/USDT --window 48

5. Unified Training Runner

# Realtime training for 4 hours
python training_runner.py --mode realtime --duration 4

# Backtest training
python training_runner.py --mode backtest --start-date 2024-01-01 --end-date 2024-12-31

Architecture

gogo2/
├── core/                   # Core system components
│   ├── config.py          # Configuration management
│   ├── data_provider.py   # Real market data fetching
│   └── orchestrator.py    # Decision coordination
├── models/                # AI models (real data only)
│   ├── cnn/               # CNN pattern recognition
│   └── rl/                # RL trading agent
├── training/              # Training pipelines
│   ├── cnn_trainer.py     # CNN training with real data
│   └── rl_trainer.py      # RL training with real data
├── web/                   # Web dashboard
└── main_clean.py          # Unified entry point

Data Sources

Approved Sources

Binance API (real-time and historical)
Cached real market data
TimescaleDB with real data

Prohibited Sources

Synthetic data generation
Random data simulation
Mock market conditions

Training Modes

CNN Training with TensorBoard

# Train on real ETH/USDT data with TensorBoard monitoring
python main_clean.py --mode cnn --symbol ETH/USDT

# Monitor training in real-time
tensorboard --logdir=runs

# Or use the convenience script
python run_tensorboard.py

# Quick test with real data
python test_cnn_only.py

RL Training with TensorBoard

# Train RL agent with real data
python main_clean.py --mode rl --symbol ETH/USDT

# Real-time RL training
python train_rl_with_realtime.py --episodes 10

# Monitor RL training metrics
tensorboard --logdir=runs

TensorBoard Monitoring

All training sessions are logged to TensorBoard for real-time monitoring:

# Start TensorBoard server
tensorboard --logdir=runs

# Or use the convenience script
python run_tensorboard.py

Metrics Available:

CNN Training: Loss, accuracy, confidence scores, feature statistics
RL Training: Rewards, returns, win rates, epsilon values, trading metrics
Model Architecture: Parameter counts, memory usage
Real-time Updates: Batch-level and epoch-level metrics

Access TensorBoard at: http://localhost:6006

Performance

Memory Usage: <2GB per model
Training Speed: ~20 seconds for 50 epochs
Real Data Processing: 1000+ candles per timeframe
Feature Count: Dynamically detected from real data (typically 48)

Monitoring

All operations log their data sources:

INFO - Generating 10000 training cases for ETH/USDT from REAL market data
INFO - Loaded 1000 real candles for ETH/USDT 1s
INFO - Building network with 48 features from real market data

Testing

# Test data provider with real data
python -m pytest tests/test_data_provider.py

# Test CNN with real data
python test_cnn_only.py

# Test full system
python main_clean.py --mode test

Web Dashboard

Access at http://localhost:8050 for:

Real-time price charts
Model predictions
Trading performance
System metrics

Configuration

Key settings in config.yaml:

data:
  provider: "binance"        # Real exchange API
  cache_enabled: true        # Cache real data
  real_time_enabled: true    # Live data feed

training:
  use_only_real_data: true   # NEVER change this
  batch_size: 32
  epochs: 100

trading:
  max_position_size: 0.1
  trading_fee: 0.0002

Safety Features

Data Validation: Ensures all data comes from real sources
Cache Verification: Validates cached data authenticity
Training Monitoring: Logs all data sources
Emergency Stops: Halts training if synthetic data detected

Contributing

When contributing:

NEVER introduce synthetic data generation
Always use real market data for testing
Log data sources clearly
Follow the real data policy strictly

License

This project is for educational and research purposes. Use real market data responsibly.

** REMEMBER: This system's integrity depends on using only real market data. No exceptions.**