liaozhaorun/NewQuant
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修复回测bug

Browse Source
This commit is contained in:
liaozhaorun
2025-06-23 23:49:43 +08:00
parent afed83f96f
commit 4521939b95
5 changed files with 9935 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9826
main.ipynb
View File

File diff suppressed because one or more lines are too long

19
src/backtest_engine.py
View File

@@ -1,5 +1,5 @@
# src/backtest_engine.py
from datetime import datetime
from typing import Type, Dict, Any, List, Optional
import pandas as pd
@@ -22,7 +22,10 @@ class BacktestEngine:
initial_capital: float = 100000.0,
slippage_rate: float = 0.0001,
commission_rate: float = 0.0002,
roll_over_mode: bool = False): # 新增换月模式参数
roll_over_mode: bool = False,
start_time: Optional[datetime] = None, # 新增开始时间
end_time: Optional[datetime] = None # 新增结束时间
): # 新增换月模式参数
"""
初始化回测引擎。
@@ -63,6 +66,10 @@ class BacktestEngine:
self._last_processed_bar_symbol: Optional[str] = None # 记录上一根 K 线的 symbol
self.is_rollover_bar: bool = False # 标记当前 K 线是否为换月 K 线（禁止开仓）
# 新增时间过滤属性
self.start_time = start_time
self.end_time = end_time
print("\n--- 回测引擎初始化完成 ---")
print(f" 策略: {strategy_class.__name__}")
print(f" 初始资金: {initial_capital:.2f}")
@@ -85,6 +92,14 @@ class BacktestEngine:
if current_bar is None:
break # 没有更多数据，回测结束
if self.start_time and current_bar.datetime < self.start_time:
continue
# 如果设置了结束时间，且当前K线在结束时间之后，则终止回测
if self.end_time and current_bar.datetime >= self.end_time:
print(f"到达结束时间 {self.end_time}，回测终止。")
break
# --- 换月逻辑判断和处理 (在处理 current_bar 之前进行) ---
# 1. 重置 is_rollover_bar 标记
self.is_rollover_bar = False

197
src/execution_simulator.py
View File

@@ -5,10 +5,12 @@ from typing import Dict, List, Optional
import pandas as pd
from .core_data import Order, Trade, Bar, PortfolioSnapshot
class ExecutionSimulator:
"""
模拟交易执行和管理账户资金、持仓。
"""
def __init__(self, initial_capital: float,
slippage_rate: float = 0.0001,
commission_rate: float = 0.0002,
@@ -49,7 +51,7 @@ class ExecutionSimulator:
"""
fill_price = -1.0 # 默认未成交
base_price = current_bar.open # 所有成交都以当前K线的开盘价为基准
base_price = current_bar.open # 所有成交都以当前K线的开盘价为基准
if order.price_type == "MARKET":
# 市价单：直接以开盘价成交，考虑滑点
@@ -58,11 +60,11 @@ class ExecutionSimulator:
elif order.direction == "SELL" or order.direction == "CLOSE_LONG": # 卖出/平多：向下偏离（少收）
fill_price = base_price * (1 - self.slippage_rate)
else:
fill_price = base_price # 理论上不发生
fill_price = base_price # 理论上不发生
elif order.price_type == "LIMIT" and order.limit_price is not None:
limit_price = order.limit_price
# 限价单：判断开盘价是否满足限价条件，如果满足，则以开盘价成交（考虑滑点）
if order.direction == "BUY" or order.direction == "CLOSE_SHORT": # 限价买入/平空
# 买单只有当开盘价低于或等于限价时才可能成交
@@ -76,7 +78,7 @@ class ExecutionSimulator:
if base_price >= limit_price:
fill_price = base_price * (1 - self.slippage_rate)
# else: 未满足限价条件，不成交
# 最终检查成交价是否有效且合理（大于0）
if fill_price <= 0:
return -1.0 # 未成交或价格无效
@@ -94,28 +96,28 @@ class ExecutionSimulator:
self.pending_orders[order.id] = order
# print(f"订单 {order.id} 加入待处理队列。")
return order
def process_pending_orders(self, current_bar: Bar):
"""
处理所有待撮合的订单。在每个K线数据到来时调用。
"""
# 复制一份待处理订单的键，防止在迭代时修改字典
order_ids_to_process = list(self.pending_orders.keys())
for order_id in order_ids_to_process:
if order_id not in self.pending_orders: # 订单可能已被取消
if order_id not in self.pending_orders: # 订单可能已被取消
continue
order = self.pending_orders[order_id]
# 只有当订单的symbol与当前bar的symbol一致时才尝试撮合
# 这样确保了在换月后，旧合约的挂单不会被尝试撮合 (尽管换月时会强制取消)
if order.symbol != current_bar.symbol:
# 这种情况理论上应该被换月逻辑清理掉的旧合约挂单，
# 如果因为某种原因漏掉了，这里直接跳过，避免异常。
continue
continue
# 尝试成交订单
# 尝试成交订单
self._execute_single_order(order, current_bar)
def _execute_single_order(self, order: Order, current_bar: Bar) -> Optional[Trade]:
@@ -124,106 +126,154 @@ class ExecutionSimulator:
由 send_order 或 process_pending_orders 调用。
"""
# --- 处理撤单指令 ---
if order.direction == "CANCEL": # 策略主动发起撤单
if order.direction == "CANCEL": # 策略主动发起撤单
success = self.cancel_order(order.id)
if success:
# print(f"[{current_bar.datetime}] 模拟器: 收到并成功处理撤单指令 for Order ID: {order.id}")
pass
return None # 撤单操作不返回Trade
return None # 撤单操作不返回Trade
symbol = order.symbol
volume = order.volume
# 尝试计算成交价格
fill_price = self._calculate_fill_price(order, current_bar)
if fill_price <= 0: # 未成交或不满足限价条件
return None
# --- 以下是订单成功成交的逻辑 ---
# --- 以下是订单成功成交前的预检查逻辑 ---
trade_value = volume * fill_price
commission = trade_value * self.commission_rate
current_position = self.positions.get(symbol, 0)
current_average_cost = self.average_costs.get(symbol, 0.0)
realized_pnl = 0.0
# 根据 direction 判断开平仓意图
# 如果 direction 是 CLOSE_LONG 或 CLOSE_SELL (平多), CLOSE_SHORT (平空) 则是平仓交易
is_close_trade = order.direction in ["CLOSE_LONG", "CLOSE_SELL", "CLOSE_SHORT"]
# 如果 direction 是 BUY 或 SELL 且不是平仓意图，则是开仓交易
is_open_trade = (order.direction in ["BUY", "SELL"]) and (not is_close_trade)
realized_pnl = 0.0 # 预先计算的实现盈亏
# -----------------------------------------------------------
# 精确判断 is_open_trade 和 is_close_trade
# -----------------------------------------------------------
is_trade_a_close_operation = False
is_trade_an_open_operation = False
# 区分实际的买卖方向
# 1. 判断是否为平仓操作
# 显式平仓指令
if order.direction in ["CLOSE_LONG", "CLOSE_SELL", "CLOSE_SHORT"]:
is_trade_a_close_operation = True
# 隐式平仓 (例如，持有空头时买入，或持有多头时卖出)
elif order.direction == "BUY" and current_position < 0: # 买入平空
is_trade_a_close_operation = True
elif order.direction == "SELL" and current_position > 0: # 卖出平多
is_trade_a_close_operation = True
# 2. 判断是否为开仓操作
if order.direction == "BUY":
# 买入开多: 如果当前持有多头或无仓位，或者从空头转为多头
if current_position >= 0 or (current_position < 0 and (current_position + volume) > 0):
is_trade_an_open_operation = True
elif order.direction == "SELL":
# 卖出开空: 如果当前持有空头或无仓位，或者从多头转为空头
if current_position <= 0 or (current_position > 0 and (current_position - volume) < 0):
is_trade_an_open_operation = True
# -----------------------------------------------------------
# 区分实际的买卖方向 (用于资金和持仓计算)
actual_execution_direction = ""
if order.direction == "BUY" or order.direction == "CLOSE_SHORT":
actual_execution_direction = "BUY"
elif order.direction == "SELL" or order.direction == "CLOSE_LONG" or order.direction == "CLOSE_SELL":
actual_execution_direction = "SELL"
else:
print(f"[{current_bar.datetime}] 模拟器: 收到未知订单方向 {order.direction} for Order ID: {order.id}. 订单未处理。")
print(
f"[{current_bar.datetime}] 模拟器: 收到未知订单方向 {order.direction} for Order ID: {order.id}. 订单未处理。")
if order.id in self.pending_orders: del self.pending_orders[order.id]
return None
# --- 临时变量，用于预计算新的资金和持仓状态 ---
temp_cash = self.cash
temp_positions = self.positions.copy()
temp_average_costs = self.average_costs.copy()
# 根据实际执行方向进行预计算和资金检查
if actual_execution_direction == "BUY": # 处理实际的买入 (开多 / 平空)
if current_position >= 0: # 当前持有多仓或无仓位 (开多)
new_total_cost = (current_average_cost * current_position) + (fill_price * volume)
new_total_volume = current_position + volume
self.average_costs[symbol] = new_total_cost / new_total_volume if new_total_volume > 0 else 0.0
self.positions[symbol] = new_total_volume
else: # 当前持有空仓 (平空)
pnl_per_share = current_average_cost - fill_price # 空头平仓盈亏
required_cash = trade_value + commission
if temp_cash < required_cash:
print(
f"[{current_bar.datetime}] 模拟器: 资金不足 (开多), 无法执行买入 {volume} {symbol} @ {fill_price:.2f}. 需要: {required_cash:.2f}, 当前: {temp_cash:.2f}")
if order.id in self.pending_orders: del self.pending_orders[order.id]
return None
temp_cash -= required_cash
new_total_cost = (temp_average_costs.get(symbol, 0.0) * temp_positions.get(symbol, 0)) + (
fill_price * volume)
new_total_volume = temp_positions.get(symbol, 0) + volume
temp_average_costs[symbol] = new_total_cost / new_total_volume if new_total_volume > 0 else 0.0
temp_positions[symbol] = new_total_volume
else: # 当前持有空仓 (平空) - 平仓交易，佣金从交易价值中扣除，不单独检查现金余额
pnl_per_share = current_average_cost - fill_price # 空头平仓盈亏
realized_pnl = pnl_per_share * volume
self.positions[symbol] += volume
if self.positions[symbol] == 0:
del self.positions[symbol]
if symbol in self.average_costs: del self.average_costs[symbol]
elif self.positions[symbol] > 0 and current_position < 0: # 空转多
self.average_costs[symbol] = fill_price # 新多头仓位成本以成交价为准
temp_cash -= commission # 扣除佣金
temp_cash += trade_value # 回收平仓价值
temp_cash += realized_pnl # 计入实现盈亏
if self.cash < trade_value + commission:
print(f"[{current_bar.datetime}] 模拟器: 资金不足，无法执行买入 {volume} {symbol} @ {fill_price:.2f}")
if order.id in self.pending_orders: del self.pending_orders[order.id]
return None
self.cash -= (trade_value + commission)
temp_positions[symbol] += volume
if temp_positions[symbol] == 0:
del temp_positions[symbol]
if symbol in temp_average_costs: del temp_average_costs[symbol]
elif current_position < 0 and temp_positions[symbol] > 0: # 发生空转多
temp_average_costs[symbol] = fill_price # 新多头仓位成本以成交价为准
elif actual_execution_direction == "SELL": # 处理实际的卖出 (开空 / 平多)
if current_position <= 0: # 当前持有空仓或无仓位 (开空)
new_total_value = (current_average_cost * abs(current_position)) + (fill_price * volume)
new_total_volume = abs(current_position) + volume
self.average_costs[symbol] = new_total_value / new_total_volume if new_total_volume > 0 else 0.0
self.positions[symbol] -= volume
else: # 当前持有多仓 (平多)
pnl_per_share = fill_price - current_average_cost # 多头平仓盈亏
# 开空主要检查佣金是否足够
if temp_cash < commission:
print(
f"[{current_bar.datetime}] 模拟器: 资金不足 (开空佣金), 无法执行卖出 {volume} {symbol} @ {fill_price:.2f}. 佣金: {commission:.2f}, 当前: {temp_cash:.2f}")
if order.id in self.pending_orders: del self.pending_orders[order.id]
return None
temp_cash -= commission
new_total_value = (temp_average_costs.get(symbol, 0.0) * abs(temp_positions.get(symbol, 0))) + (
fill_price * volume)
new_total_volume = abs(temp_positions.get(symbol, 0)) + volume
temp_average_costs[symbol] = new_total_value / new_total_volume if new_total_volume > 0 else 0.0 # 平均成本
temp_positions[symbol] -= volume
else: # 当前持有多仓 (平多) - 平仓交易，佣金从交易价值中扣除，不单独检查现金余额
pnl_per_share = fill_price - current_average_cost # 多头平仓盈亏
realized_pnl = pnl_per_share * volume
self.positions[symbol] -= volume
if self.positions[symbol] == 0:
del self.positions[symbol]
if symbol in self.average_costs: del self.average_costs[symbol]
elif self.positions[symbol] < 0 and current_position > 0: # 多转空
self.average_costs[symbol] = fill_price # 新空头仓位成本以成交价为准
if self.cash < commission: # 卖出交易，佣金先扣
print(f"[{current_bar.datetime}] 模拟器: 资金不足（佣金），无法执行卖出 {volume} {symbol} @ {fill_price:.2f}")
if order.id in self.pending_orders: del self.pending_orders[order.id]
return None
self.cash -= commission
self.cash += trade_value
temp_cash -= commission # 扣除佣金
temp_cash += trade_value # 回收平仓价值
temp_cash += realized_pnl # 计入实现盈亏
temp_positions[symbol] -= volume
if temp_positions[symbol] == 0:
del temp_positions[symbol]
if symbol in temp_average_costs: del temp_average_costs[symbol]
elif current_position > 0 and temp_positions[symbol] < 0: # 发生多转空
temp_average_costs[symbol] = fill_price # 新空头仓位成本以成交价为准
# --- 所有检查通过后，才正式更新模拟器状态 ---
self.cash = temp_cash
self.positions = temp_positions
self.average_costs = temp_average_costs
# 创建 Trade 对象时，direction 使用原始订单的 direction
executed_trade = Trade(
order_id=order.id, fill_time=current_bar.datetime, symbol=symbol,
direction=order.direction, # 使用原始订单的 direction
direction=order.direction, # 使用原始订单的 direction
volume=volume, price=fill_price, commission=commission,
cash_after_trade=self.cash, positions_after_trade=self.positions.copy(),
realized_pnl=realized_pnl,
is_open_trade=is_open_trade,
is_close_trade=is_close_trade
is_open_trade=is_trade_an_open_operation, # 使用更精确的判断
is_close_trade=is_trade_a_close_operation # 使用更精确的判断
)
self.trade_log.append(executed_trade)
@@ -232,6 +282,7 @@ class ExecutionSimulator:
del self.pending_orders[order.id]
return executed_trade
def cancel_order(self, order_id: str) -> bool:
"""
尝试取消一个待处理订单。
@@ -240,7 +291,7 @@ class ExecutionSimulator:
del self.pending_orders[order_id]
return True
return False
# --- 新增：强制平仓指定合约的所有持仓 ---
def force_close_all_positions_for_symbol(self, symbol_to_close: str, closing_bar: Bar) -> List[Trade]:
"""
@@ -252,14 +303,14 @@ class ExecutionSimulator:
List[Trade]: 因强制平仓而产生的交易记录。
"""
closed_trades: List[Trade] = []
# 仅处理指定symbol的持仓
if symbol_to_close in self.positions and self.positions[symbol_to_close] != 0:
volume_to_close = self.positions[symbol_to_close]
# 根据持仓方向决定平仓订单的方向
direction = "SELL" if volume_to_close > 0 else "BUY" # 多头平仓是卖出，空头平仓是买入
direction = "CLOSE_LONG" if volume_to_close > 0 else "CLOSE_SELL" # 多头平仓是卖出，空头平仓是买入
# 构造一个市价平仓订单
rollover_order = Order(
id=f"FORCE_CLOSE_{symbol_to_close}_{closing_bar.datetime.strftime('%Y%m%d%H%M%S%f')}",
@@ -270,7 +321,7 @@ class ExecutionSimulator:
limit_price=None,
submitted_time=closing_bar.datetime,
)
# 使用内部的执行逻辑进行撮合
trade = self._execute_single_order(rollover_order, closing_bar)
if trade:
@@ -291,7 +342,7 @@ class ExecutionSimulator:
if order.symbol == symbol_to_cancel
]
for order_id in order_ids_to_cancel:
if self.cancel_order(order_id): # 调用现有的 cancel_order 方法
if self.cancel_order(order_id): # 调用现有的 cancel_order 方法
cancelled_count += 1
return cancelled_count
@@ -347,10 +398,10 @@ class ExecutionSimulator:
self.cash = new_initial_capital if new_initial_capital is not None else self.initial_capital
self.positions = new_initial_positions.copy() if new_initial_positions is not None else {}
self.average_costs = {}
for symbol, qty in self.positions.items(): # 重置平均成本
for symbol, qty in self.positions.items(): # 重置平均成本
self.average_costs[symbol] = 0.0
self.trade_log = []
self.pending_orders = {} # 清空挂单
self.pending_orders = {} # 清空挂单
self._current_time = None
# Removed clear_trade_history as trade_log is cleared in reset
@@ -358,4 +409,4 @@ class ExecutionSimulator:
def get_average_position_price(self, symbol: str) -> Optional[float]:
if symbol in self.positions and self.positions[symbol] != 0:
return self.average_costs.get(symbol)
return None
return None

104
src/research/grid_search.ipynb
View File

File diff suppressed because one or more lines are too long

1
src/strategies/SimpleLimitBuyStrategy.py
View File

@@ -157,6 +157,7 @@ class SimpleLimitBuyStrategy(Strategy):
self.log(f"[{current_datetime}] 开多仓信号 - 当前Open={bar.open:.2f}, "
f"前1Range={range_1_ago:.2f}, 前7Range={range_7_ago:.2f}, "
f"计算目标买入价={target_buy_price:.2f}")
self.log(f'{self.context._simulator.get_current_positions()}')
order_id = f"{self.symbol}_BUY_{bar.datetime.strftime('%Y%m%d%H%M%S')}_{self.order_id_counter}"
self.order_id_counter += 1