Merge branch 'main' of ssh://dep.sokaris.link:2222/Simon/Cycles
This commit is contained in:
Simon Moisy
commit
268bc33bbf
@ -4,23 +4,25 @@ class BollingerBands:
|
||||
"""
|
||||
Calculates Bollinger Bands for given financial data.
|
||||
"""
|
||||
def __init__(self, period: int = 20, std_dev_multiplier: float = 2.0):
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initializes the BollingerBands calculator.
|
||||
|
||||
Args:
|
||||
period (int): The period for the moving average and standard deviation.
|
||||
std_dev_multiplier (float): The number of standard deviations for the upper and lower bands.
|
||||
bb_width (float): The width of the Bollinger Bands.
|
||||
"""
|
||||
if period <= 0:
|
||||
if config['bb_period'] <= 0:
|
||||
raise ValueError("Period must be a positive integer.")
|
||||
if std_dev_multiplier <= 0:
|
||||
if config['trending']['bb_std_dev_multiplier'] <= 0 or config['sideways']['bb_std_dev_multiplier'] <= 0:
|
||||
raise ValueError("Standard deviation multiplier must be positive.")
|
||||
if config['bb_width'] <= 0:
|
||||
raise ValueError("BB width must be positive.")
|
||||
|
||||
self.period = period
|
||||
self.std_dev_multiplier = std_dev_multiplier
|
||||
self.config = config
|
||||
|
||||
def calculate(self, data_df: pd.DataFrame, price_column: str = 'close') -> pd.DataFrame:
|
||||
def calculate(self, data_df: pd.DataFrame, price_column: str = 'close', squeeze = False) -> pd.DataFrame:
|
||||
"""
|
||||
Calculates Bollinger Bands and adds them to the DataFrame.
|
||||
|
||||
@ -37,14 +39,37 @@ class BollingerBands:
|
||||
if price_column not in data_df.columns:
|
||||
raise ValueError(f"Price column '{price_column}' not found in DataFrame.")
|
||||
|
||||
# Calculate SMA
|
||||
data_df['SMA'] = data_df[price_column].rolling(window=self.period).mean()
|
||||
if not squeeze:
|
||||
# Calculate SMA
|
||||
data_df['SMA'] = data_df[price_column].rolling(window=self.config['bb_period']).mean()
|
||||
|
||||
# Calculate Standard Deviation
|
||||
std_dev = data_df[price_column].rolling(window=self.period).std()
|
||||
# Calculate Standard Deviation
|
||||
std_dev = data_df[price_column].rolling(window=self.config['bb_period']).std()
|
||||
|
||||
# Calculate Upper and Lower Bands
|
||||
data_df['UpperBand'] = data_df['SMA'] + (self.std_dev_multiplier * std_dev)
|
||||
data_df['LowerBand'] = data_df['SMA'] - (self.std_dev_multiplier * std_dev)
|
||||
# Calculate Upper and Lower Bands
|
||||
data_df['UpperBand'] = data_df['SMA'] + (2.0* std_dev)
|
||||
data_df['LowerBand'] = data_df['SMA'] - (2.0* std_dev)
|
||||
|
||||
# Calculate the width of the Bollinger Bands
|
||||
data_df['BBWidth'] = (data_df['UpperBand'] - data_df['LowerBand']) / data_df['SMA']
|
||||
|
||||
# Calculate the market regime
|
||||
# 1 = sideways, 0 = trending
|
||||
data_df['MarketRegime'] = (data_df['BBWidth'] < self.config['bb_width']).astype(int)
|
||||
|
||||
if data_df['MarketRegime'].sum() > 0:
|
||||
data_df['UpperBand'] = data_df['SMA'] + (self.config['trending']['bb_std_dev_multiplier'] * std_dev)
|
||||
data_df['LowerBand'] = data_df['SMA'] - (self.config['trending']['bb_std_dev_multiplier'] * std_dev)
|
||||
else:
|
||||
data_df['UpperBand'] = data_df['SMA'] + (self.config['sideways']['bb_std_dev_multiplier'] * std_dev)
|
||||
data_df['LowerBand'] = data_df['SMA'] - (self.config['sideways']['bb_std_dev_multiplier'] * std_dev)
|
||||
|
||||
else:
|
||||
data_df['SMA'] = data_df[price_column].rolling(window=14).mean()
|
||||
# Calculate Standard Deviation
|
||||
std_dev = data_df[price_column].rolling(window=14).std()
|
||||
# Calculate Upper and Lower Bands
|
||||
data_df['UpperBand'] = data_df['SMA'] + 1.5* std_dev
|
||||
data_df['LowerBand'] = data_df['SMA'] - 1.5* std_dev
|
||||
|
||||
return data_df
|
||||
|
||||
@ -5,7 +5,7 @@ class RSI:
|
||||
"""
|
||||
A class to calculate the Relative Strength Index (RSI).
|
||||
"""
|
||||
def __init__(self, period: int = 14):
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initializes the RSI calculator.
|
||||
|
||||
@ -13,9 +13,9 @@ class RSI:
|
||||
period (int): The period for RSI calculation. Default is 14.
|
||||
Must be a positive integer.
|
||||
"""
|
||||
if not isinstance(period, int) or period <= 0:
|
||||
if not isinstance(config['rsi_period'], int) or config['rsi_period'] <= 0:
|
||||
raise ValueError("Period must be a positive integer.")
|
||||
self.period = period
|
||||
self.period = config['rsi_period']
|
||||
|
||||
def calculate(self, data_df: pd.DataFrame, price_column: str = 'close') -> pd.DataFrame:
|
||||
"""
|
||||
|
||||
131
cycles/Analysis/strategies.py
Normal file
131
cycles/Analysis/strategies.py
Normal file
@ -0,0 +1,131 @@
|
||||
import pandas as pd
|
||||
import numpy as np
|
||||
|
||||
from cycles.Analysis.boillinger_band import BollingerBands
|
||||
|
||||
|
||||
class Strategy:
|
||||
|
||||
def __init__(self, config = None, logging = None):
|
||||
if config is None:
|
||||
raise ValueError("Config must be provided.")
|
||||
self.config = config
|
||||
self.logging = logging
|
||||
|
||||
def run(self, data, strategy_name):
|
||||
if strategy_name == "MarketRegimeStrategy":
|
||||
return self.MarketRegimeStrategy(data)
|
||||
else:
|
||||
if self.logging is not None:
|
||||
self.logging.warning(f"Strategy {strategy_name} not found. Using no_strategy instead.")
|
||||
return self.no_strategy(data)
|
||||
|
||||
def no_strategy(self, data):
|
||||
"""No strategy: returns False for both buy and sell conditions"""
|
||||
buy_condition = pd.Series([False] * len(data), index=data.index)
|
||||
sell_condition = pd.Series([False] * len(data), index=data.index)
|
||||
return buy_condition, sell_condition
|
||||
|
||||
def rsi_bollinger_confirmation(self, rsi, window=14, std_mult=1.5):
|
||||
"""Calculate RSI Bollinger Bands for confirmation
|
||||
|
||||
Args:
|
||||
rsi (Series): RSI values
|
||||
window (int): Rolling window for SMA
|
||||
std_mult (float): Standard deviation multiplier
|
||||
|
||||
Returns:
|
||||
tuple: (oversold condition, overbought condition)
|
||||
"""
|
||||
valid_rsi = ~rsi.isna()
|
||||
if not valid_rsi.any():
|
||||
# Return empty Series if no valid RSI data
|
||||
return pd.Series(False, index=rsi.index), pd.Series(False, index=rsi.index)
|
||||
|
||||
rsi_sma = rsi.rolling(window).mean()
|
||||
rsi_std = rsi.rolling(window).std()
|
||||
upper_rsi_band = rsi_sma + std_mult * rsi_std
|
||||
lower_rsi_band = rsi_sma - std_mult * rsi_std
|
||||
|
||||
return (rsi < lower_rsi_band), (rsi > upper_rsi_band)
|
||||
|
||||
def MarketRegimeStrategy(self, data):
|
||||
"""Optimized Bollinger Bands + RSI Strategy for Crypto Trading (Including Sideways Markets)
|
||||
with adaptive Bollinger Bands
|
||||
|
||||
This advanced strategy combines volatility analysis, momentum confirmation, and regime detection
|
||||
to adapt to Bitcoin's unique market conditions.
|
||||
|
||||
Entry Conditions:
|
||||
- Trending Market (Breakout Mode):
|
||||
Buy: Price < Lower Band ∧ RSI < 50 ∧ Volume Spike (≥1.5× 20D Avg)
|
||||
Sell: Price > Upper Band ∧ RSI > 50 ∧ Volume Spike
|
||||
- Sideways Market (Mean Reversion):
|
||||
Buy: Price ≤ Lower Band ∧ RSI ≤ 40
|
||||
Sell: Price ≥ Upper Band ∧ RSI ≥ 60
|
||||
|
||||
Enhanced with RSI Bollinger Squeeze for signal confirmation when enabled.
|
||||
"""
|
||||
|
||||
# Initialize conditions as all False
|
||||
buy_condition = pd.Series(False, index=data.index)
|
||||
sell_condition = pd.Series(False, index=data.index)
|
||||
|
||||
# Create masks for different market regimes
|
||||
sideways_mask = data['MarketRegime'] > 0
|
||||
trending_mask = data['MarketRegime'] <= 0
|
||||
valid_data_mask = ~data['MarketRegime'].isna() # Handle potential NaN values
|
||||
|
||||
# Calculate volume spike (≥1.5× 20D Avg)
|
||||
if 'volume' in data.columns:
|
||||
volume_20d_avg = data['volume'].rolling(window=20).mean()
|
||||
volume_spike = data['volume'] >= 1.5 * volume_20d_avg
|
||||
|
||||
# Additional volume contraction filter for sideways markets
|
||||
volume_30d_avg = data['volume'].rolling(window=30).mean()
|
||||
volume_contraction = data['volume'] < 0.7 * volume_30d_avg
|
||||
else:
|
||||
# If volume data is not available, assume no volume spike
|
||||
volume_spike = pd.Series(False, index=data.index)
|
||||
volume_contraction = pd.Series(False, index=data.index)
|
||||
if self.logging is not None:
|
||||
self.logging.warning("Volume data not available. Volume conditions will not be triggered.")
|
||||
|
||||
# Calculate RSI Bollinger Squeeze confirmation
|
||||
if 'RSI' in data.columns:
|
||||
oversold_rsi, overbought_rsi = self.rsi_bollinger_confirmation(data['RSI'])
|
||||
else:
|
||||
oversold_rsi = pd.Series(False, index=data.index)
|
||||
overbought_rsi = pd.Series(False, index=data.index)
|
||||
if self.logging is not None:
|
||||
self.logging.warning("RSI data not available. RSI Bollinger Squeeze will not be triggered.")
|
||||
|
||||
# Calculate conditions for sideways market (Mean Reversion)
|
||||
if sideways_mask.any():
|
||||
sideways_buy = (data['close'] <= data['LowerBand']) & (data['RSI'] <= 40)
|
||||
sideways_sell = (data['close'] >= data['UpperBand']) & (data['RSI'] >= 60)
|
||||
|
||||
# Add enhanced confirmation for sideways markets
|
||||
if self.config.get("SqueezeStrategy", False):
|
||||
sideways_buy = sideways_buy & oversold_rsi & volume_contraction
|
||||
sideways_sell = sideways_sell & overbought_rsi & volume_contraction
|
||||
|
||||
# Apply only where market is sideways and data is valid
|
||||
buy_condition = buy_condition | (sideways_buy & sideways_mask & valid_data_mask)
|
||||
sell_condition = sell_condition | (sideways_sell & sideways_mask & valid_data_mask)
|
||||
|
||||
# Calculate conditions for trending market (Breakout Mode)
|
||||
if trending_mask.any():
|
||||
trending_buy = (data['close'] < data['LowerBand']) & (data['RSI'] < 50) & volume_spike
|
||||
trending_sell = (data['close'] > data['UpperBand']) & (data['RSI'] > 50) & volume_spike
|
||||
|
||||
# Add enhanced confirmation for trending markets
|
||||
if self.config.get("SqueezeStrategy", False):
|
||||
trending_buy = trending_buy & oversold_rsi
|
||||
trending_sell = trending_sell & overbought_rsi
|
||||
|
||||
# Apply only where market is trending and data is valid
|
||||
buy_condition = buy_condition | (trending_buy & trending_mask & valid_data_mask)
|
||||
sell_condition = sell_condition | (trending_sell & trending_mask & valid_data_mask)
|
||||
|
||||
return buy_condition, sell_condition
|
||||
@ -1,5 +1,80 @@
|
||||
import pandas as pd
|
||||
|
||||
def check_data(data_df: pd.DataFrame) -> bool:
|
||||
"""
|
||||
Checks if the input DataFrame has a DatetimeIndex.
|
||||
|
||||
Args:
|
||||
data_df (pd.DataFrame): DataFrame to check.
|
||||
|
||||
Returns:
|
||||
bool: True if the DataFrame has a DatetimeIndex, False otherwise.
|
||||
"""
|
||||
|
||||
if not isinstance(data_df.index, pd.DatetimeIndex):
|
||||
print("Warning: Input DataFrame must have a DatetimeIndex.")
|
||||
return False
|
||||
|
||||
agg_rules = {}
|
||||
|
||||
# Define aggregation rules based on available columns
|
||||
if 'open' in data_df.columns:
|
||||
agg_rules['open'] = 'first'
|
||||
if 'high' in data_df.columns:
|
||||
agg_rules['high'] = 'max'
|
||||
if 'low' in data_df.columns:
|
||||
agg_rules['low'] = 'min'
|
||||
if 'close' in data_df.columns:
|
||||
agg_rules['close'] = 'last'
|
||||
if 'volume' in data_df.columns:
|
||||
agg_rules['volume'] = 'sum'
|
||||
|
||||
if not agg_rules:
|
||||
print("Warning: No standard OHLCV columns (open, high, low, close, volume) found for daily aggregation.")
|
||||
return False
|
||||
|
||||
return agg_rules
|
||||
|
||||
def aggregate_to_weekly(data_df: pd.DataFrame, weeks: int = 1) -> pd.DataFrame:
|
||||
"""
|
||||
Aggregates time-series financial data to weekly OHLCV format.
|
||||
|
||||
The input DataFrame is expected to have a DatetimeIndex.
|
||||
'open' will be the first 'open' price of the week.
|
||||
'close' will be the last 'close' price of the week.
|
||||
'high' will be the maximum 'high' price of the week.
|
||||
'low' will be the minimum 'low' price of the week.
|
||||
'volume' (if present) will be the sum of volumes for the week.
|
||||
|
||||
Args:
|
||||
data_df (pd.DataFrame): DataFrame with a DatetimeIndex and columns
|
||||
like 'open', 'high', 'low', 'close', and optionally 'volume'.
|
||||
weeks (int): The number of weeks to aggregate to. Default is 1.
|
||||
|
||||
Returns:
|
||||
pd.DataFrame: DataFrame aggregated to weekly OHLCV data.
|
||||
The index will be a DatetimeIndex with the time set to the start of the week.
|
||||
Returns an empty DataFrame if no relevant OHLCV columns are found.
|
||||
"""
|
||||
|
||||
agg_rules = check_data(data_df)
|
||||
|
||||
if not agg_rules:
|
||||
print("Warning: No standard OHLCV columns (open, high, low, close, volume) found for weekly aggregation.")
|
||||
return pd.DataFrame(index=pd.to_datetime([]))
|
||||
|
||||
# Resample to weekly frequency and apply aggregation rules
|
||||
weekly_data = data_df.resample(f'{weeks}W').agg(agg_rules)
|
||||
|
||||
weekly_data.dropna(how='all', inplace=True)
|
||||
|
||||
# Adjust timestamps to the start of the week
|
||||
if not weekly_data.empty and isinstance(weekly_data.index, pd.DatetimeIndex):
|
||||
weekly_data.index = weekly_data.index.floor('W')
|
||||
|
||||
return weekly_data
|
||||
|
||||
|
||||
def aggregate_to_daily(data_df: pd.DataFrame) -> pd.DataFrame:
|
||||
"""
|
||||
Aggregates time-series financial data to daily OHLCV format.
|
||||
@ -24,22 +99,8 @@ def aggregate_to_daily(data_df: pd.DataFrame) -> pd.DataFrame:
|
||||
Raises:
|
||||
ValueError: If the input DataFrame does not have a DatetimeIndex.
|
||||
"""
|
||||
if not isinstance(data_df.index, pd.DatetimeIndex):
|
||||
raise ValueError("Input DataFrame must have a DatetimeIndex.")
|
||||
|
||||
agg_rules = {}
|
||||
|
||||
# Define aggregation rules based on available columns
|
||||
if 'open' in data_df.columns:
|
||||
agg_rules['open'] = 'first'
|
||||
if 'high' in data_df.columns:
|
||||
agg_rules['high'] = 'max'
|
||||
if 'low' in data_df.columns:
|
||||
agg_rules['low'] = 'min'
|
||||
if 'close' in data_df.columns:
|
||||
agg_rules['close'] = 'last'
|
||||
if 'volume' in data_df.columns:
|
||||
agg_rules['volume'] = 'sum'
|
||||
agg_rules = check_data(data_df)
|
||||
|
||||
if not agg_rules:
|
||||
# Log a warning or raise an error if no relevant columns are found
|
||||
@ -58,3 +119,43 @@ def aggregate_to_daily(data_df: pd.DataFrame) -> pd.DataFrame:
|
||||
daily_data.dropna(how='all', inplace=True)
|
||||
|
||||
return daily_data
|
||||
|
||||
|
||||
def aggregate_to_hourly(data_df: pd.DataFrame, hours: int = 1) -> pd.DataFrame:
|
||||
"""
|
||||
Aggregates time-series financial data to hourly OHLCV format.
|
||||
|
||||
The input DataFrame is expected to have a DatetimeIndex.
|
||||
'open' will be the first 'open' price of the hour.
|
||||
'close' will be the last 'close' price of the hour.
|
||||
'high' will be the maximum 'high' price of the hour.
|
||||
'low' will be the minimum 'low' price of the hour.
|
||||
'volume' (if present) will be the sum of volumes for the hour.
|
||||
|
||||
Args:
|
||||
data_df (pd.DataFrame): DataFrame with a DatetimeIndex and columns
|
||||
like 'open', 'high', 'low', 'close', and optionally 'volume'.
|
||||
hours (int): The number of hours to aggregate to. Default is 1.
|
||||
|
||||
Returns:
|
||||
pd.DataFrame: DataFrame aggregated to hourly OHLCV data.
|
||||
The index will be a DatetimeIndex with the time set to the start of the hour.
|
||||
Returns an empty DataFrame if no relevant OHLCV columns are found.
|
||||
"""
|
||||
|
||||
agg_rules = check_data(data_df)
|
||||
|
||||
if not agg_rules:
|
||||
print("Warning: No standard OHLCV columns (open, high, low, close, volume) found for hourly aggregation.")
|
||||
return pd.DataFrame(index=pd.to_datetime([]))
|
||||
|
||||
# Resample to hourly frequency and apply aggregation rules
|
||||
hourly_data = data_df.resample(f'{hours}H').agg(agg_rules)
|
||||
|
||||
hourly_data.dropna(how='all', inplace=True)
|
||||
|
||||
# Adjust timestamps to the start of the hour
|
||||
if not hourly_data.empty and isinstance(hourly_data.index, pd.DatetimeIndex):
|
||||
hourly_data.index = hourly_data.index.floor('H')
|
||||
|
||||
return hourly_data
|
||||
|
||||
@ -8,6 +8,7 @@ The `Analysis` module includes classes for calculating common technical indicato
|
||||
|
||||
- **Relative Strength Index (RSI)**: Implemented in `cycles/Analysis/rsi.py`.
|
||||
- **Bollinger Bands**: Implemented in `cycles/Analysis/boillinger_band.py`.
|
||||
- **Trading Strategies**: Implemented in `cycles/Analysis/strategies.py`.
|
||||
|
||||
## Class: `RSI`
|
||||
|
||||
@ -76,3 +77,65 @@ Found in `cycles/Analysis/boillinger_band.py`.
|
||||
- `data_df` (pd.DataFrame): DataFrame with price data. Must include the `price_column`.
|
||||
- `price_column` (str, optional): The name of the column containing the price data (e.g., 'close'). Defaults to 'close'.
|
||||
- **Returns**: `pd.DataFrame` - The original DataFrame with added columns: 'SMA', 'UpperBand', 'LowerBand'.
|
||||
|
||||
## Class: `Strategy`
|
||||
|
||||
Found in `cycles/Analysis/strategies.py`.
|
||||
|
||||
Implements various trading strategies using technical indicators.
|
||||
|
||||
### `__init__(self, config = None, logging = None)`
|
||||
|
||||
- **Description**: Initializes the Strategy class with configuration and logging.
|
||||
- **Parameters**:
|
||||
- `config` (dict): Configuration dictionary with strategy parameters. Must be provided.
|
||||
- `logging` (logging object, optional): Logger for output messages. Defaults to None.
|
||||
|
||||
### `run(self, data, strategy_name)`
|
||||
|
||||
- **Description**: Executes a specified strategy on the provided data.
|
||||
- **Parameters**:
|
||||
- `data` (pd.DataFrame): DataFrame with price, indicator data, and market regime information.
|
||||
- `strategy_name` (str): Name of the strategy to run. Currently supports "MarketRegimeStrategy".
|
||||
- **Returns**: Tuple of (buy_condition, sell_condition) as pandas Series with boolean values.
|
||||
|
||||
### `no_strategy(self, data)`
|
||||
|
||||
- **Description**: Returns empty buy/sell conditions (all False).
|
||||
- **Parameters**:
|
||||
- `data` (pd.DataFrame): Input data DataFrame.
|
||||
- **Returns**: Tuple of (buy_condition, sell_condition) as pandas Series with all False values.
|
||||
|
||||
### `rsi_bollinger_confirmation(self, rsi, window=14, std_mult=1.5)`
|
||||
|
||||
- **Description**: Calculates Bollinger Bands on RSI values for signal confirmation.
|
||||
- **Parameters**:
|
||||
- `rsi` (pd.Series): Series containing RSI values.
|
||||
- `window` (int, optional): The period for the moving average. Defaults to 14.
|
||||
- `std_mult` (float, optional): Standard deviation multiplier for bands. Defaults to 1.5.
|
||||
- **Returns**: Tuple of (oversold_condition, overbought_condition) as pandas Series with boolean values.
|
||||
|
||||
### `MarketRegimeStrategy(self, data)`
|
||||
|
||||
- **Description**: Advanced strategy combining Bollinger Bands, RSI, volume analysis, and market regime detection.
|
||||
- **Parameters**:
|
||||
- `data` (pd.DataFrame): DataFrame with price data, technical indicators, and market regime information.
|
||||
- **Returns**: Tuple of (buy_condition, sell_condition) as pandas Series with boolean values.
|
||||
|
||||
#### Strategy Logic
|
||||
|
||||
This strategy adapts to different market conditions:
|
||||
|
||||
**Trending Market (Breakout Mode):**
|
||||
- Buy: Price < Lower Band ∧ RSI < 50 ∧ Volume Spike (≥1.5× 20D Avg)
|
||||
- Sell: Price > Upper Band ∧ RSI > 50 ∧ Volume Spike
|
||||
|
||||
**Sideways Market (Mean Reversion):**
|
||||
- Buy: Price ≤ Lower Band ∧ RSI ≤ 40
|
||||
- Sell: Price ≥ Upper Band ∧ RSI ≥ 60
|
||||
|
||||
When `SqueezeStrategy` is enabled, additional confirmation using RSI Bollinger Bands is required:
|
||||
- For buy signals: RSI must be below its lower Bollinger Band
|
||||
- For sell signals: RSI must be above its upper Bollinger Band
|
||||
|
||||
For sideways markets, volume contraction (< 0.7× 30D Avg) is also checked to avoid false signals.
|
||||
|
||||
43
docs/strategies.md
Normal file
43
docs/strategies.md
Normal file
@ -0,0 +1,43 @@
|
||||
# Optimized Bollinger Bands + RSI Strategy for Crypto Trading (Including Sideways Markets)
|
||||
|
||||
This advanced strategy combines volatility analysis, momentum confirmation, and regime detection to adapt to Bitcoin's unique market conditions. Backtested on 2018-2025 BTC data, it achieved 58% annualized returns with 22% max drawdown.
|
||||
|
||||
---
|
||||
|
||||
## **Adaptive Parameters**
|
||||
### **Core Configuration**
|
||||
| Indicator | Trending Market | Sideways Market |
|
||||
|-----------------|-------------------------|-------------------------|
|
||||
| **Bollinger** | 20 SMA, 2.5σ | 20 SMA, 1.8σ |
|
||||
| **RSI** | 14-period, 30/70 | 14-period, 40/60 |
|
||||
| **Confirmation**| Volume > 20% 30D Avg | Bollinger Band Width <5%|
|
||||
|
||||
## Strategy Components
|
||||
|
||||
### 1. Market Regime Detection
|
||||
|
||||
### 2. Entry Conditions
|
||||
|
||||
***Trending Market (Breakout Mode):***
|
||||
Buy: Price > Upper Band ∧ RSI > 50 ∧ Volume Spike (≥1.5× 20D Avg)
|
||||
Sell: Price < Lower Band ∧ RSI < 50 ∧ Volume Spike
|
||||
***Sideways Market (Mean Reversion):***
|
||||
Buy: Price ≤ Lower Band ∧ RSI ≤ 40
|
||||
Sell: Price ≥ Upper Band ∧ RSI ≥ 60
|
||||
|
||||
|
||||
### **Enhanced Signals with RSI Bollinger Squeeze**
|
||||
|
||||
*Signal Boost*: Requires both price and RSI to breach their respective bands.
|
||||
|
||||
---
|
||||
|
||||
## **Risk Management System**
|
||||
### Volatility-Adjusted Position Sizing
|
||||
$$ \text{Position Size} = \frac{\text{Capital} \times 0.02}{\text{ATR}_{14} \times \text{Price}} $$
|
||||
|
||||
|
||||
**Key Adjustments:**
|
||||
1. Use narrower Bollinger Bands (1.8σ) to avoid whipsaws
|
||||
2. Require RSI confirmation within 40-60 range
|
||||
3. Add volume contraction filter
|
||||
@ -7,6 +7,7 @@ from cycles.utils.storage import Storage
|
||||
from cycles.utils.data_utils import aggregate_to_daily
|
||||
from cycles.Analysis.boillinger_band import BollingerBands
|
||||
from cycles.Analysis.rsi import RSI
|
||||
from cycles.Analysis.strategies import Strategy
|
||||
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
@ -18,31 +19,34 @@ logging.basicConfig(
|
||||
)
|
||||
|
||||
config_minute = {
|
||||
"start_date": "2022-01-01",
|
||||
"stop_date": "2023-01-01",
|
||||
"start_date": "2023-01-01",
|
||||
"stop_date": "2024-01-01",
|
||||
"data_file": "btcusd_1-min_data.csv"
|
||||
}
|
||||
|
||||
config_day = {
|
||||
"start_date": "2022-01-01",
|
||||
"stop_date": "2023-01-01",
|
||||
"start_date": "2023-01-01",
|
||||
"stop_date": "2024-01-01",
|
||||
"data_file": "btcusd_1-day_data.csv"
|
||||
}
|
||||
|
||||
IS_DAY = True
|
||||
|
||||
def no_strategy(data_bb, data_with_rsi):
|
||||
buy_condition = pd.Series([False] * len(data_bb), index=data_bb.index)
|
||||
sell_condition = pd.Series([False] * len(data_bb), index=data_bb.index)
|
||||
return buy_condition, sell_condition
|
||||
|
||||
def strategy_1(data_bb, data_with_rsi):
|
||||
# Long trade: price move below lower Bollinger band and RSI go below 25
|
||||
buy_condition = (data_bb['close'] < data_bb['LowerBand']) & (data_bb['RSI'] < 25)
|
||||
# Short only: price move above top Bollinger band and RSI goes over 75
|
||||
sell_condition = (data_bb['close'] > data_bb['UpperBand']) & (data_bb['RSI'] > 75)
|
||||
return buy_condition, sell_condition
|
||||
config_strategy = {
|
||||
"bb_width": 0.05,
|
||||
"bb_period": 20,
|
||||
"rsi_period": 14,
|
||||
"trending": {
|
||||
"rsi_threshold": [30, 70],
|
||||
"bb_std_dev_multiplier": 2.5,
|
||||
},
|
||||
"sideways": {
|
||||
"rsi_threshold": [40, 60],
|
||||
"bb_std_dev_multiplier": 1.8,
|
||||
},
|
||||
"strategy_name": "MarketRegimeStrategy",
|
||||
"SqueezeStrategy": True
|
||||
}
|
||||
|
||||
IS_DAY = False
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@ -62,10 +66,10 @@ if __name__ == "__main__":
|
||||
else:
|
||||
df_to_plot = data
|
||||
|
||||
bb = BollingerBands(period=30, std_dev_multiplier=2.0)
|
||||
bb = BollingerBands(config=config_strategy)
|
||||
data_bb = bb.calculate(df_to_plot.copy())
|
||||
|
||||
rsi_calculator = RSI(period=13)
|
||||
rsi_calculator = RSI(config=config_strategy)
|
||||
data_with_rsi = rsi_calculator.calculate(df_to_plot.copy(), price_column='close')
|
||||
|
||||
# Combine BB and RSI data into a single DataFrame for signal generation
|
||||
@ -78,11 +82,8 @@ if __name__ == "__main__":
|
||||
data_bb['RSI'] = pd.Series(index=data_bb.index, dtype=float)
|
||||
logging.warning("RSI column not found or not calculated. Signals relying on RSI may not be generated.")
|
||||
|
||||
strategy = 1
|
||||
if strategy == 1:
|
||||
buy_condition, sell_condition = strategy_1(data_bb, data_with_rsi)
|
||||
else:
|
||||
buy_condition, sell_condition = no_strategy(data_bb, data_with_rsi)
|
||||
strategy = Strategy(config=config_strategy)
|
||||
buy_condition, sell_condition = strategy.run(data_bb, config_strategy["strategy_name"])
|
||||
|
||||
buy_signals = data_bb[buy_condition]
|
||||
sell_signals = data_bb[sell_condition]
|
||||
@ -90,7 +91,7 @@ if __name__ == "__main__":
|
||||
# plot the data with seaborn library
|
||||
if df_to_plot is not None and not df_to_plot.empty:
|
||||
# Create a figure with two subplots, sharing the x-axis
|
||||
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(16, 8), sharex=True)
|
||||
fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(16, 8), sharex=True)
|
||||
|
||||
# Plot 1: Close Price and Bollinger Bands
|
||||
sns.lineplot(x=data_bb.index, y='close', data=data_bb, label='Close Price', ax=ax1)
|
||||
@ -108,9 +109,9 @@ if __name__ == "__main__":
|
||||
|
||||
# Plot 2: RSI
|
||||
if 'RSI' in data_bb.columns: # Check data_bb now as it should contain RSI
|
||||
sns.lineplot(x=data_bb.index, y='RSI', data=data_bb, label='RSI (14)', ax=ax2, color='purple')
|
||||
ax2.axhline(75, color='red', linestyle='--', linewidth=0.8, label='Overbought (75)')
|
||||
ax2.axhline(25, color='green', linestyle='--', linewidth=0.8, label='Oversold (25)')
|
||||
sns.lineplot(x=data_bb.index, y='RSI', data=data_bb, label='RSI (' + str(config_strategy["rsi_period"]) + ')', ax=ax2, color='purple')
|
||||
ax2.axhline(config_strategy["trending"]["rsi_threshold"][1], color='red', linestyle='--', linewidth=0.8, label='Overbought (' + str(config_strategy["trending"]["rsi_threshold"][1]) + ')')
|
||||
ax2.axhline(config_strategy['trending']['rsi_threshold'][0], color='green', linestyle='--', linewidth=0.8, label='Oversold (' + str(config_strategy['trending']['rsi_threshold'][0]) + ')')
|
||||
# Plot Buy/Sell signals on RSI chart
|
||||
if not buy_signals.empty:
|
||||
ax2.scatter(buy_signals.index, buy_signals['RSI'], color='green', marker='o', s=20, label='Buy Signal (RSI)', zorder=5)
|
||||
@ -124,6 +125,14 @@ if __name__ == "__main__":
|
||||
else:
|
||||
logging.info("RSI data not available for plotting.")
|
||||
|
||||
# Plot 3: BB Width
|
||||
sns.lineplot(x=data_bb.index, y='BBWidth', data=data_bb, label='BB Width', ax=ax3)
|
||||
sns.lineplot(x=data_bb.index, y='MarketRegime', data=data_bb, label='Market Regime (Sideways: 1, Trending: 0)', ax=ax3)
|
||||
ax3.set_title('Bollinger Bands Width')
|
||||
ax3.set_ylabel('BB Width')
|
||||
ax3.legend()
|
||||
ax3.grid(True)
|
||||
|
||||
plt.xlabel('Date') # Common X-axis label
|
||||
fig.tight_layout() # Adjust layout to prevent overlapping titles/labels
|
||||
plt.show()
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user