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

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