755 lines
31 KiB
Python
755 lines
31 KiB
Python
"""
|
||
布林带延迟反转策略回测 - 2026年3月
|
||
策略规则：
|
||
1. 5分钟K线，BB(10, 2.5)
|
||
2. 空仓触上轨开空，触下轨开多
|
||
3. 同向加仓最多1次，保证金递增(1%->2%)
|
||
4. 延迟反转：触轨不立刻平仓，记录价格，回调到该价再平仓+反向开仓
|
||
5. 中轨平半+回开仓价全平
|
||
6. 止损：亏损达保证金50%
|
||
"""
|
||
|
||
import pandas as pd
|
||
from pathlib import Path
|
||
from peewee import *
|
||
from loguru import logger
|
||
|
||
# 数据库配置
|
||
DB_PATH = Path(__file__).parent / 'models' / 'database.db'
|
||
db = SqliteDatabase(str(DB_PATH))
|
||
|
||
class BitMartETH5M(Model):
|
||
"""5分钟K线模型"""
|
||
id = BigIntegerField(primary_key=True)
|
||
open = FloatField(null=True)
|
||
high = FloatField(null=True)
|
||
low = FloatField(null=True)
|
||
close = FloatField(null=True)
|
||
|
||
class Meta:
|
||
database = db
|
||
table_name = 'bitmart_eth_5m'
|
||
|
||
|
||
class BitMartETH1M(Model):
|
||
"""1分钟K线模型"""
|
||
id = BigIntegerField(primary_key=True)
|
||
open = FloatField(null=True)
|
||
high = FloatField(null=True)
|
||
low = FloatField(null=True)
|
||
close = FloatField(null=True)
|
||
|
||
class Meta:
|
||
database = db
|
||
table_name = 'bitmart_eth_1m'
|
||
|
||
|
||
class BollingerBandBacktest:
|
||
"""布林带延迟反转策略回测"""
|
||
|
||
def __init__(self):
|
||
# 策略参数
|
||
self.bb_period = 10
|
||
self.bb_std = 2.5
|
||
self.initial_capital = 100 # 初始本金100U
|
||
self.leverage = 50 # 50倍杠杆
|
||
self.fee_rate = 0.0005 # 万五手续费
|
||
self.rebate_rate = 0.9 # 90%返佣
|
||
self.margin_ratio_1 = 0.01 # 首次开仓保证金比例1%
|
||
self.margin_ratio_2 = 0.01 # 加仓保证金比例1%
|
||
self.stop_loss_ratio = 0.5 # 止损比例50%
|
||
self.entry_slippage = 0.0002 # 开仓滑点（2bps）
|
||
self.rebate_credit_hour = 8 # 次日早上8点返佣到账（上海时间）
|
||
|
||
# 账户状态
|
||
self.capital = self.initial_capital
|
||
self.position = 0 # 持仓量（正=多，负=空）
|
||
self.position_count = 0 # 持仓次数（0=空仓，1=首次，2=加仓）
|
||
self.entry_price = 0 # 开仓均价
|
||
self.total_margin = 0 # 总保证金
|
||
|
||
# 延迟反转状态
|
||
self.delay_reverse_price = None # 记录触碰轨道时的轨道价格
|
||
self.delay_reverse_type = None # 'long_to_short' 或 'short_to_long'
|
||
self.delay_reverse_kline_index = None # 触发延迟反转的K线索引
|
||
|
||
# 中轨平仓记录
|
||
self.mid_closed_half = False # 是否已平50%
|
||
|
||
# 1分钟K线缓存（key=5分钟起始时间戳, value=该5分钟内的1m列表）
|
||
self.one_minute_by_5m = {}
|
||
|
||
# 交易记录
|
||
self.trades = []
|
||
self.daily_pnl = []
|
||
self.pending_rebates = [] # 待到账返佣队列
|
||
self.total_rebate_credited = 0.0
|
||
self.current_run_label = "default"
|
||
|
||
def calculate_bollinger_bands(self, df):
|
||
"""计算布林带（整体右移1根，避免使用当前K收盘价）"""
|
||
df['sma'] = df['close'].rolling(window=self.bb_period).mean()
|
||
df['std'] = df['close'].rolling(window=self.bb_period).std()
|
||
df['upper'] = (df['sma'] + self.bb_std * df['std']).shift(1)
|
||
df['lower'] = (df['sma'] - self.bb_std * df['std']).shift(1)
|
||
df['middle'] = df['sma'].shift(1)
|
||
return df
|
||
|
||
def get_rebate_amount(self, fee):
|
||
"""计算返佣金额"""
|
||
return fee * self.rebate_rate
|
||
|
||
def schedule_rebate(self, fee, timestamp):
|
||
"""登记返佣到账时间（次日08:00，上海时间）"""
|
||
rebate = self.get_rebate_amount(fee)
|
||
if rebate <= 0:
|
||
return
|
||
|
||
trade_utc = pd.Timestamp(timestamp, tz='UTC')
|
||
trade_local = trade_utc.tz_convert('Asia/Shanghai')
|
||
credit_local = (trade_local + pd.Timedelta(days=1)).normalize() + pd.Timedelta(hours=self.rebate_credit_hour)
|
||
credit_utc = credit_local.tz_convert('UTC').tz_localize(None)
|
||
|
||
self.pending_rebates.append({
|
||
'credit_time': credit_utc,
|
||
'amount': rebate,
|
||
'trade_time': trade_utc.tz_localize(None),
|
||
})
|
||
|
||
def apply_pending_rebates(self, current_time):
|
||
"""处理当前时刻前应到账的返佣"""
|
||
if not self.pending_rebates:
|
||
return
|
||
|
||
remaining = []
|
||
for item in self.pending_rebates:
|
||
if item['credit_time'] <= current_time:
|
||
amount = item['amount']
|
||
self.capital += amount
|
||
self.total_rebate_credited += amount
|
||
self.trades.append({
|
||
'timestamp': current_time.strftime('%Y-%m-%d %H:%M'),
|
||
'action': '返佣到账',
|
||
'price': None,
|
||
'size': None,
|
||
'rebate': amount,
|
||
'capital': self.capital,
|
||
'reason': f"次日08:00返佣到账({item['trade_time'].strftime('%Y-%m-%d %H:%M')}手续费)"
|
||
})
|
||
logger.info(
|
||
f"[{current_time.strftime('%Y-%m-%d %H:%M')}] 返佣到账: {amount:.4f}U | 可用资金: {self.capital:.4f}U"
|
||
)
|
||
else:
|
||
remaining.append(item)
|
||
|
||
self.pending_rebates = remaining
|
||
|
||
def apply_entry_slippage(self, price, direction):
|
||
"""按方向施加不利滑点"""
|
||
if direction == 'long':
|
||
return price * (1 + self.entry_slippage)
|
||
return price * (1 - self.entry_slippage)
|
||
|
||
def load_one_minute_cache(self, start_ts, end_ts):
|
||
"""加载并缓存1分钟K线，用于5分钟内走势确认"""
|
||
query = BitMartETH1M.select().where(
|
||
(BitMartETH1M.id >= start_ts) & (BitMartETH1M.id <= end_ts)
|
||
).order_by(BitMartETH1M.id)
|
||
|
||
bucket = {}
|
||
for row in query:
|
||
five_min_start = int(row.id - (row.id % 300000))
|
||
bucket.setdefault(five_min_start, []).append({
|
||
'timestamp': int(row.id),
|
||
'open': float(row.open) if row.open is not None else None,
|
||
'high': float(row.high) if row.high is not None else None,
|
||
'low': float(row.low) if row.low is not None else None,
|
||
'close': float(row.close) if row.close is not None else None,
|
||
})
|
||
|
||
self.one_minute_by_5m = bucket
|
||
total_rows = sum(len(v) for v in bucket.values())
|
||
logger.info(f"加载1分钟数据: {total_rows} 根 | 5分钟桶: {len(bucket)}")
|
||
|
||
def should_close_half_by_1m_trend(self, five_min_ts, middle_price, side):
|
||
"""
|
||
1分钟顺序确认中轨平半：
|
||
- 多仓：先到中轨上方，再回踩中轨
|
||
- 空仓：先到中轨下方，再反抽中轨
|
||
"""
|
||
minute_rows = self.one_minute_by_5m.get(five_min_ts, [])
|
||
if not minute_rows:
|
||
return False, None
|
||
|
||
seen_above_middle = False
|
||
seen_below_middle = False
|
||
|
||
for minute in minute_rows:
|
||
m_open = minute['open']
|
||
m_high = minute['high']
|
||
m_low = minute['low']
|
||
m_close = minute['close']
|
||
|
||
if None in (m_open, m_high, m_low, m_close):
|
||
continue
|
||
|
||
minute_time = pd.to_datetime(minute['timestamp'], unit='ms').strftime('%H:%M')
|
||
|
||
if side == 'long':
|
||
# 当前1m开在中轨上方且回踩到中轨，视为有效回踩
|
||
if m_open >= middle_price and m_low <= middle_price:
|
||
return True, f"1m({minute_time})回踩中轨"
|
||
|
||
# 已经到过中轨上方后，再次触及中轨
|
||
if seen_above_middle and m_low <= middle_price:
|
||
return True, f"1m({minute_time})回踩中轨"
|
||
|
||
if m_high >= middle_price:
|
||
seen_above_middle = True
|
||
|
||
else: # short
|
||
# 当前1m开在中轨下方且反抽到中轨，视为有效反抽
|
||
if m_open <= middle_price and m_high >= middle_price:
|
||
return True, f"1m({minute_time})反抽中轨"
|
||
|
||
# 已经到过中轨下方后，再次触及中轨
|
||
if seen_below_middle and m_high >= middle_price:
|
||
return True, f"1m({minute_time})反抽中轨"
|
||
|
||
if m_low <= middle_price:
|
||
seen_below_middle = True
|
||
|
||
return False, None
|
||
|
||
def get_touch_entry_price(self, five_min_ts, direction, touch_price):
|
||
"""
|
||
触轨开仓的保守成交价：
|
||
- 在该5分钟内找到首个触轨1m
|
||
- 用该1m收盘价作为基准
|
||
- 为避免“过于理想”，不允许优于触轨价，再叠加不利滑点
|
||
"""
|
||
minute_rows = self.one_minute_by_5m.get(five_min_ts, [])
|
||
if not minute_rows:
|
||
return self.apply_entry_slippage(touch_price, direction)
|
||
|
||
trigger_close = None
|
||
for minute in minute_rows:
|
||
m_high = minute['high']
|
||
m_low = minute['low']
|
||
m_close = minute['close']
|
||
if None in (m_high, m_low, m_close):
|
||
continue
|
||
|
||
if direction == 'short' and m_high >= touch_price:
|
||
trigger_close = m_close
|
||
break
|
||
if direction == 'long' and m_low <= touch_price:
|
||
trigger_close = m_close
|
||
break
|
||
|
||
if trigger_close is None:
|
||
base_price = touch_price
|
||
elif direction == 'long':
|
||
base_price = max(touch_price, trigger_close)
|
||
else:
|
||
base_price = min(touch_price, trigger_close)
|
||
|
||
return self.apply_entry_slippage(base_price, direction)
|
||
|
||
def clear_delay_reversal(self):
|
||
"""清理延迟反转状态"""
|
||
self.delay_reverse_price = None
|
||
self.delay_reverse_type = None
|
||
self.delay_reverse_kline_index = None
|
||
|
||
def mark_delay_reversal(self, reverse_type, trigger_price, kline_index, timestamp):
|
||
"""记录延迟反转触发信息"""
|
||
self.delay_reverse_type = reverse_type
|
||
self.delay_reverse_price = trigger_price
|
||
self.delay_reverse_kline_index = kline_index
|
||
|
||
if reverse_type == 'long_to_short':
|
||
logger.info(f"[{timestamp}] 多仓触上轨 @ {trigger_price:.2f}，进入延迟反转")
|
||
else:
|
||
logger.info(f"[{timestamp}] 空仓触下轨 @ {trigger_price:.2f}，进入延迟反转")
|
||
|
||
def reverse_position(self, price, new_direction, timestamp, reason):
|
||
"""全平后反向开仓"""
|
||
if self.position == 0:
|
||
self.clear_delay_reversal()
|
||
return False
|
||
|
||
close_side = "多" if self.position > 0 else "空"
|
||
open_side = "多" if new_direction == "long" else "空"
|
||
self.close_position(price, 1.0, timestamp, f"{reason}-平{close_side}")
|
||
open_price = self.apply_entry_slippage(price, new_direction)
|
||
self.open_position(open_price, new_direction, timestamp, f"{reason}-开{open_side}")
|
||
self.mid_closed_half = False
|
||
self.clear_delay_reversal()
|
||
return True
|
||
|
||
def check_delay_reversal_signal(self, i, row, prev_row):
|
||
"""检查延迟反转是否在当前收盘K成立（仅返回信号，不直接执行）"""
|
||
if self.position == 0 or self.delay_reverse_price is None or self.delay_reverse_kline_index is None:
|
||
return None
|
||
|
||
offset = i - self.delay_reverse_kline_index
|
||
# 禁止同K确认，最早次K确认
|
||
if offset <= 0:
|
||
return None
|
||
|
||
high = row['high']
|
||
low = row['low']
|
||
|
||
if self.delay_reverse_type == 'long_to_short':
|
||
# 情况1：触上轨后，次K回调到记录上轨价
|
||
if offset == 1 and low <= self.delay_reverse_price:
|
||
return 'short', "延迟反转-次K回调确认", self.delay_reverse_price
|
||
|
||
# 情况2：持续等待，动态追踪上一根K线条件
|
||
if offset >= 2 and prev_row is not None:
|
||
prev_upper = prev_row['upper']
|
||
prev_touch_upper = pd.notna(prev_upper) and prev_row['high'] >= prev_upper
|
||
if prev_touch_upper:
|
||
if low <= prev_upper:
|
||
return 'short', "延迟反转-上一根触上轨后回调确认", prev_upper
|
||
else:
|
||
prev_body_low = min(prev_row['open'], prev_row['close'])
|
||
if low <= prev_body_low:
|
||
return 'short', "延迟反转-跌破上一根实体确认", prev_body_low
|
||
|
||
elif self.delay_reverse_type == 'short_to_long':
|
||
# 情况1：触下轨后，次K反弹到记录下轨价
|
||
if offset == 1 and high >= self.delay_reverse_price:
|
||
return 'long', "延迟反转-次K反弹确认", self.delay_reverse_price
|
||
|
||
# 情况2：持续等待，动态追踪上一根K线条件
|
||
if offset >= 2 and prev_row is not None:
|
||
prev_lower = prev_row['lower']
|
||
prev_touch_lower = pd.notna(prev_lower) and prev_row['low'] <= prev_lower
|
||
if prev_touch_lower:
|
||
if high >= prev_lower:
|
||
return 'long', "延迟反转-上一根触下轨后反弹确认", prev_lower
|
||
else:
|
||
prev_body_high = max(prev_row['open'], prev_row['close'])
|
||
if high >= prev_body_high:
|
||
return 'long', "延迟反转-突破上一根实体确认", prev_body_high
|
||
|
||
return None
|
||
|
||
def open_position(self, price, direction, timestamp, reason):
|
||
"""开仓或加仓"""
|
||
if self.position_count not in (0, 1):
|
||
return False
|
||
|
||
if self.position_count == 1:
|
||
current_direction = 'long' if self.position > 0 else 'short'
|
||
if direction != current_direction:
|
||
logger.warning("加仓方向不一致，跳过")
|
||
return False
|
||
|
||
margin_ratio = self.margin_ratio_1 if self.position_count == 0 else self.margin_ratio_2
|
||
margin = self.capital * margin_ratio
|
||
if margin <= 0:
|
||
logger.warning(f"[{timestamp}] 资金不足，无法开仓 | 可用资金: {self.capital:.4f}U")
|
||
return False
|
||
|
||
position_size = margin * self.leverage / price
|
||
fee = position_size * price * self.fee_rate
|
||
required = margin + fee
|
||
if self.capital < required:
|
||
logger.warning(
|
||
f"[{timestamp}] 可用资金不足，无法开仓 | 需要: {required:.4f}U | 可用: {self.capital:.4f}U"
|
||
)
|
||
return False
|
||
|
||
# 冻结保证金并扣除手续费
|
||
self.capital -= required
|
||
self.schedule_rebate(fee, timestamp)
|
||
|
||
if self.position_count == 0:
|
||
self.position = position_size if direction == 'long' else -position_size
|
||
self.entry_price = price
|
||
self.total_margin = margin
|
||
self.position_count = 1
|
||
action = f'开{direction}'
|
||
else:
|
||
old_size = abs(self.position)
|
||
new_size = old_size + position_size
|
||
old_value = old_size * self.entry_price
|
||
new_value = position_size * price
|
||
self.entry_price = (old_value + new_value) / new_size
|
||
self.position = new_size if direction == 'long' else -new_size
|
||
self.total_margin += margin
|
||
self.position_count = 2
|
||
action = f'加{direction}'
|
||
|
||
self.mid_closed_half = False
|
||
|
||
self.trades.append({
|
||
'timestamp': timestamp,
|
||
'action': action,
|
||
'price': price,
|
||
'size': position_size,
|
||
'margin': margin,
|
||
'fee': fee,
|
||
'rebate': self.get_rebate_amount(fee),
|
||
'capital': self.capital,
|
||
'reason': reason
|
||
})
|
||
|
||
logger.info(
|
||
f"[{timestamp}] {action} @ {price:.2f} | 仓位: {position_size:.4f} | "
|
||
f"保证金: {margin:.4f}U | 手续费: {fee:.4f}U | 返佣待到账: {self.get_rebate_amount(fee):.4f}U | "
|
||
f"可用资金: {self.capital:.4f}U | {reason}"
|
||
)
|
||
return True
|
||
|
||
def close_position(self, price, ratio, timestamp, reason):
|
||
"""平仓"""
|
||
if self.position == 0:
|
||
return False
|
||
|
||
ratio = min(max(ratio, 0.0), 1.0)
|
||
if ratio == 0:
|
||
return False
|
||
|
||
close_size = abs(self.position) * ratio
|
||
if self.position > 0:
|
||
pnl = close_size * (price - self.entry_price)
|
||
else:
|
||
pnl = close_size * (self.entry_price - price)
|
||
|
||
fee = close_size * price * self.fee_rate
|
||
|
||
released_margin = self.total_margin * ratio
|
||
self.capital += released_margin + pnl - fee
|
||
self.schedule_rebate(fee, timestamp)
|
||
|
||
if ratio >= 0.999:
|
||
self.position = 0
|
||
self.position_count = 0
|
||
self.total_margin = 0
|
||
self.entry_price = 0
|
||
self.mid_closed_half = False
|
||
self.clear_delay_reversal()
|
||
else:
|
||
self.position *= (1 - ratio)
|
||
self.total_margin *= (1 - ratio)
|
||
if abs(self.position) < 1e-12:
|
||
self.position = 0
|
||
self.position_count = 0
|
||
self.total_margin = 0
|
||
self.entry_price = 0
|
||
self.mid_closed_half = False
|
||
self.clear_delay_reversal()
|
||
|
||
self.trades.append({
|
||
'timestamp': timestamp,
|
||
'action': f'平仓{int(ratio*100)}%',
|
||
'price': price,
|
||
'size': close_size,
|
||
'pnl': pnl,
|
||
'fee': fee,
|
||
'rebate': self.get_rebate_amount(fee),
|
||
'capital': self.capital,
|
||
'reason': reason
|
||
})
|
||
|
||
logger.info(f"[{timestamp}] 平仓{int(ratio*100)}% @ {price:.2f} | "
|
||
f"盈亏: {pnl:.4f}U | 手续费: {fee:.4f}U | 返佣待到账: {self.get_rebate_amount(fee):.4f}U | "
|
||
f"可用资金: {self.capital:.4f}U | {reason}")
|
||
return True
|
||
|
||
def check_stop_loss(self, high, low):
|
||
"""检查当前收盘K是否触发止损信号"""
|
||
if self.position == 0:
|
||
return False
|
||
|
||
stop_price = low if self.position > 0 else high
|
||
if self.position > 0:
|
||
unrealized_pnl = abs(self.position) * (stop_price - self.entry_price)
|
||
else:
|
||
unrealized_pnl = abs(self.position) * (self.entry_price - stop_price)
|
||
|
||
return unrealized_pnl <= -self.total_margin * self.stop_loss_ratio
|
||
|
||
def run_backtest(self, start_date, end_date):
|
||
"""运行回测（开仓当K触发，平仓/止损仍按下一根K开盘执行）"""
|
||
# 重置状态，支持同一实例重复回测
|
||
self.capital = self.initial_capital
|
||
self.position = 0
|
||
self.position_count = 0
|
||
self.entry_price = 0
|
||
self.total_margin = 0
|
||
self.mid_closed_half = False
|
||
self.trades = []
|
||
self.daily_pnl = []
|
||
self.pending_rebates = []
|
||
self.total_rebate_credited = 0.0
|
||
self.clear_delay_reversal()
|
||
|
||
logger.info(f"{'='*80}")
|
||
logger.info(f"开始回测: {start_date} ~ {end_date}")
|
||
logger.info(f"初始资金: {self.initial_capital}U | 杠杆: {self.leverage}x | BB({self.bb_period}, {self.bb_std})")
|
||
logger.info(f"{'='*80}")
|
||
|
||
# 从数据库加载数据
|
||
start_dt = pd.Timestamp(start_date)
|
||
end_dt = pd.Timestamp(end_date)
|
||
if isinstance(end_date, str) and len(end_date) <= 10:
|
||
end_dt = end_dt + pd.Timedelta(days=1) - pd.Timedelta(milliseconds=1)
|
||
|
||
self.current_run_label = f"{start_dt.strftime('%Y%m%d')}_{end_dt.strftime('%Y%m%d')}"
|
||
|
||
start_ts = int(start_dt.timestamp() * 1000)
|
||
end_ts = int(end_dt.timestamp() * 1000)
|
||
|
||
query = BitMartETH5M.select().where(
|
||
(BitMartETH5M.id >= start_ts) & (BitMartETH5M.id <= end_ts)
|
||
).order_by(BitMartETH5M.id)
|
||
|
||
data = []
|
||
for row in query:
|
||
data.append({
|
||
'timestamp': row.id,
|
||
'open': row.open,
|
||
'high': row.high,
|
||
'low': row.low,
|
||
'close': row.close
|
||
})
|
||
|
||
if not data:
|
||
logger.error("没有找到数据！")
|
||
return None
|
||
|
||
df = pd.DataFrame(data)
|
||
df['datetime'] = pd.to_datetime(df['timestamp'], unit='ms')
|
||
|
||
logger.info(f"加载数据: {len(df)} 根K线")
|
||
logger.info(f"时间范围: {df['datetime'].min()} ~ {df['datetime'].max()}")
|
||
|
||
# 计算布林带
|
||
df = self.calculate_bollinger_bands(df)
|
||
|
||
if len(df) <= self.bb_period + 1:
|
||
logger.error("数据不足，无法执行回测")
|
||
return None
|
||
|
||
# 逐根K线回测（开仓当K触发，平仓/止损下一K开盘执行）
|
||
for i in range(self.bb_period, len(df) - 1):
|
||
row = df.iloc[i]
|
||
prev_row = df.iloc[i-1] if i > 0 else None
|
||
next_row = df.iloc[i + 1]
|
||
|
||
signal_dt = row['datetime']
|
||
signal_ts = signal_dt.strftime('%Y-%m-%d %H:%M')
|
||
five_min_ts = int(row['timestamp'])
|
||
execute_ts = next_row['datetime'].strftime('%Y-%m-%d %H:%M')
|
||
next_open = float(next_row['open']) if pd.notna(next_row['open']) else None
|
||
|
||
high = row['high']
|
||
low = row['low']
|
||
upper = row['upper']
|
||
lower = row['lower']
|
||
middle = row['middle']
|
||
|
||
# 先处理当前收盘时刻返佣到账
|
||
self.apply_pending_rebates(signal_dt)
|
||
|
||
if pd.isna(upper) or pd.isna(lower) or pd.isna(middle):
|
||
continue
|
||
if next_open is None:
|
||
continue
|
||
|
||
# 检查止损（收盘确认，下一K开盘平仓）
|
||
if self.check_stop_loss(high, low):
|
||
logger.warning(f"[{signal_ts}] 触发止损信号，下一K开盘执行")
|
||
self.close_position(next_open, 1.0, execute_ts, f"止损-收盘确认({signal_ts})")
|
||
continue
|
||
|
||
# 已处于延迟反转状态时，先检查确认逻辑
|
||
if self.delay_reverse_price is not None:
|
||
reversal_signal = self.check_delay_reversal_signal(i, row, prev_row)
|
||
if reversal_signal is not None and self.position != 0:
|
||
new_direction, reason, reversal_price = reversal_signal
|
||
if reversal_price is None or pd.isna(reversal_price):
|
||
reversal_price = float(row['close'])
|
||
close_side = "多" if self.position > 0 else "空"
|
||
open_side = "多" if new_direction == 'long' else "空"
|
||
self.close_position(
|
||
reversal_price,
|
||
1.0,
|
||
signal_ts,
|
||
f"{reason}-当K确认({signal_ts})-平{close_side}"
|
||
)
|
||
open_price = self.apply_entry_slippage(reversal_price, new_direction)
|
||
self.open_position(
|
||
open_price,
|
||
new_direction,
|
||
signal_ts,
|
||
f"{reason}-当K确认({signal_ts})-开{open_side}"
|
||
)
|
||
self.mid_closed_half = False
|
||
self.clear_delay_reversal()
|
||
continue
|
||
|
||
# === 中轨平仓逻辑 ===
|
||
if self.position != 0:
|
||
had_mid_closed_half = self.mid_closed_half
|
||
if self.position > 0: # 多仓
|
||
# 回到开仓价全平+反手（仅在此前已平半的前提下触发）
|
||
if had_mid_closed_half and low <= self.entry_price:
|
||
self.close_position(next_open, 1.0, execute_ts, f"回开仓价全平-收盘确认({signal_ts})")
|
||
entry_price = self.apply_entry_slippage(next_open, 'short')
|
||
self.open_position(entry_price, 'short', execute_ts, f"回开仓价反手开空-收盘确认({signal_ts})")
|
||
self.mid_closed_half = False
|
||
continue
|
||
# 触中轨平半（收盘确认）
|
||
if not had_mid_closed_half and low <= middle <= high:
|
||
self.close_position(next_open, 0.5, execute_ts, f"触中轨平50%-收盘确认({signal_ts})")
|
||
self.mid_closed_half = True
|
||
continue
|
||
|
||
else: # 空仓
|
||
# 回到开仓价全平+反手（仅在此前已平半的前提下触发）
|
||
if had_mid_closed_half and high >= self.entry_price:
|
||
self.close_position(next_open, 1.0, execute_ts, f"回开仓价全平-收盘确认({signal_ts})")
|
||
entry_price = self.apply_entry_slippage(next_open, 'long')
|
||
self.open_position(entry_price, 'long', execute_ts, f"回开仓价反手开多-收盘确认({signal_ts})")
|
||
self.mid_closed_half = False
|
||
continue
|
||
# 触中轨平半（收盘确认）
|
||
if not had_mid_closed_half and low <= middle <= high:
|
||
self.close_position(next_open, 0.5, execute_ts, f"触中轨平50%-收盘确认({signal_ts})")
|
||
self.mid_closed_half = True
|
||
continue
|
||
|
||
# === 开仓与加仓逻辑 ===
|
||
if self.position == 0: # 空仓
|
||
self.clear_delay_reversal()
|
||
|
||
# 触上轨开空
|
||
if high >= upper:
|
||
entry_price = self.get_touch_entry_price(five_min_ts, 'short', upper)
|
||
self.open_position(entry_price, 'short', signal_ts, f"触上轨开空-当K触发({signal_ts})")
|
||
|
||
# 触下轨开多
|
||
elif low <= lower:
|
||
entry_price = self.get_touch_entry_price(five_min_ts, 'long', lower)
|
||
self.open_position(entry_price, 'long', signal_ts, f"触下轨开多-当K触发({signal_ts})")
|
||
continue
|
||
|
||
# 有持仓：先检查是否触发延迟反转（核心）
|
||
if self.position > 0 and high >= upper:
|
||
self.mark_delay_reversal('long_to_short', upper, i, signal_ts)
|
||
continue
|
||
|
||
elif self.position < 0 and low <= lower:
|
||
self.mark_delay_reversal('short_to_long', lower, i, signal_ts)
|
||
continue
|
||
|
||
# 进入延迟反转等待后，不再执行加仓
|
||
if self.delay_reverse_price is not None:
|
||
continue
|
||
|
||
# 同向加仓最多1次
|
||
if self.position_count == 1:
|
||
if self.position > 0 and low <= lower:
|
||
entry_price = self.get_touch_entry_price(five_min_ts, 'long', lower)
|
||
self.open_position(entry_price, 'long', signal_ts, f"触下轨加多-当K触发({signal_ts})")
|
||
elif self.position < 0 and high >= upper:
|
||
entry_price = self.get_touch_entry_price(five_min_ts, 'short', upper)
|
||
self.open_position(entry_price, 'short', signal_ts, f"触上轨加空-当K触发({signal_ts})")
|
||
|
||
# 回测末尾再处理一次返佣到账
|
||
self.apply_pending_rebates(df.iloc[-1]['datetime'])
|
||
|
||
# 最后平仓
|
||
if self.position != 0:
|
||
final_price = df.iloc[-1]['close']
|
||
final_time = df.iloc[-1]['datetime'].strftime('%Y-%m-%d %H:%M')
|
||
self.close_position(final_price, 1.0, final_time, "回测结束平仓")
|
||
|
||
# 生成报告
|
||
return self.generate_report(df)
|
||
|
||
def generate_report(self, df):
|
||
"""生成回测报告"""
|
||
logger.info(f"\n{'='*80}")
|
||
logger.info("回测报告")
|
||
logger.info(f"{'='*80}")
|
||
|
||
# 基本统计
|
||
total_trades = len([t for t in self.trades if '开' in t['action']])
|
||
win_trades = len([t for t in self.trades if '平' in t['action'] and t.get('pnl', 0) > 0])
|
||
loss_trades = len([t for t in self.trades if '平' in t['action'] and t.get('pnl', 0) < 0])
|
||
|
||
total_pnl = sum([t.get('pnl', 0) for t in self.trades])
|
||
total_fee = sum([t.get('fee', 0) for t in self.trades])
|
||
total_rebate_expected = sum([t.get('rebate', 0) for t in self.trades if t.get('fee', 0) > 0])
|
||
pending_rebate = sum([x['amount'] for x in self.pending_rebates])
|
||
realized_net_fee = total_fee - self.total_rebate_credited
|
||
|
||
final_capital = self.capital
|
||
roi = (final_capital - self.initial_capital) / self.initial_capital * 100
|
||
|
||
logger.info(f"初始资金: {self.initial_capital:.2f}U")
|
||
logger.info(f"最终资金: {final_capital:.2f}U")
|
||
logger.info(f"总盈亏: {total_pnl:.2f}U")
|
||
logger.info(f"总手续费(开平全额): {total_fee:.2f}U")
|
||
logger.info(f"返佣应返总额: {total_rebate_expected:.2f}U")
|
||
logger.info(f"返佣已到账: {self.total_rebate_credited:.2f}U")
|
||
logger.info(f"返佣待到账: {pending_rebate:.2f}U")
|
||
logger.info(f"已实现净手续费: {realized_net_fee:.2f}U")
|
||
logger.info(f"净收益: {final_capital - self.initial_capital:.2f}U")
|
||
logger.info(f"收益率: {roi:.2f}%")
|
||
logger.info(f"总交易次数: {total_trades}")
|
||
logger.info(f"盈利次数: {win_trades}")
|
||
logger.info(f"亏损次数: {loss_trades}")
|
||
if win_trades + loss_trades > 0:
|
||
logger.info(f"胜率: {win_trades/(win_trades+loss_trades)*100:.2f}%")
|
||
|
||
# 保存交易记录
|
||
trades_df = pd.DataFrame(self.trades)
|
||
output_dir = Path(__file__).parent / 'backtest_outputs' / 'trades'
|
||
output_dir.mkdir(parents=True, exist_ok=True)
|
||
output_file = output_dir / f'bb_backtest_{self.current_run_label}_trades.csv'
|
||
trades_df.to_csv(output_file, index=False, encoding='utf-8-sig')
|
||
logger.info(f"\n交易记录已保存到: {output_file}")
|
||
|
||
return {
|
||
'initial_capital': self.initial_capital,
|
||
'final_capital': final_capital,
|
||
'total_pnl': total_pnl,
|
||
'total_fee': total_fee,
|
||
'total_rebate_expected': total_rebate_expected,
|
||
'total_rebate_credited': self.total_rebate_credited,
|
||
'pending_rebate': pending_rebate,
|
||
'realized_net_fee': realized_net_fee,
|
||
'roi': roi,
|
||
'total_trades': total_trades,
|
||
'win_trades': win_trades,
|
||
'loss_trades': loss_trades,
|
||
'trades_file': str(output_file),
|
||
'trades': self.trades
|
||
}
|
||
|
||
|
||
if __name__ == '__main__':
|
||
# 连接数据库
|
||
db.connect(reuse_if_open=True)
|
||
|
||
try:
|
||
# 创建回测实例
|
||
backtest = BollingerBandBacktest()
|
||
|
||
# 运行回测（2026年全年）
|
||
result = backtest.run_backtest('2026-01-01', '2026-12-31')
|
||
|
||
if result:
|
||
logger.success(f"\n回测完成！最终收益率: {result['roi']:.2f}%")
|
||
|
||
finally:
|
||
db.close()
|