189 lines
5.0 KiB
Markdown
189 lines
5.0 KiB
Markdown
# Strategy Development Guide
|
|
|
|
Trading strategies in Dexorder define entry/exit rules and position management logic.
|
|
|
|
## Strategy Structure
|
|
|
|
```python
|
|
class Strategy:
|
|
def __init__(self, **params):
|
|
"""Initialize strategy with parameters"""
|
|
self.params = params
|
|
|
|
def generate_signals(self, df):
|
|
"""
|
|
Generate trading signals
|
|
|
|
Args:
|
|
df: DataFrame with OHLCV + indicator columns
|
|
|
|
Returns:
|
|
DataFrame with 'signal' column:
|
|
1 = long entry
|
|
-1 = short entry
|
|
0 = no action
|
|
"""
|
|
pass
|
|
|
|
def calculate_position_size(self, capital, price, risk_pct):
|
|
"""Calculate position size based on risk"""
|
|
pass
|
|
|
|
def get_stop_loss(self, entry_price, direction):
|
|
"""Calculate stop loss level"""
|
|
pass
|
|
|
|
def get_take_profit(self, entry_price, direction):
|
|
"""Calculate take profit level"""
|
|
pass
|
|
```
|
|
|
|
## Example: Simple Moving Average Crossover
|
|
|
|
```python
|
|
class SMACrossoverStrategy:
|
|
def __init__(self, fast_period=20, slow_period=50, risk_pct=0.02):
|
|
self.fast_period = fast_period
|
|
self.slow_period = slow_period
|
|
self.risk_pct = risk_pct
|
|
|
|
def generate_signals(self, df):
|
|
# Calculate moving averages
|
|
df['sma_fast'] = df['close'].rolling(self.fast_period).mean()
|
|
df['sma_slow'] = df['close'].rolling(self.slow_period).mean()
|
|
|
|
# Generate signals
|
|
df['signal'] = 0
|
|
|
|
# Long when fast crosses above slow
|
|
df.loc[
|
|
(df['sma_fast'] > df['sma_slow']) &
|
|
(df['sma_fast'].shift(1) <= df['sma_slow'].shift(1)),
|
|
'signal'
|
|
] = 1
|
|
|
|
# Short when fast crosses below slow
|
|
df.loc[
|
|
(df['sma_fast'] < df['sma_slow']) &
|
|
(df['sma_fast'].shift(1) >= df['sma_slow'].shift(1)),
|
|
'signal'
|
|
] = -1
|
|
|
|
return df
|
|
|
|
def calculate_position_size(self, capital, price, atr):
|
|
# Risk-based position sizing
|
|
risk_amount = capital * self.risk_pct
|
|
stop_distance = 2 * atr
|
|
position_size = risk_amount / stop_distance
|
|
return position_size
|
|
|
|
def get_stop_loss(self, entry_price, direction, atr):
|
|
if direction == 1: # Long
|
|
return entry_price - (2 * atr)
|
|
else: # Short
|
|
return entry_price + (2 * atr)
|
|
|
|
def get_take_profit(self, entry_price, direction, atr):
|
|
if direction == 1: # Long
|
|
return entry_price + (4 * atr) # 2:1 risk/reward
|
|
else: # Short
|
|
return entry_price - (4 * atr)
|
|
```
|
|
|
|
## Strategy Components
|
|
|
|
### Signal Generation
|
|
Entry conditions based on:
|
|
- Indicator crossovers
|
|
- Price patterns
|
|
- Volume confirmation
|
|
- Multiple timeframe confluence
|
|
|
|
### Risk Management
|
|
Essential elements:
|
|
- **Position Sizing**: Based on account risk percentage
|
|
- **Stop Losses**: ATR-based or support/resistance
|
|
- **Take Profits**: Multiple targets or trailing stops
|
|
- **Max Positions**: Limit concurrent trades
|
|
|
|
### Filters
|
|
Reduce false signals:
|
|
- **Trend Filter**: Only trade with the trend
|
|
- **Volatility Filter**: Avoid low volatility periods
|
|
- **Time Filter**: Specific trading hours
|
|
- **Volume Filter**: Minimum volume requirements
|
|
|
|
### Exit Rules
|
|
Multiple exit types:
|
|
- **Stop Loss**: Protect capital
|
|
- **Take Profit**: Lock in gains
|
|
- **Trailing Stop**: Follow profitable moves
|
|
- **Time Exit**: Close at end of period
|
|
- **Signal Exit**: Opposite signal
|
|
|
|
## Backtesting Considerations
|
|
|
|
### Data Quality
|
|
- Use clean, validated data
|
|
- Handle missing data appropriately
|
|
- Account for survivorship bias
|
|
- Include realistic spreads and slippage
|
|
|
|
### Performance Metrics
|
|
Track key metrics:
|
|
- **Total Return**: Cumulative profit/loss
|
|
- **Sharpe Ratio**: Risk-adjusted returns
|
|
- **Max Drawdown**: Largest peak-to-trough decline
|
|
- **Win Rate**: Percentage of profitable trades
|
|
- **Profit Factor**: Gross profit / gross loss
|
|
- **Expectancy**: Average $ per trade
|
|
|
|
### Validation
|
|
Prevent overfitting:
|
|
- **Train/Test Split**: 70/30 or 60/40
|
|
- **Walk-Forward**: Rolling windows
|
|
- **Out-of-Sample**: Test on recent unseen data
|
|
- **Monte Carlo**: Randomize trade order
|
|
- **Paper Trading**: Live validation
|
|
|
|
## Common Strategy Types
|
|
|
|
### Trend Following
|
|
Follow sustained price movements:
|
|
- Moving average crossovers
|
|
- Breakout strategies
|
|
- Trend channels
|
|
- Works best in trending markets
|
|
|
|
### Mean Reversion
|
|
Profit from price returning to average:
|
|
- Bollinger Band reversals
|
|
- RSI extremes
|
|
- Statistical arbitrage
|
|
- Works best in ranging markets
|
|
|
|
### Momentum
|
|
Trade in direction of strong moves:
|
|
- Relative strength
|
|
- Price acceleration
|
|
- Volume surges
|
|
- Breakout confirmation
|
|
|
|
### Arbitrage
|
|
Exploit price discrepancies:
|
|
- Cross-exchange spreads
|
|
- Funding rate arbitrage
|
|
- Statistical pairs trading
|
|
- Requires low latency
|
|
|
|
## Integration with Platform
|
|
|
|
Store strategies in your git repository under `strategies/` directory.
|
|
|
|
Test using the backtesting tools provided by the platform.
|
|
|
|
Deploy live strategies through the execution engine with proper risk controls.
|
|
|
|
Monitor performance and adjust parameters as market conditions change.
|