268 lines
7.6 KiB
Markdown
268 lines
7.6 KiB
Markdown
# IncrementalTrader
|
|
|
|
A high-performance, memory-efficient trading framework designed for real-time algorithmic trading and backtesting. Built around the principle of **incremental computation**, IncrementalTrader processes new data points efficiently without recalculating entire histories.
|
|
|
|
## 🚀 Key Features
|
|
|
|
- **Incremental Computation**: Constant memory usage and O(1) processing time per data point
|
|
- **Real-time Capable**: Designed for live trading with minimal latency
|
|
- **Modular Architecture**: Clean separation between strategies, execution, and testing
|
|
- **Built-in Strategies**: MetaTrend, BBRS, and Random strategies included
|
|
- **Comprehensive Backtesting**: Multi-threaded backtesting with parameter optimization
|
|
- **Rich Indicators**: Supertrend, Bollinger Bands, RSI, Moving Averages, and more
|
|
- **Performance Tracking**: Detailed metrics and portfolio analysis
|
|
|
|
## 📦 Installation
|
|
|
|
```bash
|
|
# Clone the repository
|
|
git clone <repository-url>
|
|
cd Cycles
|
|
|
|
# Install dependencies
|
|
pip install -r requirements.txt
|
|
|
|
# Import the module
|
|
from IncrementalTrader import *
|
|
```
|
|
|
|
## 🏃♂️ Quick Start
|
|
|
|
### Basic Strategy Usage
|
|
|
|
```python
|
|
from IncrementalTrader import MetaTrendStrategy, IncTrader
|
|
import pandas as pd
|
|
|
|
# Load your data
|
|
data = pd.read_csv('your_data.csv')
|
|
|
|
# Create strategy
|
|
strategy = MetaTrendStrategy("metatrend", params={
|
|
"timeframe": "15min",
|
|
"supertrend_periods": [10, 20, 30],
|
|
"supertrend_multipliers": [2.0, 3.0, 4.0]
|
|
})
|
|
|
|
# Create trader
|
|
trader = IncTrader(strategy, initial_usd=10000)
|
|
|
|
# Process data
|
|
for _, row in data.iterrows():
|
|
trader.process_data_point(
|
|
timestamp=row['timestamp'],
|
|
ohlcv=(row['open'], row['high'], row['low'], row['close'], row['volume'])
|
|
)
|
|
|
|
# Get results
|
|
results = trader.get_results()
|
|
print(f"Final Portfolio Value: ${results['final_portfolio_value']:.2f}")
|
|
print(f"Total Return: {results['total_return_pct']:.2f}%")
|
|
```
|
|
|
|
### Backtesting
|
|
|
|
```python
|
|
from IncrementalTrader import IncBacktester, BacktestConfig
|
|
|
|
# Configure backtest
|
|
config = BacktestConfig(
|
|
initial_usd=10000,
|
|
stop_loss_pct=0.03,
|
|
take_profit_pct=0.06,
|
|
start_date="2024-01-01",
|
|
end_date="2024-12-31"
|
|
)
|
|
|
|
# Run backtest
|
|
backtester = IncBacktester()
|
|
results = backtester.run_single_strategy(
|
|
strategy_class=MetaTrendStrategy,
|
|
strategy_params={"timeframe": "15min"},
|
|
config=config,
|
|
data_file="data/BTCUSDT_1m.csv"
|
|
)
|
|
|
|
# Analyze results
|
|
print(f"Sharpe Ratio: {results['performance_metrics']['sharpe_ratio']:.2f}")
|
|
print(f"Max Drawdown: {results['performance_metrics']['max_drawdown_pct']:.2f}%")
|
|
```
|
|
|
|
## 📊 Available Strategies
|
|
|
|
### MetaTrend Strategy
|
|
A sophisticated trend-following strategy that uses multiple Supertrend indicators to detect market trends.
|
|
|
|
```python
|
|
strategy = MetaTrendStrategy("metatrend", params={
|
|
"timeframe": "15min",
|
|
"supertrend_periods": [10, 20, 30],
|
|
"supertrend_multipliers": [2.0, 3.0, 4.0],
|
|
"min_trend_agreement": 0.6
|
|
})
|
|
```
|
|
|
|
### BBRS Strategy
|
|
Combines Bollinger Bands and RSI with market regime detection for adaptive trading.
|
|
|
|
```python
|
|
strategy = BBRSStrategy("bbrs", params={
|
|
"timeframe": "15min",
|
|
"bb_period": 20,
|
|
"bb_std": 2.0,
|
|
"rsi_period": 14,
|
|
"volume_ma_period": 20
|
|
})
|
|
```
|
|
|
|
### Random Strategy
|
|
A testing strategy that generates random signals for framework validation.
|
|
|
|
```python
|
|
strategy = RandomStrategy("random", params={
|
|
"timeframe": "15min",
|
|
"buy_probability": 0.1,
|
|
"sell_probability": 0.1
|
|
})
|
|
```
|
|
|
|
## 🔧 Technical Indicators
|
|
|
|
All indicators are designed for incremental computation:
|
|
|
|
```python
|
|
from IncrementalTrader.strategies.indicators import *
|
|
|
|
# Moving Averages
|
|
sma = MovingAverageState(period=20)
|
|
ema = ExponentialMovingAverageState(period=20, alpha=0.1)
|
|
|
|
# Volatility
|
|
atr = ATRState(period=14)
|
|
|
|
# Trend
|
|
supertrend = SupertrendState(period=10, multiplier=3.0)
|
|
|
|
# Oscillators
|
|
rsi = RSIState(period=14)
|
|
bb = BollingerBandsState(period=20, std_dev=2.0)
|
|
|
|
# Update with new data
|
|
for price in price_data:
|
|
sma.update(price)
|
|
current_sma = sma.get_value()
|
|
```
|
|
|
|
## 🧪 Parameter Optimization
|
|
|
|
```python
|
|
from IncrementalTrader import OptimizationConfig
|
|
|
|
# Define parameter ranges
|
|
param_ranges = {
|
|
"supertrend_periods": [[10, 20, 30], [15, 25, 35], [20, 30, 40]],
|
|
"supertrend_multipliers": [[2.0, 3.0, 4.0], [1.5, 2.5, 3.5]],
|
|
"min_trend_agreement": [0.5, 0.6, 0.7, 0.8]
|
|
}
|
|
|
|
# Configure optimization
|
|
opt_config = OptimizationConfig(
|
|
base_config=config,
|
|
param_ranges=param_ranges,
|
|
max_workers=4
|
|
)
|
|
|
|
# Run optimization
|
|
results = backtester.optimize_strategy(
|
|
strategy_class=MetaTrendStrategy,
|
|
optimization_config=opt_config,
|
|
data_file="data/BTCUSDT_1m.csv"
|
|
)
|
|
|
|
# Get best parameters
|
|
best_params = results['best_params']
|
|
best_performance = results['best_performance']
|
|
```
|
|
|
|
## 📈 Performance Analysis
|
|
|
|
```python
|
|
# Get detailed performance metrics
|
|
performance = results['performance_metrics']
|
|
|
|
print(f"Total Trades: {performance['total_trades']}")
|
|
print(f"Win Rate: {performance['win_rate']:.2f}%")
|
|
print(f"Profit Factor: {performance['profit_factor']:.2f}")
|
|
print(f"Sharpe Ratio: {performance['sharpe_ratio']:.2f}")
|
|
print(f"Max Drawdown: {performance['max_drawdown_pct']:.2f}%")
|
|
print(f"Calmar Ratio: {performance['calmar_ratio']:.2f}")
|
|
|
|
# Access trade history
|
|
trades = results['trades']
|
|
for trade in trades[-5:]: # Last 5 trades
|
|
print(f"Trade: {trade['side']} at {trade['price']} - P&L: {trade['pnl']:.2f}")
|
|
```
|
|
|
|
## 🏗️ Architecture
|
|
|
|
IncrementalTrader follows a modular architecture:
|
|
|
|
```
|
|
IncrementalTrader/
|
|
├── strategies/ # Trading strategies and indicators
|
|
│ ├── base.py # Base classes and framework
|
|
│ ├── metatrend.py # MetaTrend strategy
|
|
│ ├── bbrs.py # BBRS strategy
|
|
│ ├── random.py # Random strategy
|
|
│ └── indicators/ # Technical indicators
|
|
├── trader/ # Trade execution and position management
|
|
│ ├── trader.py # Main trader implementation
|
|
│ └── position.py # Position management
|
|
├── backtester/ # Backtesting framework
|
|
│ ├── backtester.py # Main backtesting engine
|
|
│ ├── config.py # Configuration management
|
|
│ └── utils.py # Utilities and helpers
|
|
└── docs/ # Documentation
|
|
```
|
|
|
|
## 🔍 Memory Efficiency
|
|
|
|
Traditional batch processing vs. IncrementalTrader:
|
|
|
|
| Aspect | Batch Processing | IncrementalTrader |
|
|
|--------|------------------|-------------------|
|
|
| Memory Usage | O(n) - grows with data | O(1) - constant |
|
|
| Processing Time | O(n) - recalculates all | O(1) - per data point |
|
|
| Real-time Capable | No - too slow | Yes - designed for it |
|
|
| Scalability | Poor - memory limited | Excellent - unlimited data |
|
|
|
|
## 📚 Documentation
|
|
|
|
- [Architecture Overview](docs/architecture.md) - Detailed system design
|
|
- [Strategy Development Guide](docs/strategies/strategies.md) - How to create custom strategies
|
|
- [Indicator Reference](docs/indicators/base.md) - Complete indicator documentation
|
|
- [Backtesting Guide](docs/backtesting.md) - Advanced backtesting features
|
|
- [API Reference](docs/api/api.md) - Complete API documentation
|
|
|
|
## 🤝 Contributing
|
|
|
|
1. Fork the repository
|
|
2. Create a feature branch
|
|
3. Make your changes
|
|
4. Add tests for new functionality
|
|
5. Submit a pull request
|
|
|
|
## 📄 License
|
|
|
|
This project is licensed under the MIT License - see the LICENSE file for details.
|
|
|
|
## 🆘 Support
|
|
|
|
For questions, issues, or contributions:
|
|
- Open an issue on GitHub
|
|
- Check the documentation in the `docs/` folder
|
|
- Review the examples in the `examples/` folder
|
|
|
|
---
|
|
|
|
**IncrementalTrader** - Efficient, scalable, and production-ready algorithmic trading framework. |