Simon/Cycles
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cleanup of the old Incremental trader after refactopring

Browse Source
This commit is contained in:
Ajasra
2025-05-29 00:28:48 +08:00
parent 54e3f5677a
commit a99ed50cfe
33 changed files with 2 additions and 12873 deletions
Download Patch File Download Diff File Expand all files Collapse all files

363
IncrementalTrader/docs/migration.md
View File

@@ -1,363 +0,0 @@
# Migration Guide: Cycles Framework → IncrementalTrader
## Overview
This guide helps you migrate from the legacy Cycles framework to the new IncrementalTrader module. The IncrementalTrader module provides a cleaner, more modular architecture while maintaining compatibility with existing strategies and workflows.
## Key Architectural Changes
### Module Structure
**Old Structure (Cycles)**:
```
cycles/
├── IncStrategies/
│ ├── base.py
│ ├── default_strategy.py
│ └── bbrs_strategy.py
├── backtest.py
├── trader.py
└── utils/
```
**New Structure (IncrementalTrader)**:
```
IncrementalTrader/
├── strategies/
│ ├── base.py
│ ├── metatrend.py
│ ├── random.py
│ ├── bbrs.py
│ └── indicators/
├── trader/
│ ├── trader.py
│ └── position.py
├── backtester/
│ ├── backtester.py
│ ├── config.py
│ └── utils.py
└── docs/
```
### Import Changes
**Old Imports**:
```python
from cycles.IncStrategies.base import StrategyBase, StrategySignal
from cycles.IncStrategies.default_strategy import DefaultStrategy
from cycles.IncStrategies.bbrs_strategy import BBRSStrategy
from cycles.backtest import Backtester
from cycles.trader import Trader
```
**New Imports**:
```python
from IncrementalTrader.strategies.base import IncStrategyBase, IncStrategySignal
from IncrementalTrader.strategies.metatrend import MetaTrendStrategy
from IncrementalTrader.strategies.bbrs import BBRSStrategy
from IncrementalTrader.backtester import IncBacktester
from IncrementalTrader.trader import IncTrader
```
## Strategy Migration
### Base Class Changes
**Old Base Class**:
```python
class MyStrategy(StrategyBase):
def get_entry_signal(self, backtester, df_index):
return StrategySignal("ENTRY", confidence=0.8)
```
**New Base Class**:
```python
class MyStrategy(IncStrategyBase):
def get_entry_signal(self, backtester, df_index):
return IncStrategySignal.BUY(confidence=0.8)
```
### Signal Generation Changes
**Old Signal Creation**:
```python
# Manual signal creation
signal = StrategySignal("ENTRY", confidence=0.8)
signal = StrategySignal("EXIT", confidence=0.9)
signal = StrategySignal("HOLD", confidence=0.0)
```
**New Signal Creation (Factory Methods)**:
```python
# Factory methods for cleaner signal creation
signal = IncStrategySignal.BUY(confidence=0.8)
signal = IncStrategySignal.SELL(confidence=0.9)
signal = IncStrategySignal.HOLD(confidence=0.0)
```
### Strategy Name Mapping
| Old Strategy | New Strategy | Compatibility Alias |
|-------------|-------------|-------------------|
| `DefaultStrategy` | `MetaTrendStrategy` | `IncMetaTrendStrategy` |
| `BBRSStrategy` | `BBRSStrategy` | `IncBBRSStrategy` |
| N/A | `RandomStrategy` | `IncRandomStrategy` |
## Backtesting Migration
### Configuration Changes
**Old Configuration**:
```python
# Direct backtester usage
backtester = Backtester(data, strategy)
results = backtester.run()
```
**New Configuration**:
```python
# Enhanced configuration system
from IncrementalTrader.backtester import IncBacktester, BacktestConfig
config = BacktestConfig(
initial_capital=10000,
commission=0.001,
slippage=0.0001
)
backtester = IncBacktester(config)
results = backtester.run_backtest(data, strategy)
```
### Parameter Optimization
**Old Optimization**:
```python
# Manual parameter loops
for param1 in values1:
for param2 in values2:
strategy = MyStrategy(param1=param1, param2=param2)
results = backtester.run()
```
**New Optimization**:
```python
# Built-in optimization framework
from IncrementalTrader.backtester import OptimizationConfig
opt_config = OptimizationConfig(
strategy_class=MyStrategy,
param_ranges={
'param1': [1, 2, 3, 4, 5],
'param2': [0.1, 0.2, 0.3, 0.4, 0.5]
},
optimization_metric='sharpe_ratio'
)
results = backtester.optimize_strategy(data, opt_config)
```
## Trading Migration
### Trader Interface Changes
**Old Trader**:
```python
trader = Trader(strategy, initial_capital=10000)
trader.process_tick(price_data)
```
**New Trader**:
```python
trader = IncTrader(strategy, initial_capital=10000)
trader.process_tick(price_data)
```
### Position Management
**Old Position Handling**:
```python
# Position management was embedded in trader
if trader.position_size > 0:
# Handle long position
```
**New Position Handling**:
```python
# Dedicated position manager
position_manager = trader.position_manager
if position_manager.has_position():
current_position = position_manager.get_current_position()
# Handle position with dedicated methods
```
## Indicator Migration
### Import Changes
**Old Indicator Imports**:
```python
from cycles.IncStrategies.indicators import SupertrendState, ATRState
```
**New Indicator Imports**:
```python
from IncrementalTrader.strategies.indicators import SupertrendState, ATRState
```
### Indicator Usage
The indicator interface remains largely the same, but with enhanced features:
**Enhanced Indicator Features**:
```python
# New indicators have better state management
supertrend = SupertrendState(period=10, multiplier=3.0)
# Process data incrementally
for price_data in data_stream:
supertrend.update(price_data)
current_trend = supertrend.get_value()
trend_direction = supertrend.get_trend()
```
## Compatibility Layer
### Backward Compatibility Aliases
The new module provides compatibility aliases for smooth migration:
```python
# These imports work for backward compatibility
from IncrementalTrader.strategies.metatrend import IncMetaTrendStrategy as DefaultStrategy
from IncrementalTrader.strategies.bbrs import IncBBRSStrategy as BBRSStrategy
from IncrementalTrader.strategies.random import IncRandomStrategy as RandomStrategy
```
### Gradual Migration Strategy
1. **Phase 1**: Update imports to use compatibility aliases
2. **Phase 2**: Update signal generation to use factory methods
3. **Phase 3**: Migrate to new configuration system
4. **Phase 4**: Update to new class names and remove aliases
## Enhanced Features
### New Capabilities in IncrementalTrader
1. **Modular Architecture**: Each component can be used independently
2. **Enhanced Configuration**: Robust configuration with validation
3. **Better Error Handling**: Comprehensive exception handling and logging
4. **Improved Performance**: Optimized data processing and memory usage
5. **Self-Contained**: No external dependencies on legacy modules
6. **Enhanced Documentation**: Comprehensive API documentation and examples
### Performance Improvements
- **Memory Efficiency**: Reduced memory footprint for large datasets
- **Processing Speed**: Optimized indicator calculations
- **Parallel Processing**: Built-in support for parallel backtesting
- **Resource Management**: Intelligent system resource allocation
## Migration Checklist
### Pre-Migration
- [ ] Review current strategy implementations
- [ ] Identify external dependencies
- [ ] Backup existing configurations
- [ ] Test current system performance
### During Migration
- [ ] Update import statements
- [ ] Replace signal generation with factory methods
- [ ] Update configuration format
- [ ] Test strategy behavior equivalence
- [ ] Validate backtesting results
### Post-Migration
- [ ] Remove old import statements
- [ ] Update documentation
- [ ] Performance testing
- [ ] Clean up legacy code references
## Common Migration Issues
### Issue 1: Signal Type Mismatch
**Problem**: Old string-based signals don't work with new system
**Solution**: Use factory methods (`IncStrategySignal.BUY()` instead of `"ENTRY"`)
### Issue 2: Import Errors
**Problem**: Old import paths no longer exist
**Solution**: Update to new module structure or use compatibility aliases
### Issue 3: Configuration Format
**Problem**: Old configuration format not compatible
**Solution**: Migrate to new `BacktestConfig` and `OptimizationConfig` classes
### Issue 4: Indicator State
**Problem**: Indicator state not preserved during migration
**Solution**: Use new indicator initialization patterns with proper state management
## Support and Resources
### Documentation
- [Strategy Development Guide](./strategies.md)
- [Indicator Reference](./indicators.md)
- [Backtesting Guide](./backtesting.md)
- [API Reference](./api.md)
### Examples
- [Basic Usage Examples](../examples/basic_usage.py)
- Strategy migration examples in documentation
### Getting Help
- Review the comprehensive API documentation
- Check the examples directory for usage patterns
- Refer to the original Cycles documentation for context
## Legacy Framework Reference
### Timeframe System (Legacy)
The legacy Cycles framework had sophisticated timeframe management that is preserved in the new system:
**Key Concepts from Legacy System**:
- Strategy-controlled timeframes
- Automatic resampling
- Precision execution with 1-minute data
- Signal mapping between timeframes
**Migration Notes**:
- The new `TimeframeAggregator` provides similar functionality
- Strategies can still specify required timeframes
- Multi-timeframe strategies are fully supported
- 1-minute precision for stop-loss execution is maintained
### Strategy Manager (Legacy)
The legacy StrategyManager for multi-strategy combination:
**Legacy Features**:
- Multi-strategy orchestration
- Signal combination methods (weighted consensus, majority voting)
- Multi-timeframe strategy coordination
**Migration Path**:
- Individual strategies are now self-contained
- Multi-strategy combination can be implemented at the application level
- Consider using multiple backtests and combining results
### Performance Characteristics (Legacy)
**Legacy Strategy Performance Notes**:
- Default Strategy: High accuracy in trending markets, vulnerable to sideways markets
- BBRS Strategy: Market regime adaptation, volume confirmation, multi-timeframe analysis
**New Performance Improvements**:
- Enhanced signal generation reduces false positives
- Better risk management with dedicated position manager
- Improved backtesting accuracy with enhanced data handling
---
*This migration guide provides a comprehensive path from the legacy Cycles framework to the new IncrementalTrader module while preserving functionality and improving architecture.*