import numpy as np import pandas as pd from typing import Optional, Dict, Any, List, Union import talib # <-- 【新增】导入talib库 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 from src.algo.TrendLine import calculate_latest_trendline_values import numpy as np import pandas as pd from typing import Optional, Dict, Any, List, Union import talib class TrendlineHawkesStrategy(Strategy): """ 趋势线与霍克斯过程双重确认策略 (V8 - O(1) 滚动统计终极版): - 对交易量Z-score的计算进行了极致优化，采用增量方式维护滚动窗口的统计量。 - 每次更新均值和标准差的计算复杂度从 O(N) 降为 O(1)。 - 这是目前性能最高的实现方式，适用于非常高频的场景。 """ def __init__( self, context: Any, main_symbol: str, # --- 所有参数与V7完全相同 --- trade_volume: int = 1, order_direction: Optional[List[str]] = None, reverse_logic: bool = False, trendline_n: int = 50, hawkes_kappa: float = 0.1, hawkes_lookback: int = 50, hawkes_entry_percent: float = 0.95, hawkes_exit_percent: float = 0.25, volume_norm_n: int = 50, enable_atr_stop_loss: bool = True, atr_period: int = 14, atr_multiplier: float = 1.0, enable_log: bool = True, indicators: Union[Indicator, List[Indicator]] = None, ): super().__init__(context, main_symbol, enable_log) # --- 参数赋值 (与V7相同) --- # ... (省略) ... self.main_symbol = main_symbol self.trade_volume = trade_volume self.order_direction = order_direction or ["BUY", "SELL"] self.reverse_logic = reverse_logic self.trendline_n = trendline_n self.hawkes_kappa = hawkes_kappa self.hawkes_lookback = hawkes_lookback self.hawkes_entry_percent = hawkes_entry_percent self.hawkes_exit_percent = hawkes_exit_percent self.volume_norm_n = volume_norm_n self.enable_atr_stop_loss = enable_atr_stop_loss self.atr_period = atr_period self.atr_multiplier = atr_multiplier self.pos_meta: Dict[str, Dict[str, Any]] = {} if indicators is None: indicators = [Empty(), Empty()] self.indicators = indicators # --- 霍克斯过程状态 (与V7相同) --- self._last_hawkes_unscaled: float = 0.0 self._hawkes_window: np.ndarray = np.array([], dtype=np.float64) self._hawkes_alpha = np.exp(-self.hawkes_kappa) # --- 【核心修改】O(1) 滚动统计状态 --- # 预分配一个固定长度的数组作为循环缓冲区 self._volume_window: np.ndarray = np.zeros(self.volume_norm_n, dtype=np.float64) self._volume_sum: float = 0.0 # 窗口内元素的和 self._volume_sum_sq: float = 0.0 # 窗口内元素平方的和 self._volume_pointer: int = 0 # 指向窗口中最旧元素的指针 self._is_volume_window_full: bool = False # 窗口是否已填满的标志 def on_init(self): super().on_init() self.pos_meta.clear() # 重置霍克斯状态 self._last_hawkes_unscaled = 0.0 self._hawkes_window = np.array([], dtype=np.float64) # 【核心修改】重置所有滚动统计状态 self._volume_window.fill(0) self._volume_sum = 0.0 self._volume_sum_sq = 0.0 self._volume_pointer = 0 self._is_volume_window_full = False # 【核心修改】_initialize_state 和 _update_state_incrementally 被重构 def _initialize_state(self, initial_volumes: np.ndarray): """ 在策略开始时调用一次，用历史数据填充所有状态。 这个函数现在也会以增量方式填充滚动统计量。 """ print("首次运行，正在以增量方式初始化所有状态...") # 1. 增量填充交易量窗口并计算历史Z-score normalized_volumes = [] for vol in initial_volumes: # 调用增量更新函数，该函数会更新窗口、和、平方和 self._update_volume_stats_incrementally(vol) # 计算Z-score mean, std = self._get_current_volume_stats() z_score = 0.0 if std > 1e-9: z_score = (vol - mean) / std normalized_volumes.append(z_score) # 2. 使用标准化的交易量历史来初始化霍克斯过程 (逻辑与V7相同) print("正在基于标准化的交易量初始化霍克斯过程...") alpha = self._hawkes_alpha temp_hawkes_history = np.zeros_like(normalized_volumes, dtype=np.float64) if len(normalized_volumes) > 0: temp_hawkes_history[0] = normalized_volumes[0] for i in range(1, len(normalized_volumes)): temp_hawkes_history[i] = temp_hawkes_history[i - 1] * alpha + normalized_volumes[i] # 3. 记录最后的状态 self._last_hawkes_unscaled = temp_hawkes_history[-1] if len(temp_hawkes_history) > 0 else 0.0 self._hawkes_window = (temp_hawkes_history * self.hawkes_kappa)[-self.hawkes_lookback:] print("状态初始化完成。") def _update_volume_stats_incrementally(self, latest_volume: float): """O(1) 增量更新交易量窗口的统计数据""" # 获取即将被替换的最旧的元素 oldest_volume = self._volume_window[self._volume_pointer] # 更新和与平方和 self._volume_sum += latest_volume - oldest_volume self._volume_sum_sq += latest_volume ** 2 - oldest_volume ** 2 # 在循环缓冲区中替换旧值 self._volume_window[self._volume_pointer] = latest_volume # 移动指针 self._volume_pointer += 1 if self._volume_pointer >= self.volume_norm_n: self._volume_pointer = 0 self._is_volume_window_full = True # 窗口在指针第一次循环时被填满 def _get_current_volume_stats(self) -> (float, float): """O(1) 获取当前的均值和标准差""" # 在窗口未满时，我们按实际元素数量计算 n = self.volume_norm_n if self._is_volume_window_full else self._volume_pointer if n == 0: return 0.0, 0.0 mean = self._volume_sum / n # 为防止浮点误差导致极小的负数，使用 max(0, ...) variance = max(0, (self._volume_sum_sq / n) - mean ** 2) std = np.sqrt(variance) return mean, std def _update_state_incrementally(self, latest_volume: float): """【重构】每个Bar上调用的主增量更新函数""" # 1. O(1) 更新交易量统计 self._update_volume_stats_incrementally(latest_volume) # 2. O(1) 计算最新Z-score mean, std = self._get_current_volume_stats() normalized_volume = 0.0 if std > 1e-9: normalized_volume = (latest_volume - mean) / std # 3. 更新霍克斯过程 (逻辑与V7相同) new_hawkes_unscaled = self._last_hawkes_unscaled * self._hawkes_alpha + normalized_volume self._last_hawkes_unscaled = new_hawkes_unscaled new_hawkes_scaled = new_hawkes_unscaled * self.hawkes_kappa if self._hawkes_window.size < self.hawkes_lookback: self._hawkes_window = np.append(self._hawkes_window, new_hawkes_scaled) else: self._hawkes_window = np.roll(self._hawkes_window, -1) self._hawkes_window[-1] = new_hawkes_scaled # on_open_bar 逻辑不变，它只负责调用 _update_state_incrementally def on_open_bar(self, open_price: float, symbol: str): bar_history = self.get_bar_history() min_bars_required = max(self.trendline_n + 2, self.hawkes_lookback + 2, self.volume_norm_n + 2, self.atr_period + 2) if len(bar_history) < min_bars_required: return # 状态更新 (调用重构后的函数) if self._hawkes_window.size == 0: initial_volumes = np.array([b.volume for b in bar_history], dtype=float) self._initialize_state(initial_volumes[:-1]) self._update_state_incrementally(float(bar_history[-1].volume)) # --- 后续交易逻辑 (与V7完全相同) --- # ... (此处省略，代码与V7的 on_open_bar 后半部分完全一样) ... self.cancel_all_pending_orders(symbol) pos = self.get_current_positions().get(symbol, 0) latest_hawkes_value = self._hawkes_window[-1] latest_hawkes_lower = np.quantile(self._hawkes_window, self.hawkes_exit_percent) meta = self.pos_meta.get(symbol) if meta and pos != 0: close_reason = None if latest_hawkes_value < latest_hawkes_lower: close_reason = f"霍克斯出场信号(强度: {latest_hawkes_value:.4f} < 阈值: {latest_hawkes_lower:.4f})" if self.enable_atr_stop_loss and 'stop_loss_price' in meta and meta['stop_loss_price'] is not None: last_close = bar_history[-1].close stop_loss_price = meta['stop_loss_price'] if (meta['direction'] == "BUY" and last_close < stop_loss_price) or \ (meta['direction'] == "SELL" and last_close > stop_loss_price): close_reason = f"ATR止损触发(收盘价: {last_close:.2f}, 止损价: {stop_loss_price:.2f})" if close_reason: self.log(close_reason) self.send_market_order("CLOSE_LONG" if meta['direction'] == "BUY" else "CLOSE_SHORT", abs(pos)) if symbol in self.pos_meta: del self.pos_meta[symbol] return if pos == 0: latest_hawkes_upper = np.quantile(self._hawkes_window, self.hawkes_entry_percent) close_prices = np.array([b.close for b in bar_history]) prices_for_trendline = close_prices[-self.trendline_n - 1:-1] trend_upper, trend_lower = calculate_latest_trendline_values(prices_for_trendline) if trend_upper is not None and trend_lower is not None: prev_close, last_close = bar_history[-2].close, bar_history[-1].close upper_break = last_close > trend_upper and prev_close < trend_upper and self.indicators[0].is_condition_met(*self.get_indicator_tuple()) lower_break = last_close < trend_lower and prev_close > trend_lower and self.indicators[1].is_condition_met(*self.get_indicator_tuple()) hawkes_confirm = latest_hawkes_value > latest_hawkes_upper if hawkes_confirm and (upper_break or lower_break): direction = "BUY" if upper_break: direction = "SELL" if self.reverse_logic else "BUY" elif lower_break: direction = "BUY" if self.reverse_logic else "SELL" if direction in self.order_direction: sl_price = None if self.enable_atr_stop_loss: atr_val = self._calculate_atr(bar_history[:-1], self.atr_period) if atr_val is not None: sl_price = open_price - atr_val * self.atr_multiplier if direction == "BUY" else open_price + atr_val * self.atr_multiplier self.log(f"ATR({self.atr_period})={atr_val:.4f}, 止损价设置为: {sl_price:.2f}") self.log( f"开仓信号确认(霍克斯强度: {latest_hawkes_value:.4f} > 阈值: {latest_hawkes_upper:.4f})") self.send_open_order(direction, open_price, self.trade_volume, sl_price) # ATR计算函数及其他下单函数与V7完全相同 def _calculate_atr(self, bar_history: List[Bar], period: int) -> Optional[float]: if len(bar_history) < period + 1: return None highs = np.array([b.high for b in bar_history], dtype=float) lows = np.array([b.low for b in bar_history], dtype=float) closes = np.array([b.close for b in bar_history], dtype=float) atr_values = talib.ATR(highs, lows, closes, timeperiod=period) latest_atr = atr_values[-1] return latest_atr if not np.isnan(latest_atr) else None def send_open_order(self, direction: str, entry_price: float, volume: int, stop_loss_price: Optional[float] = None): current_time = self.get_current_time() order_id = f"{self.symbol}_{direction}_{current_time.strftime('%Y%m%d%H%M%S')}" order_direction = "BUY" if direction == "BUY" else "SELL" order = Order(id=order_id, symbol=self.symbol, direction=order_direction, volume=volume, price_type="MARKET", submitted_time=current_time, offset="OPEN") self.send_order(order) self.pos_meta[self.symbol] = { "direction": direction, "volume": volume, "entry_price": entry_price, "stop_loss_price": stop_loss_price } self.log(f"发送开仓订单: {direction} {volume}手 @ Market Price (执行价约 {entry_price:.2f})") def send_market_order(self, direction: str, volume: int): current_time = self.get_current_time() order_id = f"{self.symbol}_{direction}_{current_time.strftime('%Y%m%d%H%M%S')}" order = Order(id=order_id, symbol=self.symbol, direction=direction, volume=volume, price_type="MARKET", submitted_time=current_time, offset="CLOSE") self.send_order(order) self.log(f"发送平仓订单: {direction} {volume}手 @ Market Price") def on_rollover(self, old_symbol: str, new_symbol: str): super().on_rollover(old_symbol, new_symbol) self.cancel_all_pending_orders(new_symbol) self.pos_meta.clear()