477 lines
19 KiB
Python
477 lines
19 KiB
Python
"""ETF 网格策略离线回测（只读分析，不修改策略代码）。
|
||
|
||
为什么要单独写：真实策略跑在 30 秒 tick 上（``strategy/etf/boot.py`` 的 RunOnce），
|
||
回测只有日线，必须把"入场区内反弹确认"和"限价单是否成交"用日线 OHLC 近似。
|
||
近似口径在 ``REPORT.md`` 里逐条列出并做了敏感性对照。
|
||
|
||
指标计算直接调用策略自己的 ``strategy.etf.signal.calculate``，
|
||
保证回测与实盘的 ATR/MA60/通道/格距口径完全一致。
|
||
|
||
用法：
|
||
py -3.14 -B analysis/etf/backtest.py # 基准 + 敏感性
|
||
py -3.14 -B analysis/etf/backtest.py --refresh # 重新抓取日线
|
||
"""
|
||
|
||
import argparse
|
||
from dataclasses import dataclass, replace
|
||
from datetime import date, datetime
|
||
import json
|
||
import math
|
||
from pathlib import Path
|
||
import statistics
|
||
import sys
|
||
|
||
# labs/analysis/etf/backtest.py -> labs/analysis/etf -> labs/analysis -> labs -> 仓库根
|
||
ROOT = Path(__file__).resolve().parents[3]
|
||
PY_CLIENT = ROOT / "py-client"
|
||
CACHE = Path(__file__).resolve().parent / "cache"
|
||
OUT = Path(__file__).resolve().parent
|
||
sys.path.insert(0, str(PY_CLIENT))
|
||
|
||
from config import EtfDefaults, EtfSymbolConfig # noqa: E402
|
||
from strategy.etf.signal import calculate # noqa: E402
|
||
|
||
DAILY_URL = "http://139.224.247.176:13499/etf/daily"
|
||
# 直接从仓库配置读取，避免回测参数与实盘配置漂移。
|
||
ETF_YAML = PY_CLIENT / "etc" / "_etf.yaml"
|
||
|
||
|
||
def load_repo_config() -> tuple[EtfDefaults, dict, tuple[str, ...]]:
|
||
"""读取 py-client/etc/_etf.yaml：全局默认、逐标的参数、白名单顺序。"""
|
||
import yaml
|
||
|
||
raw = yaml.safe_load(ETF_YAML.read_text(encoding="utf-8")) or {}
|
||
defaults = EtfDefaults(**(raw.get("defaults") or {}))
|
||
params = {
|
||
code: dict(values or {})
|
||
for code, values in (raw.get("symbols") or {}).items()
|
||
}
|
||
return defaults, params, tuple(params)
|
||
|
||
|
||
# 账户级参数（account_config；_etf.yaml 不含这两项，按账户配置写在这里）。
|
||
MIN_CASH_RATIO = 0.10
|
||
COMMISSION_RATE = 0.0003
|
||
MIN_COMMISSION = 5.0
|
||
# 起始资金：新配置三只各铺满 10 档约需 46.5 万，取 50 万作为"铺得开"的参考账户。
|
||
# 注意该策略按固定股数下单，绝对盈亏由 _etf.yaml 的股数决定，与账户规模无关（见 REPORT §10）。
|
||
START_CASH = 500_000.0
|
||
# 日线最后一根是 2026-09-18，用之后的日期做"今天"，保证整段日线可用。
|
||
RUN_TODAY = date(2026, 9, 19)
|
||
WARMUP = 61
|
||
|
||
# 导入时按仓库配置初始化，供按需调整的脚本直接使用。
|
||
REPO_DEFAULTS, REPO_PARAMS, SYMBOLS = load_repo_config()
|
||
SYMBOL_PARAMS = REPO_PARAMS
|
||
|
||
|
||
def fetch_daily(code: str, refresh: bool = False) -> list[dict]:
|
||
"""读取日线；默认用本地缓存，避免反复打接口。"""
|
||
CACHE.mkdir(parents=True, exist_ok=True)
|
||
path = CACHE / f"{code}.json"
|
||
if refresh or not path.exists():
|
||
import urllib.request
|
||
|
||
with urllib.request.urlopen(f"{DAILY_URL}?code={code}", timeout=30) as response:
|
||
payload = json.load(response)
|
||
path.write_text(json.dumps(payload), encoding="utf-8")
|
||
rows = json.loads(path.read_text(encoding="utf-8"))
|
||
bars: dict[str, dict] = {}
|
||
for row in rows:
|
||
if row.get("ts_code") != code:
|
||
continue
|
||
stamp = str(row.get("trade_date"))
|
||
if len(stamp) != 8 or not stamp.isdigit():
|
||
continue
|
||
day = datetime.strptime(stamp, "%Y%m%d").date()
|
||
if day >= RUN_TODAY:
|
||
continue
|
||
values = {key: float(row[key]) for key in ("open", "high", "low", "close")}
|
||
if not all(math.isfinite(v) and v > 0 for v in values.values()):
|
||
continue
|
||
if not (values["low"] <= values["open"] <= values["high"]
|
||
and values["low"] <= values["close"] <= values["high"]):
|
||
continue
|
||
bars[stamp] = dict(date=stamp, **values)
|
||
return [bars[stamp] for stamp in sorted(bars)]
|
||
|
||
|
||
def fees(amount: float, rate: float, minimum: float) -> float:
|
||
if amount <= 0:
|
||
return 0.0
|
||
return max(minimum, amount * rate)
|
||
|
||
|
||
@dataclass(slots=True)
|
||
class Lot:
|
||
volume: int
|
||
cost: float # 含买入佣金
|
||
bought: date
|
||
|
||
|
||
@dataclass(slots=True)
|
||
class Fill:
|
||
day: date
|
||
code: str
|
||
side: str # BUY / SELL
|
||
kind: str # base / add / exit / level
|
||
volume: int
|
||
price: float
|
||
fee: float
|
||
note: str = ""
|
||
|
||
|
||
class SymbolBook:
|
||
"""单标的网格状态；持仓档位是唯一跨轮存活的状态。"""
|
||
|
||
def __init__(self, code: str, symbol: EtfSymbolConfig):
|
||
self.code = code
|
||
self.symbol = symbol
|
||
self.lots: list[Lot] = []
|
||
self.anchor: float | None = None
|
||
self.last_buy = 0.0
|
||
self.adds = 0
|
||
self.last_add_day: date | None = None
|
||
self.peak_grid: int | None = None
|
||
self.rounds = 0 # 主出口清仓次数
|
||
self.max_level = 0 # 曾经达到的档位数
|
||
|
||
@property
|
||
def volume(self) -> int:
|
||
return sum(lot.volume for lot in self.lots)
|
||
|
||
@property
|
||
def avg_cost(self) -> float:
|
||
total = self.volume
|
||
if total <= 0:
|
||
return 0.0
|
||
return sum(lot.volume * lot.cost for lot in self.lots) / total
|
||
|
||
def sellable(self, day: date) -> int:
|
||
"""当日可卖份额：is_t0 当日可卖，否则只算隔夜份额（T+1）。"""
|
||
if self.symbol.is_t0:
|
||
volume = self.volume
|
||
else:
|
||
volume = sum(lot.volume for lot in self.lots if lot.bought < day)
|
||
return volume - volume % 100
|
||
|
||
def add(self, volume: int, price: float, fee: float, day: date) -> None:
|
||
cost = (price * volume + fee) / volume if volume else price
|
||
for lot in self.lots:
|
||
if lot.bought == day:
|
||
total = lot.volume + volume
|
||
lot.cost = (lot.cost * lot.volume + cost * volume) / total
|
||
lot.volume = total
|
||
break
|
||
else:
|
||
self.lots.append(Lot(volume=volume, cost=cost, bought=day))
|
||
self.last_buy = price
|
||
self.max_level = max(self.max_level, self.volume // self.symbol.buy_shares)
|
||
|
||
def reduce(self, volume: int) -> float:
|
||
"""先进先出减仓，返回被减仓位的含费成本。"""
|
||
removed = 0.0
|
||
left = volume
|
||
while left > 0 and self.lots:
|
||
lot = self.lots[0]
|
||
take = min(lot.volume, left)
|
||
removed += take * lot.cost
|
||
lot.volume -= take
|
||
left -= take
|
||
if lot.volume <= 0:
|
||
self.lots.pop(0)
|
||
return removed
|
||
|
||
def held_days(self, day: date) -> int:
|
||
return min((day - lot.bought).days for lot in self.lots) if self.lots else 0
|
||
|
||
|
||
def precondition(
|
||
bars: list[dict], symbol: EtfSymbolConfig, defaults: EtfDefaults
|
||
) -> list[tuple[dict, dict]]:
|
||
"""给每根日线预先算好指标。
|
||
|
||
关键：传给 ``calculate`` 的 ``today`` 必须是**该日线自己的日期**。
|
||
策略里 ``today`` 是"运行当天"，而 ``calculate`` 会拒绝距今超过 15 个自然日的
|
||
日线（防停牌/缓存过期）；回测必须逐日回放，否则整段历史都会被当成过期数据丢掉。
|
||
"""
|
||
series = []
|
||
for index, bar in enumerate(bars):
|
||
if index + 1 < WARMUP:
|
||
continue
|
||
day = datetime.strptime(bar["date"], "%Y%m%d").date()
|
||
window = bars[max(0, index - 119): index + 1] # 与 signal.BAR_COUNT=120 一致
|
||
try:
|
||
ind = calculate(window, symbol, defaults, day)
|
||
except ValueError:
|
||
continue
|
||
series.append((bar, ind))
|
||
return series
|
||
|
||
|
||
def fill_price(
|
||
mode: str, trigger: float, bar: dict, side: str, rebound_pct: float = 0.5
|
||
) -> float:
|
||
"""把"触发价 + 当日 OHLC"折算成成交价。
|
||
|
||
- ``touch``：限价单在触价当天按触价成交（最乐观，隐含着"盘中挂单必成交"）。
|
||
- ``bounce``：跌到触发价后，等价格从当日最低点反弹 ``rebound_pct`` 才成交
|
||
（最贴近实盘 tick 语义，见 ``docs/etf.md`` §2.2 / §4.2）。
|
||
- ``close``：只在收盘时判断，并按收盘价成交（最悲观）。
|
||
"""
|
||
if mode == "touch":
|
||
return trigger
|
||
if mode == "bounce":
|
||
rebound = bar["low"] * (1 + rebound_pct / 100)
|
||
if side == "BUY":
|
||
return min(bar["close"], max(trigger, rebound))
|
||
return max(bar["close"], min(trigger, rebound))
|
||
return bar["close"]
|
||
|
||
|
||
def _order_volume(sizer, cash: float, price: float, symbol: EtfSymbolConfig) -> int:
|
||
"""单档股数：默认用配置的 ``buy_shares``，给了 ``sizer`` 就按资金比例算。"""
|
||
if sizer is None:
|
||
return symbol.buy_shares
|
||
volume = int(sizer(cash, price))
|
||
return max(0, volume - volume % 100)
|
||
|
||
|
||
def simulate(
|
||
data: dict[str, list[dict]],
|
||
*,
|
||
defaults: EtfDefaults | None = None,
|
||
symbol_params: dict | None = None,
|
||
fill_mode: str = "touch",
|
||
trigger_fill: bool | None = None,
|
||
secondary_exit: bool = True,
|
||
min_hold_days: int | None = None,
|
||
start_cash: float = START_CASH,
|
||
commission_rate: float = COMMISSION_RATE,
|
||
min_commission: float = MIN_COMMISSION,
|
||
sizer=None,
|
||
precomputed: dict | None = None,
|
||
) -> dict:
|
||
"""共享资金的多标的组合回测。
|
||
|
||
``fill_mode``：``touch`` / ``bounce`` / ``close``，见 ``fill_price``。
|
||
``trigger_fill``：兼容旧参数，False 等价于 ``close``。
|
||
``secondary_exit``：是否启用单档峰值回撤副出口。
|
||
``min_hold_days``：覆盖 min_hold_days（is_t0 标的仍不受限）。
|
||
``sizer``：``(equity, price) -> 股数``，把固定股数换成按资金比例下单。
|
||
``precomputed``：复用 ``precondition`` 结果加速扫描（其指标只依赖 symbol/defaults）。
|
||
"""
|
||
if trigger_fill is not None:
|
||
fill_mode = "touch" if trigger_fill else "close"
|
||
defaults = defaults or EtfDefaults()
|
||
params = symbol_params or SYMBOL_PARAMS
|
||
hold_days = defaults.min_hold_days if min_hold_days is None else min_hold_days
|
||
books = {
|
||
code: SymbolBook(code, EtfSymbolConfig(**{**params[code]}))
|
||
for code in data
|
||
}
|
||
if precomputed is not None:
|
||
series = precomputed
|
||
else:
|
||
series = {code: precondition(data[code], books[code].symbol, defaults) for code in data}
|
||
by_date = {code: {bar["date"]: (bar, ind) for bar, ind in series[code]} for code in data}
|
||
calendar = sorted({stamp for code in data for stamp in by_date[code]})
|
||
latest_close = {code: 0.0 for code in data}
|
||
cash = start_cash
|
||
fills: list[Fill] = []
|
||
curve: list[tuple[date, float, float, float]] = [] # 日期, 权益, 持仓市值, 现金
|
||
reserve = start_cash * MIN_CASH_RATIO
|
||
|
||
for stamp in calendar:
|
||
day = datetime.strptime(stamp, "%Y%m%d").date()
|
||
for code in sorted(data): # 白名单顺序即资金优先级
|
||
book = books[code]
|
||
row = by_date[code].get(stamp)
|
||
if row is None:
|
||
continue
|
||
bar, ind = row
|
||
close, high, low = bar["close"], bar["high"], bar["low"]
|
||
latest_close[code] = close
|
||
entry, grid = ind["etf_entry"], ind["etf_grid"]
|
||
symbol = book.symbol
|
||
|
||
# 1. 主出口：盈亏率 ≥ min_profit_pct，整仓止盈（受 T+1/min_hold_days 约束）
|
||
if book.volume > 0:
|
||
avg = book.avg_cost
|
||
target = avg * (1 + defaults.min_profit_pct / 100)
|
||
can_sell = book.sellable(day)
|
||
if (not symbol.is_t0) and hold_days > 0 and book.held_days(day) < hold_days:
|
||
can_sell = 0
|
||
if high >= target and can_sell > 0:
|
||
price = fill_price(fill_mode, target, bar, "SELL", defaults.rebound_pct)
|
||
price = min(price, high)
|
||
amount = price * can_sell
|
||
fee = fees(amount, commission_rate, min_commission)
|
||
cash += amount - fee
|
||
book.reduce(can_sell)
|
||
book.rounds += 1
|
||
book.peak_grid = None
|
||
fills.append(Fill(day, code, "SELL", "exit", can_sell, price, fee,
|
||
f"目标={target:.3f} 档位={book.max_level}"))
|
||
if book.volume == 0:
|
||
book.anchor, book.adds, book.last_buy, book.last_add_day = None, 0, 0.0, None
|
||
continue
|
||
|
||
# 2. 副出口：单档峰值回撤（只卖该档）
|
||
if secondary_exit and book.volume > 0:
|
||
avg = book.avg_cost
|
||
pnl_rate = (close - avg) / avg * 100
|
||
current = math.floor(pnl_rate / symbol.inner_step)
|
||
if book.peak_grid is None:
|
||
book.peak_grid = current
|
||
elif current > book.peak_grid:
|
||
book.peak_grid = current
|
||
elif current < book.peak_grid and book.peak_grid >= defaults.inner_grids:
|
||
volume = min(book.sellable(day), symbol.buy_shares)
|
||
if volume > 0:
|
||
amount = close * volume
|
||
fee = fees(amount, commission_rate, min_commission)
|
||
cash += amount - fee
|
||
book.reduce(volume)
|
||
fills.append(Fill(day, code, "SELL", "level", volume, close, fee,
|
||
f"峰值={book.peak_grid}格"))
|
||
book.peak_grid = None
|
||
|
||
# 3. 补仓：自上一档再跌 add_pct，当日收盘回到触发价之上
|
||
if book.volume > 0 and book.adds < defaults.max_adds and book.last_buy > 0:
|
||
trigger = book.last_buy * (1 - defaults.add_pct / 100)
|
||
room = symbol.max_shares - book.volume
|
||
volume = min(_order_volume(sizer, cash, trigger, symbol),
|
||
room - room % 100)
|
||
if volume > 0 and low <= trigger and close > trigger and book.last_add_day != day:
|
||
price = min(high, fill_price(fill_mode, trigger, bar, "BUY", defaults.rebound_pct))
|
||
amount = price * volume
|
||
fee = fees(amount, commission_rate, min_commission)
|
||
if amount + fee <= cash - reserve:
|
||
cash -= amount + fee
|
||
book.add(volume, price, fee, day)
|
||
book.adds += 1
|
||
book.last_add_day = day
|
||
drop = (book.last_buy / price - 1) * 100 if book.last_buy else 0.0
|
||
fills.append(Fill(day, code, "BUY", "add", volume, price, fee,
|
||
f"触发={trigger:.3f} 跌幅={drop:.2f}%"))
|
||
|
||
# 4. 建网：跌进入场门槛且当日收在门槛之上（反弹确认的日线近似）
|
||
if book.volume == 0 and book.anchor is None and low <= entry and close > entry:
|
||
price = min(high, fill_price(fill_mode, entry, bar, "BUY", defaults.rebound_pct))
|
||
volume = _order_volume(sizer, cash, entry, symbol)
|
||
amount = price * volume
|
||
fee = fees(amount, commission_rate, min_commission)
|
||
if amount + fee <= cash - reserve:
|
||
cash -= amount + fee
|
||
book.add(volume, price, fee, day)
|
||
book.anchor = price
|
||
book.adds = 0
|
||
book.last_add_day = day
|
||
book.peak_grid = None
|
||
fills.append(Fill(day, code, "BUY", "base", volume, price, fee,
|
||
f"门槛={entry:.3f} MA60={ind['etf_ma60']:.3f}"))
|
||
|
||
market_value = sum(books[code].volume * (latest_close[code] or 0.0) for code in data)
|
||
curve.append((day, cash + market_value, market_value, cash))
|
||
|
||
return {
|
||
"fills": fills,
|
||
"curve": curve,
|
||
"books": books,
|
||
"cash": cash,
|
||
"start_cash": start_cash,
|
||
"params": {
|
||
"fill_mode": fill_mode,
|
||
"secondary_exit": secondary_exit,
|
||
"min_hold_days": hold_days,
|
||
"add_pct": defaults.add_pct,
|
||
"min_profit_pct": defaults.min_profit_pct,
|
||
"channel_pct": defaults.channel_pct,
|
||
"max_adds": defaults.max_adds,
|
||
"commission_rate": commission_rate,
|
||
"min_commission": min_commission,
|
||
},
|
||
}
|
||
|
||
|
||
def analyze(result: dict) -> dict:
|
||
"""把成交与权益曲线折算成指标。"""
|
||
fills: list[Fill] = result["fills"]
|
||
curve = result["curve"]
|
||
buys = [f for f in fills if f.side == "BUY"]
|
||
sells = [f for f in fills if f.side == "SELL"]
|
||
buy_amount = sum(f.price * f.volume for f in buys)
|
||
sell_amount = sum(f.price * f.volume for f in sells)
|
||
fee_total = sum(f.fee for f in fills)
|
||
net = (sell_amount - buy_amount) - fee_total
|
||
equity = [point[1] for point in curve]
|
||
peak, max_dd = -math.inf, 0.0
|
||
for value in equity:
|
||
peak = max(peak, value)
|
||
max_dd = max(max_dd, (peak - value) / peak)
|
||
deployed = [point[2] for point in curve]
|
||
initial, final = result["start_cash"], equity[-1]
|
||
days = len(curve)
|
||
per_symbol = {}
|
||
for code, book in result["books"].items():
|
||
rows = [f for f in fills if f.code == code]
|
||
per_symbol[code] = {
|
||
"base": len([f for f in rows if f.kind == "base"]),
|
||
"adds": len([f for f in rows if f.kind == "add"]),
|
||
"exits": book.rounds,
|
||
"levels": len([f for f in rows if f.kind == "level"]),
|
||
"held_shares": book.volume,
|
||
"max_level": book.max_level,
|
||
"net": sum((f.price * f.volume if f.side == "SELL" else -f.price * f.volume) - f.fee for f in rows),
|
||
}
|
||
return {
|
||
"days": days,
|
||
"net": net,
|
||
"gross": sell_amount - buy_amount,
|
||
"fees": fee_total,
|
||
"fee_share_of_gross": fee_total / (sell_amount - buy_amount) * 100 if sell_amount > buy_amount else 0.0,
|
||
"return_pct": (final - initial) / initial * 100,
|
||
"max_dd_pct": max_dd * 100,
|
||
"buy_count": len(buys),
|
||
"sell_count": len(sells),
|
||
"buy_amount": buy_amount,
|
||
"turnover_x": buy_amount / initial,
|
||
"avg_deployed": statistics.fmean(deployed) if deployed else 0.0,
|
||
"avg_util_pct": (statistics.fmean(deployed) / initial * 100) if deployed else 0.0,
|
||
"max_deployed": max(deployed) if deployed else 0.0,
|
||
"final_equity": final,
|
||
"cash": result["cash"],
|
||
"per_symbol": per_symbol,
|
||
"params": result["params"],
|
||
}
|
||
|
||
|
||
def main() -> int:
|
||
parser = argparse.ArgumentParser()
|
||
parser.add_argument("--refresh", action="store_true")
|
||
parser.add_argument("--ledger", action="store_true", help="打印逐笔成交")
|
||
args = parser.parse_args()
|
||
|
||
defaults = EtfDefaults()
|
||
data = {code: fetch_daily(code, args.refresh) for code in SYMBOLS}
|
||
for code, bars in data.items():
|
||
print(f"{code}: {len(bars)} bars {bars[0]['date']}..{bars[-1]['date']}")
|
||
|
||
base = simulate(data)
|
||
stats = analyze(base)
|
||
print(json.dumps(stats, ensure_ascii=False, indent=2, default=str))
|
||
if args.ledger:
|
||
for fill in base["fills"]:
|
||
amount = fill.price * fill.volume
|
||
print(
|
||
f"{fill.day} {fill.code} {fill.side:4} {fill.kind:4} "
|
||
f"{fill.volume:6} @{fill.price:.3f} amount={amount:10.2f} "
|
||
f"fee={fill.fee:5.2f} {fill.note}"
|
||
)
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|