335 lines
13 KiB
Python
335 lines
13 KiB
Python
import numpy as np
|
||
import talib
|
||
from scipy.signal import stft
|
||
from datetime import timedelta
|
||
from typing import Optional, Any, List
|
||
|
||
from src.core_data import Bar, Order
|
||
from src.indicators.base_indicators import Indicator
|
||
from src.indicators.indicators import Empty
|
||
from src.strategies.base_strategy import Strategy
|
||
|
||
|
||
class SpectralTrendStrategy(Strategy):
|
||
"""
|
||
频域能量相变策略 - 双因子自适应版 (Dual-Factor Adaptive)
|
||
|
||
优化逻辑：
|
||
不再通过静态参数 reverse 控制方向，而是由两个 Indicator 动态决策：
|
||
1. 计算 STFT 基础方向 (Base Direction)。
|
||
2. 检查 indicator_primary：若满足，则采用 Base Direction (顺势/正向)。
|
||
3. 若不满足，检查 indicator_secondary：若满足，则采用 Reverse Direction (逆势/反转)。
|
||
4. 若都不满足，保持空仓。
|
||
|
||
状态追踪：
|
||
self.entry_signal_source 会记录当前持仓是 'PRIMARY' 还是 'SECONDARY'。
|
||
"""
|
||
|
||
def __init__(
|
||
self,
|
||
context: Any,
|
||
main_symbol: str,
|
||
enable_log: bool,
|
||
trade_volume: int,
|
||
# --- 市场参数 ---
|
||
bars_per_day: int = 23,
|
||
# --- STFT 策略参数 ---
|
||
spectral_window_days: float = 2.0,
|
||
low_freq_days: float = 2.0,
|
||
high_freq_days: float = 1.0,
|
||
trend_strength_threshold: float = 0.2,
|
||
exit_threshold: float = 0.1,
|
||
slope_threshold: float = 0.0,
|
||
|
||
# --- 关键风控参数 (Chandelier Exit) ---
|
||
stop_loss_atr_multiplier: float = 5.0,
|
||
stop_loss_atr_period: int = 14,
|
||
|
||
# --- 信号控制指标 (核心优化) ---
|
||
indicator_primary: Indicator = None, # 满足此条件 -> 正向开仓 (reverse=False)
|
||
indicator_secondary: Indicator = None, # 满足此条件 -> 反向开仓 (reverse=True)
|
||
model_indicator: Indicator = None, # 可选：额外的AI模型过滤器
|
||
|
||
# --- 其他 ---
|
||
order_direction: Optional[List[str]] = None,
|
||
):
|
||
super().__init__(context, main_symbol, enable_log)
|
||
if order_direction is None:
|
||
order_direction = ['BUY', 'SELL']
|
||
|
||
self.trade_volume = trade_volume
|
||
self.bars_per_day = bars_per_day
|
||
|
||
# 信号参数
|
||
self.spectral_window_days = spectral_window_days
|
||
self.low_freq_days = low_freq_days
|
||
self.high_freq_days = high_freq_days
|
||
self.trend_strength_threshold = trend_strength_threshold
|
||
self.exit_threshold = exit_threshold
|
||
self.slope_threshold = slope_threshold
|
||
|
||
# 风控参数
|
||
self.sl_atr_multiplier = stop_loss_atr_multiplier
|
||
self.sl_atr_period = stop_loss_atr_period
|
||
|
||
self.order_direction = order_direction
|
||
|
||
# 初始指标容器 (默认为Empty，即永远返回True或False，视Empty具体实现而定，建议传入具体指标)
|
||
self.indicator_primary = indicator_primary or Empty()
|
||
self.indicator_secondary = indicator_secondary or Empty()
|
||
self.model_indicator = model_indicator or Empty()
|
||
|
||
# 计算 STFT 窗口大小
|
||
self.spectral_window = int(self.spectral_window_days * self.bars_per_day)
|
||
if self.spectral_window % 2 != 0:
|
||
self.spectral_window += 1
|
||
|
||
self.low_freq_bound = 1.0 / self.low_freq_days if self.low_freq_days > 0 else float('inf')
|
||
self.high_freq_bound = 1.0 / self.high_freq_days if self.high_freq_days > 0 else 0.0
|
||
|
||
self.order_id_counter = 0
|
||
|
||
# --- 持仓状态追踪变量 ---
|
||
self.entry_price = 0.0
|
||
self.pos_highest = 0.0
|
||
self.pos_lowest = 0.0
|
||
|
||
# 新增：记录开仓信号来源 ('PRIMARY' or 'SECONDARY')
|
||
self.entry_signal_source = None
|
||
|
||
self.log(
|
||
f"SpectralTrend Dual-Adaptive Strategy Initialized.\n"
|
||
f"Window: {self.spectral_window}, ATR Stop: {self.sl_atr_multiplier}x\n"
|
||
f"Primary Ind: {type(self.indicator_primary).__name__}, "
|
||
f"Secondary Ind: {type(self.indicator_secondary).__name__}"
|
||
)
|
||
|
||
def on_open_bar(self, open_price: float, symbol: str):
|
||
self.symbol = symbol
|
||
bar_history = self.get_bar_history()
|
||
|
||
self.cancel_all_pending_orders(self.main_symbol)
|
||
|
||
# 1. 数据长度检查
|
||
required_len = max(self.spectral_window, self.sl_atr_period + 5)
|
||
if len(bar_history) < required_len:
|
||
return
|
||
|
||
# 2. 计算 ATR
|
||
atr_window = self.sl_atr_period + 10
|
||
highs = np.array([b.high for b in bar_history[-atr_window:]], dtype=float)
|
||
lows = np.array([b.low for b in bar_history[-atr_window:]], dtype=float)
|
||
closes = np.array([b.close for b in bar_history[-atr_window:]], dtype=float)
|
||
|
||
try:
|
||
atr_values = talib.ATR(highs, lows, closes, timeperiod=self.sl_atr_period)
|
||
current_atr = atr_values[-1]
|
||
if np.isnan(current_atr): current_atr = 0.0
|
||
except Exception as e:
|
||
self.log(f"ATR Calc Error: {e}")
|
||
current_atr = 0.0
|
||
|
||
# 3. 计算 STFT 核心指标
|
||
stft_closes = np.array([b.close for b in bar_history[-self.spectral_window:]], dtype=float)
|
||
trend_strength, trend_slope = self.calculate_market_state(stft_closes)
|
||
|
||
# 4. 交易逻辑
|
||
position_volume = self.get_current_positions().get(self.symbol, 0)
|
||
current_high = bar_history[-1].high
|
||
current_low = bar_history[-1].low
|
||
|
||
if self.trading:
|
||
if position_volume == 0:
|
||
# 重置所有状态
|
||
self.pos_highest = 0.0
|
||
self.pos_lowest = 0.0
|
||
self.entry_price = 0.0
|
||
self.entry_signal_source = None # 重置信号来源
|
||
|
||
self.evaluate_entry_signal(open_price, trend_strength, trend_slope)
|
||
else:
|
||
self.manage_open_position(
|
||
position_volume,
|
||
trend_strength,
|
||
open_price,
|
||
current_atr,
|
||
current_high,
|
||
current_low
|
||
)
|
||
|
||
def calculate_market_state(self, prices: np.array) -> (float, float):
|
||
"""
|
||
计算频域能量占比和线性回归斜率
|
||
"""
|
||
if len(prices) < self.spectral_window:
|
||
return 0.0, 0.0
|
||
|
||
window_data = prices[-self.spectral_window:]
|
||
mean_val = np.mean(window_data)
|
||
std_val = np.std(window_data)
|
||
if std_val == 0: std_val = 1.0
|
||
|
||
normalized = (window_data - mean_val) / (std_val + 1e-8)
|
||
|
||
try:
|
||
f, t, Zxx = stft(
|
||
normalized,
|
||
fs=self.bars_per_day,
|
||
nperseg=self.spectral_window,
|
||
noverlap=max(0, self.spectral_window // 2),
|
||
boundary=None,
|
||
padded=False
|
||
)
|
||
except Exception:
|
||
return 0.0, 0.0
|
||
|
||
valid_mask = (f >= 0) & (f <= self.bars_per_day / 2)
|
||
f = f[valid_mask]
|
||
Zxx = Zxx[valid_mask, :]
|
||
|
||
if Zxx.size == 0: return 0.0, 0.0
|
||
|
||
current_energy = np.abs(Zxx[:, -1]) ** 2
|
||
low_mask = f < self.low_freq_bound
|
||
high_mask = f > self.high_freq_bound
|
||
|
||
low_energy = np.sum(current_energy[low_mask]) if np.any(low_mask) else 0.0
|
||
high_energy = np.sum(current_energy[high_mask]) if np.any(high_mask) else 0.0
|
||
total_energy = low_energy + high_energy + 1e-8
|
||
|
||
trend_strength = low_energy / total_energy
|
||
|
||
x = np.arange(len(normalized))
|
||
slope, _ = np.polyfit(x, normalized, 1)
|
||
|
||
return trend_strength, slope
|
||
|
||
def evaluate_entry_signal(self, open_price: float, trend_strength: float, trend_slope: float):
|
||
"""
|
||
入场逻辑优化：双因子控制
|
||
"""
|
||
# 1. 基础能量阈值检查
|
||
if trend_strength <= self.trend_strength_threshold:
|
||
return
|
||
|
||
# 2. 确定 STFT 原始方向 (Raw Direction)
|
||
raw_direction = None
|
||
if trend_slope > self.slope_threshold:
|
||
raw_direction = "BUY"
|
||
elif trend_slope < -self.slope_threshold:
|
||
raw_direction = "SELL"
|
||
|
||
if not raw_direction:
|
||
return
|
||
|
||
# 3. 双指标分支逻辑 (Dual-Indicator Branching)
|
||
# 获取指标计算所需的参数 (通常是 bar_history 等，依赖基类实现)
|
||
indicator_args = self.get_indicator_tuple()
|
||
|
||
final_direction = None
|
||
source_tag = None
|
||
|
||
# --- 分支 1: Primary Indicator (优先) ---
|
||
# 如果满足主条件 -> 使用原始方向 (Equivalent to reverse=False)
|
||
if self.indicator_primary.is_condition_met(*indicator_args):
|
||
final_direction = raw_direction
|
||
source_tag = "PRIMARY"
|
||
|
||
# --- 分支 2: Secondary Indicator (备选/Else) ---
|
||
# 如果不满足主条件，但满足备选条件 -> 使用反转方向 (Equivalent to reverse=True)
|
||
elif self.indicator_secondary.is_condition_met(*indicator_args):
|
||
final_direction = "SELL" if raw_direction == "BUY" else "BUY"
|
||
source_tag = "SECONDARY"
|
||
|
||
# --- 分支 3: 都不满足 ---
|
||
else:
|
||
return # 放弃交易
|
||
|
||
# 4. 全局模型过滤 (可选)
|
||
if not self.model_indicator.is_condition_met(*indicator_args):
|
||
return
|
||
|
||
# 5. 最终方向检查
|
||
if final_direction not in self.order_direction:
|
||
return
|
||
|
||
# 6. 执行开仓
|
||
self.log(
|
||
f"Entry Triggered [{source_tag}]: "
|
||
f"Raw={raw_direction} -> Final={final_direction} | "
|
||
f"Strength={trend_strength:.2f} | Slope={trend_slope:.4f}"
|
||
)
|
||
|
||
self.send_limit_order(final_direction, open_price, self.trade_volume, "OPEN")
|
||
|
||
# 更新状态
|
||
self.entry_price = open_price
|
||
self.pos_highest = open_price
|
||
self.pos_lowest = open_price
|
||
self.entry_signal_source = source_tag # 保存是由哪一个条件控制的
|
||
|
||
def manage_open_position(self, volume: int, trend_strength: float, current_price: float,
|
||
current_atr: float, high_price: float, low_price: float):
|
||
"""
|
||
离场逻辑 (保持不变，但日志中可以体现来源)
|
||
"""
|
||
exit_dir = "CLOSE_LONG" if volume > 0 else "CLOSE_SHORT"
|
||
|
||
# 更新极值
|
||
if volume > 0:
|
||
if high_price > self.pos_highest or self.pos_highest == 0:
|
||
self.pos_highest = high_price
|
||
else:
|
||
if (low_price < self.pos_lowest or self.pos_lowest == 0) and low_price > 0:
|
||
self.pos_lowest = low_price
|
||
|
||
# 1. 结构性止损 (Chandelier Exit)
|
||
is_stop_triggered = False
|
||
stop_line = 0.0
|
||
|
||
if current_atr > 0:
|
||
stop_distance = current_atr * self.sl_atr_multiplier
|
||
if volume > 0:
|
||
stop_line = self.pos_highest - stop_distance
|
||
if current_price <= stop_line:
|
||
is_stop_triggered = True
|
||
else:
|
||
stop_line = self.pos_lowest + stop_distance
|
||
if current_price >= stop_line:
|
||
is_stop_triggered = True
|
||
|
||
if is_stop_triggered:
|
||
self.log(
|
||
f"STOP Loss ({self.entry_signal_source}): Price {current_price} hit Chandelier line {stop_line:.2f}")
|
||
self.close_position(exit_dir, abs(volume))
|
||
return
|
||
|
||
# 2. 信号衰竭离场
|
||
if trend_strength < self.exit_threshold:
|
||
self.log(
|
||
f"Exit Signal ({self.entry_signal_source}): Energy Faded {trend_strength:.2f} < {self.exit_threshold}")
|
||
self.close_position(exit_dir, abs(volume))
|
||
return
|
||
|
||
# --- 交易辅助 ---
|
||
def close_position(self, direction: str, volume: int):
|
||
self.send_market_order(direction, volume, offset="CLOSE")
|
||
|
||
def send_market_order(self, direction: str, volume: int, offset: str):
|
||
order_id = f"{self.symbol}_{direction}_MKT_{self.order_id_counter}"
|
||
self.order_id_counter += 1
|
||
order = Order(
|
||
id=order_id, symbol=self.symbol, direction=direction, volume=volume,
|
||
price_type="MARKET", submitted_time=self.get_current_time(), offset=offset
|
||
)
|
||
self.send_order(order)
|
||
|
||
def send_limit_order(self, direction: str, limit_price: float, volume: int, offset: str):
|
||
order_id = f"{self.symbol}_{direction}_LMT_{self.order_id_counter}"
|
||
self.order_id_counter += 1
|
||
order = Order(
|
||
id=order_id, symbol=self.symbol, direction=direction, volume=volume,
|
||
price_type="LIMIT", submitted_time=self.get_current_time(), offset=offset,
|
||
limit_price=limit_price
|
||
)
|
||
self.send_order(order) |