444 lines
15 KiB
Markdown
444 lines
15 KiB
Markdown
# MetaTrend Strategy Documentation
|
||
|
||
## Overview
|
||
|
||
The MetaTrend Strategy is a sophisticated trend-following algorithm that uses multiple Supertrend indicators to detect and confirm market trends. By combining signals from multiple Supertrend configurations, it creates a "meta-trend" that provides more reliable trend detection with reduced false signals.
|
||
|
||
## Strategy Concept
|
||
|
||
### Core Philosophy
|
||
- **Trend Confirmation**: Multiple Supertrend indicators must agree before generating signals
|
||
- **False Signal Reduction**: Requires consensus among indicators to filter noise
|
||
- **Adaptive Sensitivity**: Different Supertrend configurations capture various trend timeframes
|
||
- **Risk Management**: Built-in trend reversal detection for exit signals
|
||
|
||
### Key Features
|
||
- **Multi-Supertrend Analysis**: Uses 3+ Supertrend indicators with different parameters
|
||
- **Consensus-Based Signals**: Requires minimum agreement threshold for signal generation
|
||
- **Incremental Processing**: O(1) memory and processing time per data point
|
||
- **Configurable Parameters**: Flexible configuration for different market conditions
|
||
|
||
## Algorithm Details
|
||
|
||
### Mathematical Foundation
|
||
|
||
The strategy uses multiple Supertrend indicators, each calculated as:
|
||
|
||
```
|
||
Basic Upper Band = (High + Low) / 2 + Multiplier × ATR(Period)
|
||
Basic Lower Band = (High + Low) / 2 - Multiplier × ATR(Period)
|
||
|
||
Final Upper Band = Basic Upper Band < Previous Upper Band OR Previous Close > Previous Upper Band
|
||
? Basic Upper Band : Previous Upper Band
|
||
|
||
Final Lower Band = Basic Lower Band > Previous Lower Band OR Previous Close < Previous Lower Band
|
||
? Basic Lower Band : Previous Lower Band
|
||
|
||
Supertrend = Close <= Final Lower Band ? Final Lower Band : Final Upper Band
|
||
Trend Direction = Close <= Final Lower Band ? -1 : 1
|
||
```
|
||
|
||
### Meta-Trend Calculation
|
||
|
||
```python
|
||
# For each Supertrend indicator
|
||
for st in supertrend_collection:
|
||
if st.is_uptrend():
|
||
uptrend_count += 1
|
||
elif st.is_downtrend():
|
||
downtrend_count += 1
|
||
|
||
# Calculate agreement ratios
|
||
total_indicators = len(supertrend_collection)
|
||
uptrend_ratio = uptrend_count / total_indicators
|
||
downtrend_ratio = downtrend_count / total_indicators
|
||
|
||
# Generate meta-signal
|
||
if uptrend_ratio >= min_trend_agreement:
|
||
meta_signal = "BUY"
|
||
elif downtrend_ratio >= min_trend_agreement:
|
||
meta_signal = "SELL"
|
||
else:
|
||
meta_signal = "HOLD"
|
||
```
|
||
|
||
## Process Flow Diagram
|
||
|
||
```
|
||
Data Input (OHLCV)
|
||
↓
|
||
TimeframeAggregator
|
||
↓
|
||
[15min aggregated data]
|
||
↓
|
||
┌─────────────────────────────────────┐
|
||
│ MetaTrend Strategy │
|
||
│ │
|
||
│ ┌─────────────────────────────────┐│
|
||
│ │ SupertrendCollection ││
|
||
│ │ ││
|
||
│ │ ST1(10,2.0) → Signal1 ││
|
||
│ │ ST2(20,3.0) → Signal2 ││
|
||
│ │ ST3(30,4.0) → Signal3 ││
|
||
│ │ ││
|
||
│ │ Agreement Analysis: ││
|
||
│ │ - Count BUY signals ││
|
||
│ │ - Count SELL signals ││
|
||
│ │ - Calculate ratios ││
|
||
│ └─────────────────────────────────┘│
|
||
│ ↓ │
|
||
│ ┌─────────────────────────────────┐│
|
||
│ │ Meta-Signal Logic ││
|
||
│ │ ││
|
||
│ │ if uptrend_ratio >= threshold: ││
|
||
│ │ return BUY ││
|
||
│ │ elif downtrend_ratio >= thresh:││
|
||
│ │ return SELL ││
|
||
│ │ else: ││
|
||
│ │ return HOLD ││
|
||
│ └─────────────────────────────────┘│
|
||
└─────────────────────────────────────┘
|
||
↓
|
||
IncStrategySignal
|
||
↓
|
||
Trader Execution
|
||
```
|
||
|
||
## Implementation Architecture
|
||
|
||
### Class Hierarchy
|
||
|
||
```
|
||
IncStrategyBase
|
||
↓
|
||
MetaTrendStrategy
|
||
├── TimeframeAggregator (inherited)
|
||
├── SupertrendCollection
|
||
│ ├── SupertrendState(10, 2.0)
|
||
│ ├── SupertrendState(20, 3.0)
|
||
│ └── SupertrendState(30, 4.0)
|
||
└── Signal Generation Logic
|
||
```
|
||
|
||
### Key Components
|
||
|
||
#### 1. SupertrendCollection
|
||
```python
|
||
class SupertrendCollection:
|
||
def __init__(self, periods: list, multipliers: list):
|
||
# Creates multiple Supertrend indicators
|
||
self.supertrends = [
|
||
SupertrendState(period, multiplier)
|
||
for period, multiplier in zip(periods, multipliers)
|
||
]
|
||
|
||
def update_ohlc(self, high, low, close):
|
||
# Updates all Supertrend indicators
|
||
for st in self.supertrends:
|
||
st.update_ohlc(high, low, close)
|
||
|
||
def get_meta_signal(self, min_agreement=0.6):
|
||
# Calculates consensus signal
|
||
signals = [st.get_signal() for st in self.supertrends]
|
||
return self._calculate_consensus(signals, min_agreement)
|
||
```
|
||
|
||
#### 2. Signal Generation Process
|
||
```python
|
||
def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
|
||
open_price, high, low, close, volume = ohlcv
|
||
|
||
# Update all Supertrend indicators
|
||
self.supertrend_collection.update_ohlc(high, low, close)
|
||
|
||
# Check if indicators are ready
|
||
if not self.supertrend_collection.is_ready():
|
||
return IncStrategySignal.HOLD()
|
||
|
||
# Get meta-signal
|
||
meta_signal = self.supertrend_collection.get_meta_signal(
|
||
min_agreement=self.params['min_trend_agreement']
|
||
)
|
||
|
||
# Generate strategy signal
|
||
if meta_signal == 'BUY' and self.current_signal.signal_type != 'BUY':
|
||
return IncStrategySignal.BUY(
|
||
confidence=self.supertrend_collection.get_agreement_ratio(),
|
||
metadata={
|
||
'meta_signal': meta_signal,
|
||
'individual_signals': self.supertrend_collection.get_signals(),
|
||
'agreement_ratio': self.supertrend_collection.get_agreement_ratio()
|
||
}
|
||
)
|
||
elif meta_signal == 'SELL' and self.current_signal.signal_type != 'SELL':
|
||
return IncStrategySignal.SELL(
|
||
confidence=self.supertrend_collection.get_agreement_ratio(),
|
||
metadata={
|
||
'meta_signal': meta_signal,
|
||
'individual_signals': self.supertrend_collection.get_signals(),
|
||
'agreement_ratio': self.supertrend_collection.get_agreement_ratio()
|
||
}
|
||
)
|
||
|
||
return IncStrategySignal.HOLD()
|
||
```
|
||
|
||
## Configuration Parameters
|
||
|
||
### Default Parameters
|
||
```python
|
||
default_params = {
|
||
"timeframe": "15min", # Data aggregation timeframe
|
||
"supertrend_periods": [10, 20, 30], # ATR periods for each Supertrend
|
||
"supertrend_multipliers": [2.0, 3.0, 4.0], # Multipliers for each Supertrend
|
||
"min_trend_agreement": 0.6 # Minimum agreement ratio (60%)
|
||
}
|
||
```
|
||
|
||
### Parameter Descriptions
|
||
|
||
| Parameter | Type | Default | Description |
|
||
|-----------|------|---------|-------------|
|
||
| `timeframe` | str | "15min" | Data aggregation timeframe |
|
||
| `supertrend_periods` | List[int] | [10, 20, 30] | ATR periods for Supertrend calculations |
|
||
| `supertrend_multipliers` | List[float] | [2.0, 3.0, 4.0] | ATR multipliers for band calculation |
|
||
| `min_trend_agreement` | float | 0.6 | Minimum ratio of indicators that must agree |
|
||
|
||
### Parameter Optimization Ranges
|
||
|
||
```python
|
||
optimization_ranges = {
|
||
"supertrend_periods": [
|
||
[10, 20, 30], # Conservative
|
||
[15, 25, 35], # Moderate
|
||
[20, 30, 40], # Aggressive
|
||
[5, 15, 25], # Fast
|
||
[25, 35, 45] # Slow
|
||
],
|
||
"supertrend_multipliers": [
|
||
[1.5, 2.5, 3.5], # Tight bands
|
||
[2.0, 3.0, 4.0], # Standard
|
||
[2.5, 3.5, 4.5], # Wide bands
|
||
[3.0, 4.0, 5.0] # Very wide bands
|
||
],
|
||
"min_trend_agreement": [0.4, 0.5, 0.6, 0.7, 0.8, 0.9],
|
||
"timeframe": ["5min", "15min", "30min", "1h"]
|
||
}
|
||
```
|
||
|
||
## Signal Generation Logic
|
||
|
||
### Entry Conditions
|
||
|
||
**BUY Signal Generated When:**
|
||
1. Meta-trend changes from non-bullish to bullish
|
||
2. Agreement ratio ≥ `min_trend_agreement`
|
||
3. Previous signal was not already BUY
|
||
4. All Supertrend indicators are ready
|
||
|
||
**SELL Signal Generated When:**
|
||
1. Meta-trend changes from non-bearish to bearish
|
||
2. Agreement ratio ≥ `min_trend_agreement`
|
||
3. Previous signal was not already SELL
|
||
4. All Supertrend indicators are ready
|
||
|
||
### Signal Confidence
|
||
|
||
The confidence level is calculated as the agreement ratio:
|
||
```python
|
||
confidence = agreeing_indicators / total_indicators
|
||
```
|
||
|
||
- **High Confidence (0.8-1.0)**: Strong consensus among indicators
|
||
- **Medium Confidence (0.6-0.8)**: Moderate consensus
|
||
- **Low Confidence (0.4-0.6)**: Weak consensus (may not generate signal)
|
||
|
||
### Signal Metadata
|
||
|
||
Each signal includes comprehensive metadata:
|
||
```python
|
||
metadata = {
|
||
'meta_signal': 'BUY', # Overall meta-signal
|
||
'individual_signals': ['BUY', 'BUY', 'HOLD'], # Individual Supertrend signals
|
||
'agreement_ratio': 0.67, # Ratio of agreeing indicators
|
||
'supertrend_values': [45123.45, 45234.56, 45345.67], # Current Supertrend values
|
||
'trend_directions': [1, 1, 0], # Trend directions (1=up, -1=down, 0=neutral)
|
||
'timestamp': 1640995200000 # Signal generation timestamp
|
||
}
|
||
```
|
||
|
||
## Performance Characteristics
|
||
|
||
### Strengths
|
||
|
||
1. **Trend Accuracy**: High accuracy in strong trending markets
|
||
2. **False Signal Reduction**: Multiple confirmations reduce whipsaws
|
||
3. **Adaptive Sensitivity**: Different parameters capture various trend speeds
|
||
4. **Risk Management**: Clear trend reversal detection
|
||
5. **Scalability**: Works across different timeframes and markets
|
||
|
||
### Weaknesses
|
||
|
||
1. **Sideways Markets**: May generate false signals in ranging conditions
|
||
2. **Lag**: Multiple confirmations can delay entry/exit points
|
||
3. **Whipsaws**: Vulnerable to rapid trend reversals
|
||
4. **Parameter Sensitivity**: Performance depends on parameter tuning
|
||
|
||
### Optimal Market Conditions
|
||
|
||
- **Trending Markets**: Best performance in clear directional moves
|
||
- **Medium Volatility**: Works well with moderate price swings
|
||
- **Sufficient Volume**: Better signals with adequate trading volume
|
||
- **Clear Trends**: Performs best when trends last longer than indicator periods
|
||
|
||
## Usage Examples
|
||
|
||
### Basic Usage
|
||
```python
|
||
from IncrementalTrader import MetaTrendStrategy, IncTrader
|
||
|
||
# Create strategy with default parameters
|
||
strategy = MetaTrendStrategy("metatrend")
|
||
|
||
# Create trader
|
||
trader = IncTrader(strategy, initial_usd=10000)
|
||
|
||
# Process data
|
||
for timestamp, ohlcv in data_stream:
|
||
signal = trader.process_data_point(timestamp, ohlcv)
|
||
if signal.signal_type != 'HOLD':
|
||
print(f"Signal: {signal.signal_type} (confidence: {signal.confidence:.2f})")
|
||
```
|
||
|
||
### Custom Configuration
|
||
```python
|
||
# Custom parameters for aggressive trading
|
||
strategy = MetaTrendStrategy("metatrend_aggressive", {
|
||
"timeframe": "5min",
|
||
"supertrend_periods": [5, 10, 15],
|
||
"supertrend_multipliers": [1.5, 2.0, 2.5],
|
||
"min_trend_agreement": 0.5
|
||
})
|
||
```
|
||
|
||
### Conservative Configuration
|
||
```python
|
||
# Conservative parameters for stable trends
|
||
strategy = MetaTrendStrategy("metatrend_conservative", {
|
||
"timeframe": "1h",
|
||
"supertrend_periods": [20, 30, 40],
|
||
"supertrend_multipliers": [3.0, 4.0, 5.0],
|
||
"min_trend_agreement": 0.8
|
||
})
|
||
```
|
||
|
||
## Backtesting Results
|
||
|
||
### Performance Metrics (Example)
|
||
```
|
||
Timeframe: 15min
|
||
Period: 2024-01-01 to 2024-12-31
|
||
Initial Capital: $10,000
|
||
|
||
Total Return: 23.45%
|
||
Sharpe Ratio: 1.34
|
||
Max Drawdown: -8.23%
|
||
Win Rate: 58.3%
|
||
Profit Factor: 1.67
|
||
Total Trades: 127
|
||
```
|
||
|
||
### Parameter Sensitivity Analysis
|
||
```
|
||
min_trend_agreement vs Performance:
|
||
0.4: Return 18.2%, Sharpe 1.12, Trades 203
|
||
0.5: Return 20.1%, Sharpe 1.23, Trades 167
|
||
0.6: Return 23.4%, Sharpe 1.34, Trades 127 ← Optimal
|
||
0.7: Return 21.8%, Sharpe 1.41, Trades 89
|
||
0.8: Return 19.3%, Sharpe 1.38, Trades 54
|
||
```
|
||
|
||
## Implementation Notes
|
||
|
||
### Memory Efficiency
|
||
- **Constant Memory**: O(1) memory usage regardless of data history
|
||
- **Efficient Updates**: Each data point processed in O(1) time
|
||
- **State Management**: Minimal state storage for optimal performance
|
||
|
||
### Real-time Capability
|
||
- **Incremental Processing**: Designed for live trading applications
|
||
- **Low Latency**: Minimal processing delay per data point
|
||
- **Stateful Design**: Maintains indicator state between updates
|
||
|
||
### Error Handling
|
||
```python
|
||
def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
|
||
try:
|
||
# Validate input data
|
||
if not self._validate_ohlcv(ohlcv):
|
||
self.logger.warning(f"Invalid OHLCV data: {ohlcv}")
|
||
return IncStrategySignal.HOLD()
|
||
|
||
# Process data
|
||
# ... strategy logic ...
|
||
|
||
except Exception as e:
|
||
self.logger.error(f"Error in MetaTrend strategy: {e}")
|
||
return IncStrategySignal.HOLD()
|
||
```
|
||
|
||
## Advanced Features
|
||
|
||
### Dynamic Parameter Adjustment
|
||
```python
|
||
# Adjust parameters based on market volatility
|
||
def adjust_parameters_for_volatility(self, volatility):
|
||
if volatility > 0.03: # High volatility
|
||
self.params['min_trend_agreement'] = 0.7 # Require more agreement
|
||
elif volatility < 0.01: # Low volatility
|
||
self.params['min_trend_agreement'] = 0.5 # Allow less agreement
|
||
```
|
||
|
||
### Multi-timeframe Analysis
|
||
```python
|
||
# Combine multiple timeframes for better signals
|
||
strategy_5m = MetaTrendStrategy("mt_5m", {"timeframe": "5min"})
|
||
strategy_15m = MetaTrendStrategy("mt_15m", {"timeframe": "15min"})
|
||
strategy_1h = MetaTrendStrategy("mt_1h", {"timeframe": "1h"})
|
||
|
||
# Use higher timeframe for trend direction, lower for entry timing
|
||
```
|
||
|
||
## Troubleshooting
|
||
|
||
### Common Issues
|
||
|
||
1. **No Signals Generated**
|
||
- Check if `min_trend_agreement` is too high
|
||
- Verify sufficient data for indicator warmup
|
||
- Ensure data quality and consistency
|
||
|
||
2. **Too Many False Signals**
|
||
- Increase `min_trend_agreement` threshold
|
||
- Use wider Supertrend multipliers
|
||
- Consider longer timeframes
|
||
|
||
3. **Delayed Signals**
|
||
- Reduce `min_trend_agreement` threshold
|
||
- Use shorter Supertrend periods
|
||
- Consider faster timeframes
|
||
|
||
### Debug Information
|
||
```python
|
||
# Enable debug logging
|
||
strategy.logger.setLevel(logging.DEBUG)
|
||
|
||
# Access internal state
|
||
print(f"Current signals: {strategy.supertrend_collection.get_signals()}")
|
||
print(f"Agreement ratio: {strategy.supertrend_collection.get_agreement_ratio()}")
|
||
print(f"Meta signal: {strategy.supertrend_collection.get_meta_signal()}")
|
||
```
|
||
|
||
---
|
||
|
||
*The MetaTrend Strategy provides robust trend-following capabilities through multi-indicator consensus, making it suitable for various market conditions while maintaining computational efficiency for real-time applications.* |