Crypto Trading Bot with Reinforcement Learning

An automated cryptocurrency trading bot that uses Deep Q-Learning (DQN) to trade ETH/USDT on the MEXC exchange. The bot features a sophisticated neural network architecture with LSTM layers and attention mechanisms for better pattern recognition.

Features

• Deep Q-Learning with experience replay
• LSTM layers for sequential data processing
• Multi-head attention mechanism
• Dueling DQN architecture
• Real-time trading capabilities
• TensorBoard integration for monitoring
• Comprehensive technical indicators
• Demo and live trading modes
• Automatic model checkpointing

Prerequisites

• Python 3.8+
• MEXC Exchange API credentials
• GPU recommended but not required

Installation

1. Clone the repository:

git clone https://github.com/yourusername/crypto-trading-bot.git
cd crypto-trading-bot

2. Create a virtual environment:

python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate

3. Install dependencies:

pip install -r requirements.txt

4. Create a .env file in the project root with your MEXC API credentials:

MEXC_API_KEY=your_api_key
MEXC_API_SECRET=your_api_secret

Usage

The bot can be run in three modes:

Training Mode

python main.py --mode train --episodes 1000

Evaluation Mode

python main.py --mode eval --episodes 10

Live Trading Mode

# Demo mode (simulated trading with real market data)
python main.py --mode live --demo

# Real trading (actual trades on MEXC)
python main.py --mode live

Demo mode simulates trading using real-time market data but does not execute actual trades. It still:

• Logs all trading decisions and performance metrics
• Updates the model based on market data (if in training mode)
• Displays real-time analytics and position information
• Calculates theoretical profits/losses
• Saves performance data to TensorBoard

This makes it perfect for testing strategies without financial risk.

Configuration

Key parameters can be adjusted in main.py:

• INITIAL_BALANCE: Starting balance for training/demo
• MAX_LEVERAGE: Maximum leverage for trades
• STOP_LOSS_PERCENT: Stop loss percentage
• TAKE_PROFIT_PERCENT: Take profit percentage
• BATCH_SIZE: Training batch size
• LEARNING_RATE: Model learning rate
• STATE_SIZE: Size of the state representation

Model Architecture

The DQN model includes:

• Input layer with technical indicators
• LSTM layers for temporal pattern recognition
• Multi-head attention mechanism
• Dueling architecture for better Q-value estimation
• Batch normalization for stable training

Monitoring

Training progress can be monitored using TensorBoard:

Training progress is logged to TensorBoard:

tensorboard --logdir=logs

This will show:

• Training rewards
• Account balance
• Win rate
• Loss metrics

Trading Strategy

The bot makes decisions based on:

• Price action
• Technical indicators (RSI, MACD, Bollinger Bands, etc.)
• Historical patterns through LSTM
• Risk management with stop-loss and take-profit

Safety Features

• Demo mode for safe testing
• Automatic stop-loss
• Position size limits
• Error handling for API calls
• Logging of all actions

Directory Structure

├── main.py # Main bot implementation ├── requirements.txt # Project dependencies ├── .env # API credentials ├── models/ # Saved model checkpoints ├── runs/ # TensorBoard logs └── trading_bot.log # Activity logs

Warning

Cryptocurrency trading carries significant risks. This bot is for educational purposes and should not be used with real money without thorough testing and understanding of the risks involved.

License

MIT License

The main changes I made: Fixed code block formatting by adding proper language identifiers Added missing closing code blocks Properly formatted directory structure Added complete sections that were cut off in the original Ensured consistent formatting throughout the document Added proper bash syntax highlighting for command examples The README.md now provides a complete guide for setting up and using the trading bot, with clear sections for installation, usage, configuration, and safety considerations.

Edits/improvements

Fixes the shape mismatch by ensuring the state vector is exactly STATE_SIZE elements Adds robust error handling in the model's forward pass to handle mismatched inputs Adds a transformer encoder for more sophisticated pattern recognition Provides an expand_model method to increase model capacity while preserving learned weights Adds detailed logging about model size and shape mismatches The model now has: Configurable hidden layer sizes Transformer layers for complex pattern recognition LSTM layers for temporal patterns Attention mechanisms for focusing on important features Dueling architecture for better Q-value estimation With hidden_size=256, this model has about 1-2 million parameters. By increasing hidden_size to 512 or 1024, you can easily scale to 5-20 million parameters. For even larger models (billions of parameters), you would need to implement a more distributed architecture with multiple GPUs, which would require significant changes to the training loop.