freedakgmail
1291 lines
63 KiB
Python
1291 lines
63 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
推荐算法回测脚本 v4.1 — 基于预扫描结果表 + 智能过滤优化 + 纯技术止盈止损
|
||
|
||
v4 新增：
|
||
- 买入过滤: min_buy_rate / min_buy_triggered
|
||
- 盈利保护: 浮盈超过阈值时不被弱卖出信号清仓
|
||
- 跟踪止盈: 利润达到阈值后激活，回撤固定幅度才卖
|
||
v4.1 新增：
|
||
- ignore_sell_signal: 完全忽略推荐卖出(MACD死叉)，用纯技术止损
|
||
- max_hold_days: 最大持仓天数（强制平仓）
|
||
- 可配置仓位参数: shares_per_trade / position_amount / max_concurrent
|
||
- 回测时自动检测扫描数据覆盖范围
|
||
|
||
依赖: 需先运行 scan_history.py 将扫描结果入库。
|
||
|
||
用法:
|
||
# v3 兼容模式
|
||
./venv/bin/python backtest_recommend.py
|
||
|
||
# v4.1 纯技术模式（忽略推荐卖出信号，改用跟踪止盈+止损）
|
||
./venv/bin/python backtest_recommend.py --ignore-sell --trailing-start 8 --trailing-gap 3 --stop-loss 5
|
||
./venv/bin/python backtest_recommend.py --ignore-sell --trailing-start 6 --trailing-gap 3 --stop-loss 8 --max-hold 30
|
||
./venv/bin/python backtest_recommend.py --ignore-sell --min-triggered 2 --trailing-start 8 --trailing-gap 3 --stop-loss 5
|
||
"""
|
||
import sys
|
||
import os
|
||
import json
|
||
import argparse
|
||
from datetime import datetime, date, timedelta
|
||
from collections import defaultdict
|
||
|
||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||
|
||
import psycopg2
|
||
from config import Config
|
||
|
||
# ─── 核心参数（默认值，可通过 run_backtest kwargs 覆盖）─────
|
||
SHARES_PER_TRADE = 1000
|
||
MAX_BUYS_PER_DAY = 2
|
||
MAX_POSITION_AMOUNT = 30000
|
||
MAX_CONCURRENT_POSITIONS = 8
|
||
SELL_COOLDOWN_DAYS = 3
|
||
PRICE_MIN = 2.0
|
||
PRICE_MAX = 100.0
|
||
START_DATE = date(2026, 1, 2)
|
||
|
||
|
||
def get_db_conn():
|
||
return psycopg2.connect(
|
||
host=Config.DB_HOST, port=Config.DB_PORT,
|
||
dbname=Config.DB_NAME, user=Config.DB_USER, password=Config.DB_PASSWORD,
|
||
)
|
||
|
||
|
||
def get_trading_days(conn, start: date, end: date):
|
||
with conn.cursor() as cur:
|
||
cur.execute("""
|
||
SELECT DISTINCT trade_date::date FROM stock_kline_daily
|
||
WHERE trade_date >= %s AND trade_date <= %s ORDER BY trade_date
|
||
""", (start, end))
|
||
return [r[0] for r in cur.fetchall()]
|
||
|
||
|
||
def get_day_ohlc(conn, trade_date: date):
|
||
"""返回 code -> (open, high, low, close) 的字典"""
|
||
with conn.cursor() as cur:
|
||
cur.execute("SELECT code, open, high, low, close FROM stock_kline_daily WHERE trade_date = %s", (trade_date,))
|
||
return {r[0]: (float(r[1]), float(r[2]), float(r[3]), float(r[4])) for r in cur.fetchall()}
|
||
|
||
|
||
def get_5min_prices(conn, trade_date: date):
|
||
"""获取指定交易日 09:35 和 13:40 的5分钟K线收盘价
|
||
返回: {code: {'buy': price_at_09:35, 'sell': price_at_13:40}}
|
||
(向后兼容接口，但新版使用 get_5min_price_at 直接按时间点查询)
|
||
"""
|
||
from datetime import time as dt_time
|
||
result = {}
|
||
dt_0935 = datetime.combine(trade_date, dt_time(9, 35))
|
||
dt_1340 = datetime.combine(trade_date, dt_time(13, 40))
|
||
|
||
with conn.cursor() as cur:
|
||
cur.execute("""
|
||
SELECT code, dt, close FROM stock_kline_5min
|
||
WHERE dt IN (%s, %s)
|
||
""", (dt_0935, dt_1340))
|
||
for row in cur.fetchall():
|
||
code, dt, price = row[0], row[1], float(row[2])
|
||
if code not in result:
|
||
result[code] = {}
|
||
if dt.hour == 9 and dt.minute == 35:
|
||
result[code]['buy'] = price
|
||
elif dt.hour == 13 and dt.minute == 40:
|
||
result[code]['sell'] = price
|
||
return result
|
||
|
||
|
||
def get_5min_price_at(conn, trade_date: date, time_str: str):
|
||
"""获取指定交易日指定时间点的5分钟K线收盘价
|
||
time_str: 如 '09:35', '10:00', '14:30', '15:00'
|
||
返回: {code: price}
|
||
"""
|
||
from datetime import time as dt_time
|
||
h, m = int(time_str.split(':')[0]), int(time_str.split(':')[1])
|
||
dt_target = datetime.combine(trade_date, dt_time(h, m))
|
||
|
||
with conn.cursor() as cur:
|
||
cur.execute("SELECT code, close FROM stock_kline_5min WHERE dt = %s", (dt_target,))
|
||
return {r[0]: float(r[1]) for r in cur.fetchall()}
|
||
|
||
|
||
def load_scan_results(conn, scan_date: date, scan_time: str):
|
||
"""从 stock_scan_history 加载某日某时段的扫描结果"""
|
||
with conn.cursor() as cur:
|
||
cur.execute("""
|
||
SELECT code, recommend_display, recommend_type, recommend_reason,
|
||
recommend_rate, triggered_count, indicators
|
||
FROM stock_scan_history
|
||
WHERE scan_date = %s AND scan_time = %s
|
||
""", (scan_date, scan_time))
|
||
result = {}
|
||
for r in cur.fetchall():
|
||
indicators = r[6] if r[6] else {}
|
||
holding_info = indicators.get('_holding', {})
|
||
result[r[0]] = {
|
||
'display': r[1], 'type': r[2], 'reason': r[3],
|
||
'rate': r[4] or 0, 'triggered': r[5] or 0,
|
||
'holding_display': holding_info.get('display', '观望'),
|
||
'holding_reason': holding_info.get('reason', ''),
|
||
'holding_rate': holding_info.get('rate', 0),
|
||
}
|
||
return result
|
||
|
||
|
||
# ─── 数据预加载（一次性加载全部数据到内存，避免反复查询DB）─────
|
||
def preload_all_data(conn, start: date, end: date, use_5min=False, full_5min=False):
|
||
"""
|
||
预加载回测所需的全部数据到内存。
|
||
参数:
|
||
use_5min: 是否加载5分钟K线数据
|
||
full_5min: 是否加载全部48个时间点(True) 还是仅10:00/15:00(False)
|
||
返回 dict:
|
||
'trading_days': [date, ...]
|
||
'ohlc': {date: {code: (o,h,l,c)}}
|
||
'5min': {(date, time_str): {code: price}} -- 新结构!
|
||
'scan': {(date, time_str): {code: info_dict}}
|
||
"""
|
||
import time as _t
|
||
t0 = _t.time()
|
||
|
||
# 1) 交易日
|
||
trading_days = get_trading_days(conn, start, end)
|
||
print(f" [preload] 交易日: {len(trading_days)} 天", flush=True)
|
||
|
||
# 2) 日线 OHLC — 批量加载
|
||
ohlc_all = {}
|
||
with conn.cursor() as cur:
|
||
cur.execute("""
|
||
SELECT trade_date::date, code, open, high, low, close
|
||
FROM stock_kline_daily
|
||
WHERE trade_date >= %s AND trade_date <= %s
|
||
""", (start, end))
|
||
for r in cur.fetchall():
|
||
d = r[0]
|
||
if d not in ohlc_all:
|
||
ohlc_all[d] = {}
|
||
ohlc_all[d][r[1]] = (float(r[2]), float(r[3]), float(r[4]), float(r[5]))
|
||
print(f" [preload] 日线OHLC: {sum(len(v) for v in ohlc_all.values()):,} 条", flush=True)
|
||
|
||
# 3) 5分钟K线 — 新结构: {(date, time_str): {code: price}}
|
||
fivemin_all = {}
|
||
if use_5min:
|
||
with conn.cursor() as cur:
|
||
if full_5min:
|
||
# 加载全部48个时间点
|
||
cur.execute("""
|
||
SELECT dt, code, close FROM stock_kline_5min
|
||
WHERE dt::date >= %s AND dt::date <= %s
|
||
""", (start, end))
|
||
else:
|
||
# 加载常用时间点: 09:35(最优买入), 10:00(旧默认), 13:40(最优卖出), 15:00(旧默认)
|
||
cur.execute("""
|
||
SELECT dt, code, close FROM stock_kline_5min
|
||
WHERE dt::date >= %s AND dt::date <= %s
|
||
AND (
|
||
(EXTRACT(hour FROM dt) = 9 AND EXTRACT(minute FROM dt) = 35)
|
||
OR (EXTRACT(hour FROM dt) = 10 AND EXTRACT(minute FROM dt) = 0)
|
||
OR (EXTRACT(hour FROM dt) = 13 AND EXTRACT(minute FROM dt) = 40)
|
||
OR (EXTRACT(hour FROM dt) = 15 AND EXTRACT(minute FROM dt) = 0)
|
||
)
|
||
""", (start, end))
|
||
for row in cur.fetchall():
|
||
dt_val, code, price = row[0], row[1], float(row[2])
|
||
d = dt_val.date() if hasattr(dt_val, 'date') else dt_val
|
||
t_str = f"{dt_val.hour:02d}:{dt_val.minute:02d}"
|
||
key = (d, t_str)
|
||
if key not in fivemin_all:
|
||
fivemin_all[key] = {}
|
||
fivemin_all[key][code] = price
|
||
total_5m = sum(len(v) for v in fivemin_all.values())
|
||
n_slots = len(set(k[1] for k in fivemin_all.keys()))
|
||
print(f" [preload] 5分钟K线: {total_5m:,} 条 ({n_slots} 个时间点)", flush=True)
|
||
|
||
# 4) 扫描结果 — 批量加载
|
||
scan_all = {}
|
||
with conn.cursor() as cur:
|
||
cur.execute("""
|
||
SELECT scan_date, scan_time, code, recommend_display, recommend_type,
|
||
recommend_reason, recommend_rate, triggered_count, indicators
|
||
FROM stock_scan_history
|
||
WHERE scan_date >= %s AND scan_date <= %s
|
||
""", (start, end))
|
||
for r in cur.fetchall():
|
||
key = (r[0], r[1])
|
||
if key not in scan_all:
|
||
scan_all[key] = {}
|
||
indicators = r[8] if r[8] else {}
|
||
holding_info = indicators.get('_holding', {})
|
||
scan_all[key][r[2]] = {
|
||
'display': r[3], 'type': r[4], 'reason': r[5],
|
||
'rate': r[6] or 0, 'triggered': r[7] or 0,
|
||
'holding_display': holding_info.get('display', '观望'),
|
||
'holding_reason': holding_info.get('reason', ''),
|
||
'holding_rate': holding_info.get('rate', 0),
|
||
}
|
||
total_scan = sum(len(v) for v in scan_all.values())
|
||
elapsed = _t.time() - t0
|
||
print(f" [preload] 扫描结果: {total_scan:,} 条 ({len(scan_all)} 个时段)", flush=True)
|
||
print(f" [preload] 完成! 耗时 {elapsed:.1f}s", flush=True)
|
||
|
||
return {
|
||
'trading_days': trading_days,
|
||
'ohlc': ohlc_all,
|
||
'5min': fivemin_all,
|
||
'scan': scan_all,
|
||
}
|
||
|
||
|
||
# ─── 统计指标计算 ─────────────────────────────────────
|
||
def calc_stats(trades, start_date, end_date, equity_series=None, max_capital_deployed=0):
|
||
total_in = 0.0
|
||
total_out = 0.0
|
||
closed_trades = []
|
||
open_buys = {}
|
||
wins = losses = flat = 0
|
||
|
||
for t in trades:
|
||
act = t['action']
|
||
code = t['code']
|
||
if act in ('买入', '加仓'):
|
||
total_in += t['amount']
|
||
if code not in open_buys:
|
||
open_buys[code] = {'cost': 0, 'shares': 0, 'first_buy': t['date']}
|
||
open_buys[code]['cost'] += t['amount']
|
||
open_buys[code]['shares'] += t['shares']
|
||
elif act == '清仓':
|
||
total_out += t.get('amount', 0)
|
||
profit = t.get('profit', 0)
|
||
buy_info = open_buys.pop(code, None)
|
||
first_buy = buy_info['first_buy'] if buy_info else t['date']
|
||
sell_date = t['date']
|
||
if isinstance(first_buy, str):
|
||
first_buy = datetime.strptime(first_buy, '%Y-%m-%d').date()
|
||
if isinstance(sell_date, str):
|
||
sell_date = datetime.strptime(sell_date, '%Y-%m-%d').date()
|
||
hold_days = (sell_date - first_buy).days
|
||
closed_trades.append({
|
||
'code': code, 'buy_date': first_buy, 'sell_date': sell_date,
|
||
'cost': buy_info['cost'] if buy_info else 0,
|
||
'revenue': t.get('amount', 0), 'profit': profit,
|
||
'hold_days': hold_days, 'reason': t.get('reason', ''),
|
||
})
|
||
if profit > 0:
|
||
wins += 1
|
||
elif profit < 0:
|
||
losses += 1
|
||
else:
|
||
flat += 1
|
||
|
||
total_closed = wins + losses + flat
|
||
win_rate = (wins / total_closed * 100) if total_closed > 0 else 0
|
||
avg_hold = (sum(ct['hold_days'] for ct in closed_trades) / len(closed_trades)) if closed_trades else 0
|
||
profit = total_out - total_in
|
||
pct = (profit / total_in * 100) if total_in > 0 else 0
|
||
days = (end_date - start_date).days
|
||
|
||
# v4.2: 真实资金收益率（基于最大同时占用资金）
|
||
capital_pct = (profit / max_capital_deployed * 100) if max_capital_deployed > 0 else 0
|
||
|
||
# 年化: 短期(<90天)用简单年化, 长期用复利年化(CAGR)
|
||
if days >= 90 and max_capital_deployed > 0 and (max_capital_deployed + profit) > 0:
|
||
capital_ann = (pow(1 + profit / max_capital_deployed, 365 / days) - 1) * 100
|
||
capital_ann_method = 'compound'
|
||
elif days > 0 and max_capital_deployed > 0:
|
||
capital_ann = capital_pct * (365 / days) # 简单年化
|
||
capital_ann_method = 'simple'
|
||
else:
|
||
capital_ann = 0.0
|
||
capital_ann_method = 'N/A'
|
||
|
||
# 周转收益率（向后兼容）
|
||
if days >= 90 and total_in > 0 and (total_in + profit) > 0:
|
||
turnover_ann = (pow((total_in + profit) / total_in, 365 / days) - 1) * 100
|
||
turnover_ann_method = 'compound'
|
||
elif days > 0 and total_in > 0:
|
||
turnover_ann = pct * (365 / days) # 简单年化
|
||
turnover_ann_method = 'simple'
|
||
else:
|
||
turnover_ann = 0.0
|
||
turnover_ann_method = 'N/A'
|
||
|
||
# 最大回撤
|
||
max_drawdown = 0.0
|
||
max_drawdown_pct = 0.0
|
||
if equity_series:
|
||
peak = equity_series[0]
|
||
for eq in equity_series:
|
||
if eq > peak:
|
||
peak = eq
|
||
dd = peak - eq
|
||
if dd > max_drawdown:
|
||
max_drawdown = dd
|
||
max_drawdown_pct = round((max_drawdown / max_capital_deployed * 100), 2) \
|
||
if max_capital_deployed > 0 else 0.0
|
||
|
||
avg_win = (sum(ct['profit'] for ct in closed_trades if ct['profit'] > 0) / wins) if wins > 0 else 0
|
||
avg_loss = (sum(ct['profit'] for ct in closed_trades if ct['profit'] < 0) / losses) if losses > 0 else 0
|
||
total_loss = abs(sum(ct['profit'] for ct in closed_trades if ct['profit'] < 0))
|
||
total_gain = abs(sum(ct['profit'] for ct in closed_trades if ct['profit'] > 0))
|
||
profit_factor = (total_gain / total_loss) if total_loss > 0 else 999.99
|
||
|
||
stock_pnl = {}
|
||
for ct in closed_trades:
|
||
c = ct['code']
|
||
if c not in stock_pnl:
|
||
stock_pnl[c] = {'profit': 0, 'trades': 0, 'wins': 0}
|
||
stock_pnl[c]['profit'] += ct['profit']
|
||
stock_pnl[c]['trades'] += 1
|
||
if ct['profit'] > 0:
|
||
stock_pnl[c]['wins'] += 1
|
||
|
||
return {
|
||
'total_in': total_in, 'total_out': total_out,
|
||
'profit': profit, 'profit_pct': round(pct, 2),
|
||
'annualized_pct': round(turnover_ann, 2),
|
||
'annualized_method': turnover_ann_method, # v5: 年化方法
|
||
'max_capital': round(max_capital_deployed, 2), # v4.2: 最大占用资金
|
||
'capital_pct': round(capital_pct, 2), # v4.2: 真实资金收益率
|
||
'capital_ann_pct': round(capital_ann, 2), # v4.2: 真实年化
|
||
'capital_ann_method': capital_ann_method, # v5: 年化方法
|
||
'trade_count': len(trades), 'closed_count': total_closed,
|
||
'wins': wins, 'losses': losses, 'flat': flat,
|
||
'win_rate': round(win_rate, 2), 'avg_hold_days': round(avg_hold, 1),
|
||
'max_drawdown': round(max_drawdown, 2),
|
||
'max_drawdown_pct': max_drawdown_pct,
|
||
'avg_win': round(avg_win, 2), 'avg_loss': round(avg_loss, 2),
|
||
'profit_factor': round(profit_factor, 2),
|
||
'days': days, 'closed_trades': closed_trades, 'stock_pnl': stock_pnl,
|
||
}
|
||
|
||
|
||
# ─── 核心回测引擎 v6.0 ─────────────────────────────────
|
||
def run_backtest(conn, start_date=None, end_date=None,
|
||
preloaded=None, # 预加载数据 (from preload_all_data)
|
||
take_profit_pct=None, stop_loss_pct=None,
|
||
# ── v4 参数 ──
|
||
min_buy_rate=0,
|
||
min_buy_triggered=0,
|
||
profit_protect_pct=0,
|
||
sell_confirm_rate=0,
|
||
trailing_start_pct=0,
|
||
trailing_gap_pct=0,
|
||
# ── v4.1 新增参数 ──
|
||
ignore_sell_signal=False, # 完全忽略推荐卖出信号
|
||
max_hold_days=0, # 最大持仓天数 (0=不限)
|
||
shares_per_trade=None, # 每笔股数 (None=用默认值)
|
||
position_amount=None, # 单只上限 (None=用默认值)
|
||
max_concurrent=None, # 最大并发持仓 (None=用默认值)
|
||
# ── v4.2 新增参数 ──
|
||
sell_confirm_days=0, # 连续N天卖出信号才执行 (0=立即)
|
||
# ── v5 新增参数 ──
|
||
use_5min_prices=False, # 使用5分钟K线实时价格
|
||
# ── v5.1 新增：总资金约束模式 ──
|
||
total_capital=0, # 总本金 (0=不限,>0 启用现金追踪)
|
||
max_buys_per_day=None, # 每日最多买入 (None=用默认值)
|
||
price_min=None, # 股价下限 (None=用默认值)
|
||
price_max=None, # 股价上限 (None=用默认值)
|
||
# ── v5.2 新增：动态仓位管理 ──
|
||
position_pct=0, # 单笔仓位占总资金百分比 (0=用固定股数, >0=动态仓位)
|
||
signal_weight=False, # 是否根据信号强度调整仓位 (True=强信号加仓)
|
||
# ── v6.0 新增：连涨保护 & 高级止盈止损 ──
|
||
momentum_tp=False, # 连涨保护: 当连涨≥N天且浮盈≥TP时转跟踪止盈(不立即卖)
|
||
momentum_days=3, # 判定连涨的天数 (≥N天收盘连涨)
|
||
momentum_trail_start=0, # 连涨时跟踪止盈启动线(0=用TP作为启动线)
|
||
momentum_trail_gap=3, # 连涨时跟踪止盈回撤幅度(%)
|
||
breakeven_at=0, # 移动止损: 浮盈≥N%后止损线提升到保本(0=关闭)
|
||
profit_lock_pct=0, # 利润锁定: 浮盈≥N%后止损线提升到N/2%(0=关闭)
|
||
partial_exit_pct=0, # 部分止盈: 到达TP时卖出该比例(0=全卖, 50=卖一半)
|
||
no_timeout_if_rising=False, # 超时保护: 如果股票在涨(浮盈>0且连涨)则不超时平仓
|
||
# ── v7.0 新增：交易时点优化 (网格搜索最优) ──
|
||
buy_time='09:35', # 买入时间点 (最优: 09:35 开盘第一根5minK线)
|
||
sell_time='13:40', # 卖出/估值时间点 (最优: 13:40 午后开盘35分钟)
|
||
verbose=False):
|
||
|
||
if start_date is None:
|
||
start_date = START_DATE
|
||
if end_date is None:
|
||
end_date = date.today()
|
||
|
||
# 可配参数回退到全局默认值
|
||
_shares = shares_per_trade or SHARES_PER_TRADE
|
||
_pos_amt = position_amount or MAX_POSITION_AMOUNT
|
||
_max_con = max_concurrent or MAX_CONCURRENT_POSITIONS
|
||
_max_buys = max_buys_per_day if max_buys_per_day is not None else MAX_BUYS_PER_DAY
|
||
_price_min = price_min if price_min is not None else PRICE_MIN
|
||
_price_max = price_max if price_max is not None else PRICE_MAX
|
||
|
||
# v5.2: 动态仓位管理模式
|
||
_dynamic_pos = False # 是否使用动态仓位
|
||
if total_capital > 0 and position_pct > 0:
|
||
_dynamic_pos = True
|
||
_shares = 0 # 标记为动态，不用固定值
|
||
|
||
# v5.1: 总资金约束模式 — 去掉人为限制
|
||
if total_capital > 0:
|
||
if position_amount is None:
|
||
_pos_amt = total_capital # 单只上限 = 总资金（无限）
|
||
if max_concurrent is None:
|
||
_max_con = 9999 # 持仓数无限
|
||
if max_buys_per_day is None:
|
||
_max_buys = 9999 # 每日买入无限
|
||
if price_min is None:
|
||
_price_min = 0 # 股价无下限
|
||
if price_max is None:
|
||
_price_max = 999999 # 股价无上限
|
||
|
||
cash_balance = float(total_capital) if total_capital > 0 else None # None=不跟踪
|
||
|
||
# v5.3: 支持预加载数据（内存回测，无DB查询）
|
||
_preloaded = preloaded is not None
|
||
if _preloaded:
|
||
# 从预加载数据中筛选指定日期范围
|
||
all_days = preloaded['trading_days']
|
||
trading_days = [d for d in all_days if start_date <= d <= end_date]
|
||
_ohlc_cache = preloaded['ohlc']
|
||
_5min_cache = preloaded.get('5min', {})
|
||
_scan_cache = preloaded.get('scan', {})
|
||
else:
|
||
trading_days = get_trading_days(conn, start_date, end_date)
|
||
_ohlc_cache = None
|
||
_5min_cache = None
|
||
_scan_cache = None
|
||
|
||
if not trading_days:
|
||
if verbose:
|
||
print("错误: 无交易日数据")
|
||
return None
|
||
|
||
if _preloaded:
|
||
scan_days = len(set(d for (d, t) in _scan_cache.keys() if start_date <= d <= end_date))
|
||
else:
|
||
with conn.cursor() as cur:
|
||
cur.execute("SELECT count(DISTINCT scan_date) FROM stock_scan_history WHERE scan_date >= %s AND scan_date <= %s",
|
||
(start_date, end_date))
|
||
scan_days = cur.fetchone()[0]
|
||
if scan_days == 0:
|
||
if verbose:
|
||
print("错误: stock_scan_history 表无数据，请先运行 scan_history.py")
|
||
return None
|
||
if verbose:
|
||
print(f" 扫描数据: {scan_days} 天可用", flush=True)
|
||
|
||
position = {} # code -> (shares, total_cost, first_buy_date)
|
||
trades = []
|
||
cooldown = {}
|
||
daily_logs = []
|
||
net_cash = 0.0
|
||
equity_series = []
|
||
peak_profit = {} # code -> 历史最高浮盈百分比
|
||
sell_streak = {} # v4.2: code -> 连续卖出信号天数
|
||
max_capital_deployed = 0.0 # v4.2: 最大同时占用资金
|
||
# v6.0: 连涨跟踪
|
||
prev_close = {} # code -> 前一日收盘价
|
||
rising_days = {} # code -> 连续上涨天数
|
||
momentum_active = {} # code -> True/False, 连涨模式是否激活(转跟踪止盈)
|
||
partial_sold = {} # code -> True/False, 是否已部分止盈
|
||
# v6.0: 移动止损
|
||
dynamic_sl = {} # code -> 动态止损线(浮盈%, 负数=亏损)
|
||
|
||
# v5.2: 动态仓位计算函数
|
||
def calc_dynamic_shares(price, rate=80, triggered=1):
|
||
"""根据价格和信号强度计算买入股数（A股最小100股）"""
|
||
if price <= 0 or not _dynamic_pos:
|
||
return _shares # 回退到固定股数
|
||
# 基础仓位 = 总资金 × position_pct%
|
||
base_amount = total_capital * position_pct / 100.0
|
||
# 信号强度加权
|
||
if signal_weight:
|
||
if triggered >= 3 or rate >= 90:
|
||
weight = 1.5 # 强信号: 1.5倍仓位
|
||
elif triggered >= 2 or rate >= 85:
|
||
weight = 1.2 # 较强信号: 1.2倍仓位
|
||
else:
|
||
weight = 1.0 # 普通信号: 标准仓位
|
||
base_amount *= weight
|
||
# 不超过可用现金
|
||
if cash_balance is not None:
|
||
base_amount = min(base_amount, cash_balance * 0.95) # 保留5%缓冲
|
||
# 计算股数（向下取整到100股）
|
||
shares_raw = int(base_amount / price / 100) * 100
|
||
return max(shares_raw, 100) if shares_raw > 0 else 0
|
||
|
||
# v5: 统计5分钟数据覆盖情况
|
||
_5min_hit = 0
|
||
_5min_miss = 0
|
||
|
||
for i, t in enumerate(trading_days):
|
||
ohlc_t = _ohlc_cache.get(t, {}) if _preloaded else get_day_ohlc(conn, t)
|
||
if not ohlc_t:
|
||
continue
|
||
|
||
# v5/v7: 加载当天5分钟K线价格（支持任意时间点）
|
||
if use_5min_prices:
|
||
if _preloaded:
|
||
# 新结构: {(date, time_str): {code: price}}
|
||
fivemin_buy_t = _5min_cache.get((t, buy_time), {})
|
||
fivemin_sell_t = _5min_cache.get((t, sell_time), {})
|
||
else:
|
||
fivemin_buy_t = get_5min_price_at(conn, t, buy_time)
|
||
fivemin_sell_t = get_5min_price_at(conn, t, sell_time)
|
||
else:
|
||
fivemin_buy_t = {}
|
||
fivemin_sell_t = {}
|
||
|
||
day_log = {'date': t, 'buys': [], 'sells': [], 'holds': []}
|
||
|
||
# ── 10:00 买入：用 T-1 的 16:30 扫描结果 ──
|
||
prev = trading_days[i - 1] if i > 0 else None
|
||
if prev is not None and len(position) < _max_con:
|
||
scan_1630 = _scan_cache.get((prev, '16:30'), {}) if _preloaded else load_scan_results(conn, prev, '16:30')
|
||
|
||
candidates = []
|
||
for code, info in scan_1630.items():
|
||
if info['display'] != '买入':
|
||
continue
|
||
if code in cooldown and t < cooldown[code]:
|
||
continue
|
||
if code in position:
|
||
continue
|
||
if code not in ohlc_t:
|
||
continue
|
||
if min_buy_rate > 0 and info['rate'] < min_buy_rate:
|
||
continue
|
||
if min_buy_triggered > 0 and info['triggered'] < min_buy_triggered:
|
||
continue
|
||
# v5/v7: 买入价 = 5分钟指定时点实时价 > mid=(开盘+收盘)/2
|
||
if use_5min_prices and code in fivemin_buy_t:
|
||
buy_price = fivemin_buy_t[code]
|
||
_5min_hit += 1
|
||
else:
|
||
o, _, _, c = ohlc_t[code]
|
||
buy_price = (o + c) / 2 # mid价
|
||
if use_5min_prices:
|
||
_5min_miss += 1
|
||
if buy_price < _price_min or buy_price > _price_max:
|
||
continue
|
||
# v5.2: 动态仓位 — 在筛选阶段只做基本检查
|
||
if _dynamic_pos:
|
||
est_shares = calc_dynamic_shares(buy_price, info['rate'], info['triggered'])
|
||
if est_shares <= 0:
|
||
continue
|
||
est_cost = buy_price * est_shares
|
||
else:
|
||
est_cost = buy_price * _shares
|
||
if est_cost > _pos_amt:
|
||
continue
|
||
# v5.1: 现金约束
|
||
if cash_balance is not None and est_cost > cash_balance:
|
||
continue
|
||
candidates.append((code, info['rate'], info['triggered'], info['reason'], buy_price))
|
||
|
||
candidates.sort(key=lambda x: (-x[1], -x[2]))
|
||
bought = 0
|
||
for code, rate, tc, reason, buy_price in candidates:
|
||
if bought >= _max_buys or len(position) >= _max_con:
|
||
break
|
||
# v5.2: 动态仓位 — 根据信号强度计算实际股数
|
||
if _dynamic_pos:
|
||
buy_shares = calc_dynamic_shares(buy_price, rate, tc)
|
||
if buy_shares <= 0:
|
||
continue
|
||
else:
|
||
buy_shares = _shares
|
||
cost = buy_price * buy_shares
|
||
# v5.1: 再次检查现金（因为已经买了 bought 只）
|
||
if cash_balance is not None and cost > cash_balance:
|
||
# v5.2: 动态仓位模式下，尝试减少股数以适配现金
|
||
if _dynamic_pos and cash_balance > buy_price * 100:
|
||
buy_shares = int(cash_balance / buy_price / 100) * 100
|
||
cost = buy_price * buy_shares
|
||
if buy_shares <= 0:
|
||
continue
|
||
else:
|
||
continue
|
||
position[code] = (buy_shares, cost, t)
|
||
peak_profit[code] = 0.0
|
||
trades.append({
|
||
'date': t, 'time': buy_time, 'action': '买入',
|
||
'code': code, 'price': buy_price, 'shares': buy_shares,
|
||
'amount': cost, 'reason': reason,
|
||
})
|
||
net_cash -= cost
|
||
if cash_balance is not None:
|
||
cash_balance -= cost
|
||
day_log['buys'].append({'code': code, 'price': buy_price, 'amount': cost, 'reason': reason})
|
||
bought += 1
|
||
|
||
# ── 15:00 持仓管理 ──
|
||
if position:
|
||
scan_1130 = _scan_cache.get((t, '11:30'), {}) if _preloaded else load_scan_results(conn, t, '11:30')
|
||
|
||
for code in list(position.keys()):
|
||
if code not in ohlc_t:
|
||
continue
|
||
# v5/v7: 卖出价 = 5分钟指定时点实时价 > mid=(开盘+收盘)/2
|
||
if use_5min_prices and code in fivemin_sell_t:
|
||
current_price = fivemin_sell_t[code]
|
||
else:
|
||
o, _, _, c = ohlc_t[code]
|
||
current_price = (o + c) / 2 if use_5min_prices else c # 非5min模式保持原close
|
||
close_p = current_price
|
||
shares, total_cost, first_buy = position[code]
|
||
profit_pct = (close_p * shares - total_cost) / total_cost * 100 if total_cost > 0 else 0
|
||
hold_days = (t - first_buy).days if isinstance(first_buy, date) else 0
|
||
|
||
# 更新峰值浮盈
|
||
if code in peak_profit:
|
||
if profit_pct > peak_profit[code]:
|
||
peak_profit[code] = profit_pct
|
||
else:
|
||
peak_profit[code] = max(0, profit_pct)
|
||
|
||
info = scan_1130.get(code, {})
|
||
holding_disp = info.get('holding_display', '观望')
|
||
holding_reason = info.get('holding_reason', '')
|
||
h_rate = info.get('holding_rate', 0)
|
||
|
||
action_taken = None
|
||
|
||
# v6.0: 更新连涨天数
|
||
pc = prev_close.get(code, 0)
|
||
if pc > 0 and close_p > pc:
|
||
rising_days[code] = rising_days.get(code, 0) + 1
|
||
else:
|
||
rising_days[code] = 0
|
||
is_rising = rising_days.get(code, 0) >= momentum_days
|
||
|
||
# v6.0: 更新动态止损线
|
||
_effective_sl = stop_loss_pct # 默认止损线
|
||
if code in dynamic_sl:
|
||
_effective_sl = dynamic_sl[code]
|
||
# 移动止损/保本止损
|
||
if breakeven_at > 0 and profit_pct >= breakeven_at:
|
||
new_sl = 0 # 保本
|
||
if profit_lock_pct > 0 and profit_pct >= profit_lock_pct:
|
||
new_sl = -(profit_lock_pct / 2) # 锁定一半利润（负值=允许的最大亏损线提高到浮盈/2）
|
||
if code not in dynamic_sl or new_sl > dynamic_sl.get(code, -999):
|
||
dynamic_sl[code] = new_sl
|
||
|
||
# v6.0: 检查连涨保护是否激活
|
||
if momentum_tp and take_profit_pct is not None and profit_pct >= take_profit_pct and is_rising:
|
||
momentum_active[code] = True # 连涨中达到TP，激活跟踪模式
|
||
|
||
# 辅助: 清仓并记录
|
||
def _do_sell(reason_text, sell_shares=None):
|
||
nonlocal net_cash, cash_balance
|
||
s = sell_shares or shares
|
||
sell_amount = close_p * s
|
||
pft = sell_amount - (total_cost * s / shares if shares > 0 else total_cost)
|
||
trades.append({
|
||
'date': t, 'time': sell_time, 'action': '清仓',
|
||
'code': code, 'price': close_p, 'shares': s,
|
||
'amount': sell_amount,
|
||
'reason': reason_text,
|
||
'profit': pft,
|
||
})
|
||
net_cash += sell_amount
|
||
if cash_balance is not None:
|
||
cash_balance += sell_amount
|
||
return pft
|
||
|
||
# ── 第1优先: 止损 (含v6.0移动止损) ──
|
||
actual_sl = _effective_sl
|
||
if code in dynamic_sl and profit_pct >= 0:
|
||
# 动态止损: 如果当前浮盈从峰值回撤超过动态止损线
|
||
peak = peak_profit.get(code, 0)
|
||
if peak > 0 and profit_pct < dynamic_sl[code]:
|
||
actual_sl = dynamic_sl[code] # 用动态止损线
|
||
if stop_loss_pct is not None and profit_pct <= -stop_loss_pct:
|
||
_do_sell(f'止损(浮亏{profit_pct:.1f}%≥{stop_loss_pct}%)')
|
||
del position[code]
|
||
peak_profit.pop(code, None)
|
||
for _d in (rising_days, momentum_active, partial_sold, dynamic_sl, prev_close):
|
||
_d.pop(code, None)
|
||
cooldown[code] = t + timedelta(days=SELL_COOLDOWN_DAYS)
|
||
action_taken = '止损清仓'
|
||
|
||
# v6.0: 移动止损触发 (保本止损 / 利润锁定)
|
||
elif code in dynamic_sl and profit_pct <= dynamic_sl[code] and profit_pct > -(stop_loss_pct or 999):
|
||
sl_line = dynamic_sl[code]
|
||
_do_sell(f'移动止损(线{sl_line:.1f}%,现{profit_pct:.1f}%)')
|
||
del position[code]
|
||
peak_profit.pop(code, None)
|
||
for _d in (rising_days, momentum_active, partial_sold, dynamic_sl, prev_close):
|
||
_d.pop(code, None)
|
||
cooldown[code] = t + timedelta(days=SELL_COOLDOWN_DAYS)
|
||
action_taken = '移动止损'
|
||
|
||
# ── 第2优先: 固定止盈 (含v6.0连涨保护 & 部分止盈) ──
|
||
elif take_profit_pct is not None and profit_pct >= take_profit_pct:
|
||
# v6.0: 连涨保护 — 连涨中不固定止盈，转跟踪
|
||
if momentum_tp and is_rising:
|
||
momentum_active[code] = True
|
||
action_taken = f'连涨保护(连涨{rising_days.get(code,0)}天,转跟踪止盈)'
|
||
# v6.0: 部分止盈
|
||
elif partial_exit_pct > 0 and not partial_sold.get(code, False):
|
||
sell_shares = max(100, int(shares * partial_exit_pct / 100 / 100) * 100)
|
||
if sell_shares >= shares:
|
||
sell_shares = shares # 不够分就全卖
|
||
partial_cost = total_cost * sell_shares / shares if shares > 0 else 0
|
||
partial_revenue = close_p * sell_shares
|
||
partial_profit = partial_revenue - partial_cost
|
||
trades.append({
|
||
'date': t, 'time': sell_time, 'action': '清仓',
|
||
'code': code, 'price': close_p, 'shares': sell_shares,
|
||
'amount': partial_revenue,
|
||
'reason': f'部分止盈{partial_exit_pct}%(浮盈{profit_pct:.1f}%≥{take_profit_pct}%)',
|
||
'profit': partial_profit,
|
||
})
|
||
remaining_shares = shares - sell_shares
|
||
remaining_cost = total_cost - partial_cost
|
||
if remaining_shares <= 0:
|
||
del position[code]
|
||
peak_profit.pop(code, None)
|
||
for _d in (rising_days, momentum_active, partial_sold, dynamic_sl, prev_close):
|
||
_d.pop(code, None)
|
||
cooldown[code] = t + timedelta(days=SELL_COOLDOWN_DAYS)
|
||
else:
|
||
position[code] = (remaining_shares, remaining_cost, first_buy)
|
||
partial_sold[code] = True
|
||
# 部分止盈后启动跟踪止盈模式
|
||
momentum_active[code] = True
|
||
net_cash += partial_revenue
|
||
if cash_balance is not None:
|
||
cash_balance += partial_revenue
|
||
action_taken = f'部分止盈{partial_exit_pct}%'
|
||
else:
|
||
_do_sell(f'止盈(浮盈{profit_pct:.1f}%≥{take_profit_pct}%)')
|
||
del position[code]
|
||
peak_profit.pop(code, None)
|
||
for _d in (rising_days, momentum_active, partial_sold, dynamic_sl, prev_close):
|
||
_d.pop(code, None)
|
||
cooldown[code] = t + timedelta(days=SELL_COOLDOWN_DAYS)
|
||
action_taken = '止盈清仓'
|
||
|
||
# ── 第3优先: 跟踪止盈 (原有 + v6.0连涨跟踪) ──
|
||
elif (trailing_start_pct > 0 and trailing_gap_pct > 0
|
||
and peak_profit.get(code, 0) >= trailing_start_pct
|
||
and profit_pct <= peak_profit.get(code, 0) - trailing_gap_pct):
|
||
pk = peak_profit.get(code, 0)
|
||
_do_sell(f'跟踪止盈(峰{pk:.1f}%→现{profit_pct:.1f}%,回撤{pk-profit_pct:.1f}%≥{trailing_gap_pct}%)')
|
||
del position[code]
|
||
peak_profit.pop(code, None)
|
||
for _d in (rising_days, momentum_active, partial_sold, dynamic_sl, prev_close):
|
||
_d.pop(code, None)
|
||
cooldown[code] = t + timedelta(days=SELL_COOLDOWN_DAYS)
|
||
action_taken = '跟踪止盈'
|
||
|
||
# v6.0: 连涨模式激活后的跟踪止盈
|
||
elif momentum_active.get(code, False):
|
||
m_trail_start = momentum_trail_start or (take_profit_pct or 10)
|
||
m_trail_gap = momentum_trail_gap
|
||
pk = peak_profit.get(code, 0)
|
||
if pk >= m_trail_start and profit_pct <= pk - m_trail_gap:
|
||
_do_sell(f'连涨跟踪止盈(峰{pk:.1f}%→现{profit_pct:.1f}%,回撤{pk-profit_pct:.1f}%≥{m_trail_gap}%)')
|
||
del position[code]
|
||
peak_profit.pop(code, None)
|
||
for _d in (rising_days, momentum_active, partial_sold, dynamic_sl, prev_close):
|
||
_d.pop(code, None)
|
||
cooldown[code] = t + timedelta(days=SELL_COOLDOWN_DAYS)
|
||
action_taken = '连涨跟踪止盈'
|
||
else:
|
||
action_taken = f'连涨跟踪中(峰{pk:.1f}%,现{profit_pct:.1f}%,连涨{rising_days.get(code,0)}天)'
|
||
|
||
# ── 第4优先: v4.1 最大持仓天数强制平仓 (v6.0:连涨保护) ──
|
||
elif max_hold_days > 0 and hold_days >= max_hold_days:
|
||
# v6.0: 如果连涨且盈利，不强制平仓
|
||
if no_timeout_if_rising and is_rising and profit_pct > 0:
|
||
action_taken = f'超时但连涨保护(持仓{hold_days}天,连涨{rising_days.get(code,0)}天,浮盈{profit_pct:.1f}%)'
|
||
else:
|
||
_do_sell(f'超时平仓(持仓{hold_days}天≥{max_hold_days}天)')
|
||
del position[code]
|
||
peak_profit.pop(code, None)
|
||
for _d in (rising_days, momentum_active, partial_sold, dynamic_sl, prev_close):
|
||
_d.pop(code, None)
|
||
cooldown[code] = t + timedelta(days=SELL_COOLDOWN_DAYS)
|
||
action_taken = '超时平仓'
|
||
|
||
# ── 第5优先: 推荐卖出（v4.1: 可忽略, v4.2: 延迟确认） ──
|
||
elif holding_disp == '卖出' and not ignore_sell_signal:
|
||
# v4.2: 延迟卖出确认
|
||
sell_streak[code] = sell_streak.get(code, 0) + 1
|
||
streak = sell_streak[code]
|
||
|
||
# v4 盈利保护逻辑
|
||
should_sell = True
|
||
protect_msg = ''
|
||
|
||
# v4.2: 连续卖出天数不足
|
||
if sell_confirm_days > 0 and streak < sell_confirm_days:
|
||
should_sell = False
|
||
protect_msg = f'延迟确认(连续{streak}/{sell_confirm_days}天)'
|
||
|
||
if should_sell and profit_protect_pct > 0 and profit_pct >= profit_protect_pct:
|
||
if sell_confirm_rate > 0 and h_rate < sell_confirm_rate:
|
||
should_sell = False
|
||
protect_msg = f'盈利保护(浮盈{profit_pct:.1f}%,卖出评分{h_rate}<{sell_confirm_rate})'
|
||
elif sell_confirm_rate == 0:
|
||
should_sell = False
|
||
protect_msg = f'盈利保护(浮盈{profit_pct:.1f}%≥{profit_protect_pct}%)'
|
||
|
||
if should_sell and sell_confirm_rate > 0 and h_rate < sell_confirm_rate:
|
||
should_sell = False
|
||
protect_msg = f'卖出评分不足({h_rate}<{sell_confirm_rate})'
|
||
|
||
if should_sell:
|
||
total_sell = close_p * shares
|
||
profit = total_sell - total_cost
|
||
trades.append({
|
||
'date': t, 'time': sell_time, 'action': '清仓',
|
||
'code': code, 'price': close_p, 'shares': shares,
|
||
'amount': total_sell,
|
||
'reason': f'推荐卖出: {holding_reason}',
|
||
'profit': profit,
|
||
})
|
||
del position[code]
|
||
peak_profit.pop(code, None)
|
||
sell_streak.pop(code, None)
|
||
net_cash += total_sell
|
||
if cash_balance is not None:
|
||
cash_balance += total_sell
|
||
cooldown[code] = t + timedelta(days=SELL_COOLDOWN_DAYS)
|
||
action_taken = '推荐卖出'
|
||
else:
|
||
action_taken = f'忽略卖出({protect_msg})'
|
||
|
||
# ── 第6: 推荐卖出但被 ignore_sell_signal 跳过 ──
|
||
elif holding_disp == '卖出' and ignore_sell_signal:
|
||
action_taken = f'跳过推荐卖出(纯技术模式)'
|
||
|
||
# ── 第7: 加仓 ──
|
||
elif holding_disp == '加仓':
|
||
sell_streak.pop(code, None) # 非卖出信号重置连续天数
|
||
# v5.2: 动态仓位 — 加仓也用动态计算
|
||
if _dynamic_pos:
|
||
add_shares = calc_dynamic_shares(close_p, h_rate, 1)
|
||
if add_shares <= 0:
|
||
add_shares = 100 # 最低加100股
|
||
else:
|
||
add_shares = _shares
|
||
add_cost = close_p * add_shares
|
||
new_total = total_cost + add_cost
|
||
can_add = new_total <= _pos_amt
|
||
if cash_balance is not None and add_cost > cash_balance:
|
||
# v5.2: 动态模式下尝试减少加仓量
|
||
if _dynamic_pos and cash_balance > close_p * 100:
|
||
add_shares = int(cash_balance / close_p / 100) * 100
|
||
add_cost = close_p * add_shares
|
||
new_total = total_cost + add_cost
|
||
can_add = new_total <= _pos_amt and add_shares > 0
|
||
else:
|
||
can_add = False
|
||
if can_add:
|
||
position[code] = (shares + add_shares, new_total, first_buy)
|
||
peak_profit[code] = 0.0 # 加仓后重置峰值
|
||
trades.append({
|
||
'date': t, 'time': sell_time, 'action': '加仓',
|
||
'code': code, 'price': close_p, 'shares': add_shares,
|
||
'amount': add_cost,
|
||
'reason': f'推荐加仓: {holding_reason}',
|
||
})
|
||
net_cash -= add_cost
|
||
if cash_balance is not None:
|
||
cash_balance -= add_cost
|
||
action_taken = '推荐加仓'
|
||
else:
|
||
action_taken = f'推荐加仓(超限不执行)'
|
||
else:
|
||
sell_streak.pop(code, None) # 非卖出信号重置连续天数
|
||
action_taken = f'推荐{holding_disp}'
|
||
|
||
day_log['holds'].append({
|
||
'code': code, 'close': close_p, 'pct': round(profit_pct, 2),
|
||
'recommend': holding_disp, 'reason': holding_reason,
|
||
'action': action_taken,
|
||
})
|
||
|
||
if action_taken and ('卖出' in action_taken or '清仓' in action_taken or '止盈' in action_taken or '平仓' in action_taken):
|
||
if not action_taken.startswith('跳过') and not action_taken.startswith('忽略'):
|
||
p = trades[-1].get('profit', 0) if trades else 0
|
||
day_log['sells'].append({
|
||
'code': code, 'price': close_p, 'profit': p,
|
||
'reason': trades[-1].get('reason', ''),
|
||
})
|
||
|
||
# v6.0: 更新所有持仓股票的前一日收盘价（用于次日连涨判断）
|
||
for code in position:
|
||
if code in ohlc_t:
|
||
prev_close[code] = ohlc_t[code][3] # close
|
||
|
||
# 当日收盘权益 + 最大占用资金
|
||
position_value = 0.0
|
||
position_cost_sum = 0.0
|
||
for code, (shares, total_cost, first_buy) in position.items():
|
||
position_cost_sum += total_cost # 累计成本
|
||
if code in ohlc_t:
|
||
# v5/v7: 权益计算用5分钟卖出时点价，否则用日线收盘价
|
||
if use_5min_prices and code in fivemin_sell_t:
|
||
eq_price = fivemin_sell_t[code]
|
||
else:
|
||
eq_price = ohlc_t[code][3] # daily close
|
||
position_value += shares * eq_price
|
||
equity_series.append(net_cash + position_value)
|
||
if position_cost_sum > max_capital_deployed:
|
||
max_capital_deployed = position_cost_sum
|
||
|
||
daily_logs.append(day_log)
|
||
|
||
# 回测结束仍有持仓
|
||
if position and trading_days:
|
||
last_day = trading_days[-1]
|
||
ohlc_last = _ohlc_cache.get(last_day, {}) if _preloaded else get_day_ohlc(conn, last_day)
|
||
fivemin_last = _5min_cache.get(last_day, {}) if (_preloaded and use_5min_prices) else (get_5min_prices(conn, last_day) if use_5min_prices else {})
|
||
for code, (shares, total_cost, first_buy) in list(position.items()):
|
||
if code in ohlc_last:
|
||
# v5: 用5分钟价或mid
|
||
if use_5min_prices and code in fivemin_last and 'sell' in fivemin_last[code]:
|
||
close_p = fivemin_last[code]['sell']
|
||
elif use_5min_prices:
|
||
o, _, _, c = ohlc_last[code]
|
||
close_p = (o + c) / 2
|
||
else:
|
||
close_p = ohlc_last[code][3] # daily close
|
||
total_sell = close_p * shares
|
||
trades.append({
|
||
'date': last_day, 'time': '回测结束', 'action': '清仓',
|
||
'code': code, 'price': close_p, 'shares': shares,
|
||
'amount': total_sell, 'reason': '回测截止',
|
||
'profit': total_sell - total_cost,
|
||
})
|
||
net_cash += total_sell
|
||
if cash_balance is not None:
|
||
cash_balance += total_sell
|
||
|
||
stats = calc_stats(trades, start_date, end_date,
|
||
equity_series=equity_series,
|
||
max_capital_deployed=max_capital_deployed)
|
||
|
||
# v5: 5分钟数据覆盖率
|
||
if use_5min_prices:
|
||
total_5min = _5min_hit + _5min_miss
|
||
coverage = (_5min_hit / total_5min * 100) if total_5min > 0 else 0
|
||
stats['5min_hit'] = _5min_hit
|
||
stats['5min_miss'] = _5min_miss
|
||
stats['5min_coverage'] = round(coverage, 1)
|
||
if verbose:
|
||
print(f" 5分钟数据: 命中{_5min_hit} 缺失{_5min_miss} 覆盖率{coverage:.1f}%", flush=True)
|
||
|
||
# v5.1: 如果有总资金，将其加入stats
|
||
if total_capital > 0:
|
||
stats['total_capital'] = total_capital
|
||
stats['final_cash'] = cash_balance
|
||
stats['capital_utilization'] = round(stats['max_capital'] / total_capital * 100, 1) if total_capital > 0 else 0
|
||
|
||
# v5.2: 动态仓位信息
|
||
stats['dynamic_position'] = _dynamic_pos
|
||
stats['position_pct'] = position_pct
|
||
stats['signal_weight'] = signal_weight
|
||
|
||
# v7.0: 交易时点信息
|
||
stats['buy_time'] = buy_time
|
||
stats['sell_time'] = sell_time
|
||
|
||
return {
|
||
'start_date': start_date, 'end_date': end_date,
|
||
'trading_days': trading_days, 'trades': trades,
|
||
'daily_logs': daily_logs, 'stats': stats,
|
||
}
|
||
|
||
|
||
def get_codes_with_data(conn, trade_date: date, min_days=30):
|
||
"""兼容旧接口"""
|
||
with conn.cursor() as cur:
|
||
cur.execute("""
|
||
SELECT code FROM stock_kline_daily
|
||
WHERE trade_date <= %s GROUP BY code HAVING count(*) >= %s
|
||
""", (trade_date, min_days))
|
||
return [r[0] for r in cur.fetchall()]
|
||
|
||
|
||
# ─── 输出与主函数 ─────────────────────────────────────
|
||
def main():
|
||
parser = argparse.ArgumentParser(description='推荐算法回测 v4.1（智能过滤 + 纯技术止盈止损）')
|
||
parser.add_argument('--take-profit', type=float, default=None, metavar='PCT',
|
||
help='止盈比例（如 10 表示 10%%）')
|
||
parser.add_argument('--stop-loss', type=float, default=None, metavar='PCT',
|
||
help='止损比例（如 5 表示 5%%）')
|
||
parser.add_argument('--min-rate', type=int, default=0, metavar='N',
|
||
help='v4: 买入最低评分 (如 85，默认0=不过滤)')
|
||
parser.add_argument('--min-triggered', type=int, default=0, metavar='N',
|
||
help='v4: 买入最低信号触发数 (如 2，默认0=不过滤)')
|
||
parser.add_argument('--profit-protect', type=float, default=0, metavar='PCT',
|
||
help='v4: 盈利保护线 (浮盈≥N%%时忽略弱卖出信号，默认0=关闭)')
|
||
parser.add_argument('--sell-confirm', type=int, default=0, metavar='N',
|
||
help='v4: 卖出确认评分 (holding_rate≥N才执行推荐卖出，默认0=不过滤)')
|
||
parser.add_argument('--trailing-start', type=float, default=0, metavar='PCT',
|
||
help='v4: 跟踪止盈激活线 (浮盈≥N%%后开始跟踪，默认0=关闭)')
|
||
parser.add_argument('--trailing-gap', type=float, default=0, metavar='PCT',
|
||
help='v4: 跟踪止盈回撤幅度 (从峰值回落N%%触发卖出，默认0=关闭)')
|
||
parser.add_argument('--ignore-sell', action='store_true',
|
||
help='v4.1: 忽略推荐卖出信号（纯技术模式）')
|
||
parser.add_argument('--max-hold', type=int, default=0, metavar='DAYS',
|
||
help='v4.1: 最大持仓天数 (超过则强制平仓，默认0=不限)')
|
||
parser.add_argument('--shares', type=int, default=None, metavar='N',
|
||
help='v4.1: 每笔股数 (默认1000)')
|
||
parser.add_argument('--pos-amount', type=float, default=None, metavar='AMT',
|
||
help='v4.1: 单只上限金额 (默认30000)')
|
||
parser.add_argument('--max-concurrent', type=int, default=None, metavar='N',
|
||
help='v4.1: 最大并发持仓数 (默认8)')
|
||
parser.add_argument('--sell-confirm-days', type=int, default=0, metavar='N',
|
||
help='v4.2: 连续N天卖出信号才执行 (默认0=立即)')
|
||
parser.add_argument('--use-5min', action='store_true',
|
||
help='v5/v7: 使用5分钟K线实时价格(买入用09:35,卖出用13:40,无则用mid)')
|
||
parser.add_argument('--buy-time', type=str, default='09:35', metavar='HH:MM',
|
||
help='v7: 买入时间点 (默认09:35, 如 10:00)')
|
||
parser.add_argument('--sell-time', type=str, default='13:40', metavar='HH:MM',
|
||
help='v7: 卖出/估值时间点 (默认13:40, 如 15:00)')
|
||
parser.add_argument('--total-capital', type=float, default=0, metavar='AMT',
|
||
help='v5.1: 总本金 (>0启用现金追踪)')
|
||
parser.add_argument('--position-pct', type=float, default=0, metavar='PCT',
|
||
help='v5.2: 单笔仓位占总资金百分比 (>0启用动态仓位, 如5=5%%)')
|
||
parser.add_argument('--signal-weight', action='store_true',
|
||
help='v5.2: 根据信号强度加权仓位(强信号1.5倍,较强1.2倍)')
|
||
parser.add_argument('--start', type=str, default=None, metavar='YYYY-MM-DD')
|
||
parser.add_argument('-v', '--verbose', action='store_true', help='输出每日详细操作')
|
||
args = parser.parse_args()
|
||
|
||
start_date = START_DATE
|
||
if args.start:
|
||
try:
|
||
start_date = datetime.strptime(args.start, '%Y-%m-%d').date()
|
||
except ValueError:
|
||
print("错误: --start 格式应为 YYYY-MM-DD")
|
||
return
|
||
|
||
conn = get_db_conn()
|
||
end = date.today()
|
||
|
||
_shares = args.shares or SHARES_PER_TRADE
|
||
_pos = args.pos_amount or MAX_POSITION_AMOUNT
|
||
_con = args.max_concurrent or MAX_CONCURRENT_POSITIONS
|
||
|
||
print("=" * 90)
|
||
print(" 推荐算法回测 v7.0（智能过滤 + 真实资金收益率 + 最优交易时点）")
|
||
print("=" * 90)
|
||
print(f" 回测区间 : {start_date} ~ {end}")
|
||
print(f" 规则 : {args.buy_time} 用 T-1 16:30扫描买入最多{MAX_BUYS_PER_DAY}只")
|
||
print(f" {args.sell_time} 用 T 日 11:30扫描做加仓/清仓推荐")
|
||
print(f" 股价区间 : {PRICE_MIN}~{PRICE_MAX} 元 单只上限 ¥{_pos:,.0f}")
|
||
print(f" 每笔股数 : {_shares} 最大持仓 : {_con} 只 冷却期 {SELL_COOLDOWN_DAYS} 天")
|
||
if args.take_profit is not None:
|
||
print(f" 止盈 : ≥{args.take_profit}%")
|
||
if args.stop_loss is not None:
|
||
print(f" 止损 : ≥{args.stop_loss}%")
|
||
if args.ignore_sell:
|
||
print(f" v4.1 : 🚫 忽略推荐卖出信号（纯技术模式）")
|
||
if args.max_hold > 0:
|
||
print(f" v4.1 : ⏰ 最大持仓 {args.max_hold} 天")
|
||
if args.sell_confirm_days > 0:
|
||
print(f" v4.2 : 📅 连续{args.sell_confirm_days}天卖出信号才执行")
|
||
if args.use_5min:
|
||
print(f" v7 : 📊 使用5分钟K线实时价格（买入@{args.buy_time},卖出@{args.sell_time},无则用mid）")
|
||
if args.min_rate > 0:
|
||
print(f" v4 买入门槛 : 评分≥{args.min_rate}")
|
||
if args.min_triggered > 0:
|
||
print(f" v4 最低信号 : 触发数≥{args.min_triggered}")
|
||
if args.profit_protect > 0:
|
||
print(f" v4 盈利保护 : 浮盈≥{args.profit_protect}%时忽略弱卖出")
|
||
if args.trailing_start > 0 and args.trailing_gap > 0:
|
||
print(f" v4 跟踪止盈 : 激活线{args.trailing_start}%, 回撤{args.trailing_gap}%触发")
|
||
print("-" * 90)
|
||
|
||
import time
|
||
t0 = time.time()
|
||
result = run_backtest(conn, start_date=start_date, end_date=end,
|
||
take_profit_pct=args.take_profit, stop_loss_pct=args.stop_loss,
|
||
min_buy_rate=args.min_rate,
|
||
min_buy_triggered=args.min_triggered,
|
||
profit_protect_pct=args.profit_protect,
|
||
sell_confirm_rate=args.sell_confirm,
|
||
trailing_start_pct=args.trailing_start,
|
||
trailing_gap_pct=args.trailing_gap,
|
||
ignore_sell_signal=args.ignore_sell,
|
||
max_hold_days=args.max_hold,
|
||
shares_per_trade=args.shares,
|
||
position_amount=args.pos_amount,
|
||
max_concurrent=args.max_concurrent,
|
||
sell_confirm_days=args.sell_confirm_days,
|
||
use_5min_prices=args.use_5min,
|
||
total_capital=args.total_capital,
|
||
position_pct=args.position_pct,
|
||
signal_weight=args.signal_weight,
|
||
buy_time=args.buy_time,
|
||
sell_time=args.sell_time,
|
||
verbose=args.verbose)
|
||
elapsed = time.time() - t0
|
||
|
||
if not result:
|
||
conn.close()
|
||
return
|
||
|
||
trades = result['trades']
|
||
stats = result['stats']
|
||
daily_logs = result['daily_logs']
|
||
print(f"\n 回测完成! 耗时 {elapsed:.1f}s")
|
||
|
||
# ── 每日交易流水 ──
|
||
print("\n" + "=" * 90)
|
||
print(" 每日交易流水")
|
||
print("=" * 90)
|
||
|
||
for log in daily_logs:
|
||
if not log['buys'] and not log['sells'] and (not log['holds'] or not args.verbose):
|
||
continue
|
||
|
||
print(f"\n ─── {log['date']} ───")
|
||
|
||
if log['buys']:
|
||
print(f" {args.buy_time} 买入:")
|
||
for b in log['buys']:
|
||
print(f" 🟢 {b['code']} ¥{b['price']:.2f} × {_shares}股 = ¥{b['amount']:,.0f} ({b['reason']})")
|
||
|
||
if log['holds']:
|
||
print(f" {args.sell_time} 持仓推荐:")
|
||
for h in log['holds']:
|
||
act = h['action']
|
||
if '清仓' in act or '卖出' in act or '止盈' in act or '平仓' in act:
|
||
if '跳过' in act or '忽略' in act:
|
||
icon = '🛡️'
|
||
else:
|
||
icon = '🔴'
|
||
elif '加仓' in act:
|
||
icon = '🔵'
|
||
else:
|
||
icon = '⚪'
|
||
print(f" {icon} {h['code']} 现价¥{h['close']:.2f} 浮盈{h['pct']:+.1f}% → {act} ({h['reason']})")
|
||
|
||
if log['sells']:
|
||
print(f" 15:00 执行卖出:")
|
||
for s in log['sells']:
|
||
p = s.get('profit', 0)
|
||
icon = '✅' if p >= 0 else '❌'
|
||
print(f" {icon} {s['code']} ¥{s['price']:.2f} 盈亏 ¥{p:+,.0f} ({s['reason']})")
|
||
|
||
# 回测截止
|
||
end_holdings = [t for t in trades if t.get('reason') == '回测截止']
|
||
if end_holdings:
|
||
print(f"\n ─── 回测截止 ───")
|
||
for t in end_holdings:
|
||
p = t.get('profit', 0)
|
||
icon = '📈' if p >= 0 else '📉'
|
||
print(f" {icon} {t['code']} ¥{t['price']:.2f} × {t['shares']}股 浮盈亏 ¥{p:+,.0f}")
|
||
|
||
# ── 完整交易明细 ──
|
||
if stats.get('closed_trades'):
|
||
print("\n" + "=" * 90)
|
||
print(" 完整交易明细（买入 → 卖出）")
|
||
print("=" * 90)
|
||
print(f" {'#':>3} {'代码':<8} {'买入日':>12} {'买入价':>8} {'卖出日':>12} "
|
||
f"{'卖出价':>8} {'盈亏':>10} {'天数':>5} {'原因'}")
|
||
print(" " + "-" * 85)
|
||
for idx, ct in enumerate(stats['closed_trades'], 1):
|
||
buy_price = sell_price = 0
|
||
for tr in trades:
|
||
if tr['code'] == ct['code'] and tr['action'] == '买入':
|
||
d = tr['date'] if isinstance(tr['date'], date) else datetime.strptime(str(tr['date']), '%Y-%m-%d').date()
|
||
if d == ct['buy_date']:
|
||
buy_price = tr['price']
|
||
break
|
||
for tr in trades:
|
||
if tr['code'] == ct['code'] and tr['action'] == '清仓':
|
||
d = tr['date'] if isinstance(tr['date'], date) else datetime.strptime(str(tr['date']), '%Y-%m-%d').date()
|
||
if d == ct['sell_date']:
|
||
sell_price = tr['price']
|
||
break
|
||
icon = '✅' if ct['profit'] > 0 else ('❌' if ct['profit'] < 0 else '➖')
|
||
reason_short = ct['reason'][:24]
|
||
print(f" {icon}{idx:>2} {ct['code']:<8} {ct['buy_date']} ¥{buy_price:>6.2f} "
|
||
f"{ct['sell_date']} ¥{sell_price:>6.2f} ¥{ct['profit']:>+9,.0f} "
|
||
f"{ct['hold_days']:>4}天 {reason_short}")
|
||
|
||
# ── 核心统计 ──
|
||
print("\n" + "=" * 90)
|
||
print(" 回测统计")
|
||
print("=" * 90)
|
||
print(f" 总投入(周转) : ¥{stats['total_in']:>12,.2f}")
|
||
print(f" 总收回 : ¥{stats['total_out']:>12,.2f}")
|
||
print(f" 净盈亏 : ¥{stats['profit']:>12,.2f}")
|
||
print("-" * 50)
|
||
mc = stats.get('max_capital', 0)
|
||
cp = stats.get('capital_pct', 0)
|
||
ca = stats.get('capital_ann_pct', 0)
|
||
print(f" 💰 最大占用资金 : ¥{mc:>10,.0f}")
|
||
print(f" 💰 真实收益率 : {cp:>+8.2f}% (盈亏/最大占用资金)")
|
||
ann_method = "简单年化" if stats['days'] < 90 else "复利年化(CAGR)"
|
||
print(f" 💰 真实年化 : {ca:>+8.2f}% ★★★ 核心指标 ({ann_method}, {stats['days']}天)")
|
||
print(f" 📊 周转收益率 : {stats['profit_pct']:>+8.2f}% (盈亏/总周转，参考)")
|
||
print(f" 📊 周转年化 : {stats['annualized_pct']:>+8.2f}% (参考)")
|
||
print(f" 最大回撤 : ¥{stats['max_drawdown']:>12,.2f} ({stats.get('max_drawdown_pct', 0):.2f}%)")
|
||
print("-" * 50)
|
||
print(f" 总交易笔数 : {stats['trade_count']}")
|
||
print(f" 已平仓笔数 : {stats['closed_count']}")
|
||
print(f" 胜 / 负 / 平 : {stats['wins']} / {stats['losses']} / {stats['flat']}")
|
||
print(f" 胜率 : {stats['win_rate']:.1f}%")
|
||
print(f" 平均持仓天数 : {stats['avg_hold_days']:.1f} 天")
|
||
print(f" 平均盈利 : ¥{stats['avg_win']:>10,.2f}")
|
||
print(f" 平均亏损 : ¥{stats['avg_loss']:>10,.2f}")
|
||
print(f" 盈亏比 : {stats['profit_factor']:.2f}")
|
||
print(f" 回测天数 : {stats['days']} 天")
|
||
if '5min_coverage' in stats:
|
||
print(f" 5分钟数据 : 命中{stats['5min_hit']} 缺失{stats['5min_miss']} 覆盖率{stats['5min_coverage']:.1f}%")
|
||
|
||
# ── 个股盈亏 ──
|
||
if stats['stock_pnl']:
|
||
print("\n" + "=" * 70)
|
||
print(" 个股盈亏明细")
|
||
print("=" * 70)
|
||
sorted_pnl = sorted(stats['stock_pnl'].items(), key=lambda x: x[1]['profit'], reverse=True)
|
||
for code, info in sorted_pnl:
|
||
wr = (info['wins'] / info['trades'] * 100) if info['trades'] > 0 else 0
|
||
icon = '✅' if info['profit'] > 0 else ('❌' if info['profit'] < 0 else '➖')
|
||
print(f" {icon} {code:<8} ¥{info['profit']:>+9,.0f} {info['trades']:>3}笔 胜率{wr:>4.0f}%")
|
||
|
||
# ── 保存 JSON ──
|
||
out_dir = os.path.join(os.path.dirname(__file__), 'docs')
|
||
os.makedirs(out_dir, exist_ok=True)
|
||
out_file = os.path.join(out_dir, 'backtest_result.json')
|
||
with open(out_file, 'w', encoding='utf-8') as f:
|
||
json.dump({
|
||
'start': str(result['start_date']), 'end': str(result['end_date']),
|
||
'version': 'v5' if args.use_5min else 'v4.2',
|
||
'params': {
|
||
'take_profit_pct': args.take_profit, 'stop_loss_pct': args.stop_loss,
|
||
'min_buy_rate': args.min_rate,
|
||
'min_buy_triggered': args.min_triggered,
|
||
'profit_protect_pct': args.profit_protect,
|
||
'sell_confirm_rate': args.sell_confirm,
|
||
'trailing_start_pct': args.trailing_start,
|
||
'trailing_gap_pct': args.trailing_gap,
|
||
'ignore_sell_signal': args.ignore_sell,
|
||
'max_hold_days': args.max_hold,
|
||
'sell_confirm_days': args.sell_confirm_days,
|
||
'use_5min_prices': args.use_5min,
|
||
'shares_per_trade': _shares,
|
||
'position_amount': _pos,
|
||
'max_concurrent': _con,
|
||
'price_range': [PRICE_MIN, PRICE_MAX],
|
||
'cooldown_days': SELL_COOLDOWN_DAYS,
|
||
},
|
||
'elapsed_seconds': round(elapsed, 2),
|
||
'stats': {k: v for k, v in stats.items() if k not in ('closed_trades', 'stock_pnl')},
|
||
'stock_pnl': stats['stock_pnl'],
|
||
'trades': [{k: (str(v) if isinstance(v, date) else v) for k, v in tr.items()} for tr in trades],
|
||
}, f, ensure_ascii=False, indent=2)
|
||
print(f"\n结果已写入 {out_file}")
|
||
conn.close()
|
||
|
||
|
||
if __name__ == '__main__':
|
||
main()
|