akg-factor-bridge/plan_review.py

782 lines
47 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""候选单复盘(只读):这个系统唯一的评价方式——名单级观察收益,不是回测。
## 为什么要有它
方案(docs/主观选股改进方案_2026-09-02.md 第 2.4 节)把评价单位定为"候选单"而不是因子:
不建仓、不计成本、不定仓位、不算净值,只看几份名单在后五、十、二十个交易日相对
全池与主榜的超额和命中率,按环境与证据线分组,每周五出报告。它取代了原对比器
score_lab(两套读数工具两种口径的坑),也承接了 09-02 手工归因的三组读数:
第一步先"对账"——用 signal_close 口径复现方案 1.8b 的四档读数(强传导 −2.04、
观察档 +0.52),证明脚本口径与手工一致;第二步再切常规口径 next_close 出周报。
本脚本不提供权重参数,只提供分组与期限——防止复盘变成调参或模拟交易。
## 六份名单
生产名单 PMS 实际拿到的候选:PMS 计划快照名册(pms_plan_snapshot.roster_json)里档位为
强传导、按分数降序前 N(N 取当时 PMS_PLAN_TOP_N,历史值不可还原,用现值并注明);
快照缺失的日子退为桥按同规则重算并标注
候选单 候选卡判决为"候选"(候选卡上线日之前的历史日,按当日快照或重算得出,
"已启动"依赖已动成员视图,视图未建的日子候选为空并标注)
关注单 判决为"关注"
环节名单 当日被传导指向的环节的全体成员等权(把"定位对"与"选票对"分开)
主榜等权 当日全部主榜
全池等权 基座行情快照当日全部个股(基准)
## 另四份名单(2026-09-03 方案第 3.3 节"复盘四份名单与对照节")
机器通过名单 PMS 动作账本 pms_action_ledger 当日 action='OPEN'、arbiter='judge'、verdict='PASS' 的票
人批名单 同表当日 arbiter='user'、verdict='PASS'
人拒名单 同表当日 arbiter='user'、verdict='REJECT'
择时看多名单 择时决策系统结论表 strategy_daily_results 当日 signal_type='BUY' 的票
账本按 decided_at 的日历日筛,代码统一转前缀式;任一路读失败该名单为空并在逐日注记里说明。
周报第七节"三套对照"把选股系统候选单、择时决策系统自评、PMS 账本四份名单摆在一张表里;
第八节"台账对表"列出 docs/复盘决定台账.md 的条目,留"一致 / 不一致"两列给人填。
## 口径
起点价 next_close(默认,实盘买得到):T 日出计划,T+1 收盘买,收益 = Σ pct[T+2 .. T+1+h]
signal_close(对账用):收益 = Σ pct[T+1 .. T+h],与方案 1.8 系列的手工口径一致
期限 5 / 10 / 20 个交易日
指标 均收益、相对全池超额、相对主榜超额、跑赢全池比例(命中率)
分组 档位、判决、吸筹三态(基座行情快照当日的 accum 状态)、事后环境(全池后 h 日涨跌,
只作解释)、事前标签(当日快照 regime 段,上线后才有)、市值三分位(成交额除以换手率)
## 跑法【桥机 155 · ~/project/akg-factor-bridge】
docker compose exec -T akg-factor-bridge python plan_review.py --since 2026-07-29 --horizons 5,10,20
docker compose exec -T akg-factor-bridge python plan_review.py --since 2026-07-29 --start-price signal_close --horizons 5 # 对账 1.8b
只读:因子表、基座视图与行情快照、PMS 计划快照全部 SELECT;只写 data/review/ 下的报告与明细。
"""
from __future__ import annotations
import argparse
import datetime as dt
import json
import os
import re
import pandas as pd
import common
import card
import config
import db
import plan
HORIZONS_DEFAULT = (5, 10, 20)
MAIN_MIN = 150.0
LEDGER_LISTS = ("机器通过名单", "人批名单", "人拒名单")
TIMING_LIST = "择时看多名单"
DECISION_LEDGER_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "docs", "复盘决定台账.md")
# ============================================================================
# 数据
# ============================================================================
def plan_dates(since: str, until: str | None) -> list[str]:
q = "SELECT DISTINCT trade_date FROM t_factor_akg_gate WHERE trade_date >= %s"
args = [since]
if until:
q += " AND trade_date <= %s"
args.append(until)
df = db.read_mysql("factor", q + " ORDER BY trade_date", tuple(args))
return [pd.Timestamp(x).date().isoformat() for x in df["trade_date"]]
def price_panel(since: str, days_after: int = 30) -> pd.DataFrame:
"""基座行情快照:trade_date × 前缀码 -> 日涨幅(百分数)。"""
end = (dt.date.fromisoformat(since) + dt.timedelta(days=200)).isoformat()
df = db.read_pg(
"SELECT trade_date, code, (metrics->>'pct_change')::float AS pct, "
"metrics->'accum'->>'state' AS accum FROM mkt_daily "
"WHERE kind='stock' AND trade_date >= %s AND trade_date <= %s", (since, end))
df["k"] = df["code"].map(common.to_prefix)
df["trade_date"] = pd.to_datetime(df["trade_date"]).dt.date.astype(str)
return df
def cap_bucket(day: str) -> dict[str, str]:
"""市值三分位(成交额除以换手率的近似流通市值),同日分桶。读不到返回空。"""
try:
df = db.read_mysql(
"factor", "SELECT symbol, amount, turnoverrate FROM gp_day_data "
"WHERE DATE(`timestamp`) = %s AND turnoverrate > 0 AND amount > 0", (day,))
except Exception as e: # noqa: BLE001
print(f" (市值分桶读取失败 {day}: {e!r})")
return {}
if df.empty:
return {}
df["k"] = df["symbol"].astype(str).str.strip().map(common.to_prefix)
df["mv"] = df["amount"] / df["turnoverrate"]
try:
df["cap"] = pd.qcut(df["mv"], 3, labels=["小盘", "中盘", "大盘"])
except ValueError:
return {}
return dict(zip(df["k"], df["cap"].astype(str)))
def _roster_pick(rows, tiers, mode, n) -> list[str]:
"""从名册行还原 PMS 当天交付的生产名单(纯函数,可离线测)。
档位白名单是一道独立的门、与排序模式无关(PMS 任何模式下都先按它过滤主榜行再截断),所以
两种模式都先过滤、再定序:upstream 按上游名次 r 升序,否则按分数 s 降序,取前 n。tiers 为空
表示不按档过滤。返回前缀式代码列表。"""
main = [r for r in rows if str(r.get("b") or "main") == "main"]
tset = {str(t).strip() for t in (tiers or []) if str(t).strip()}
if tset:
main = [r for r in main if str(r.get("t") or "") in tset]
if mode == "upstream":
main.sort(key=lambda r: r.get("r") if r.get("r") is not None else 1 << 60)
else:
main.sort(key=lambda r: -(r.get("s") or 0))
return [common.to_prefix(str(r["c"]).strip()) for r in main[:n] if r.get("c")]
def pms_roster(day: str) -> tuple[list[str], str]:
"""PMS 当日拿到的生产名单。返回 (代码, 注记)。档位白名单(PMS_PLAN_TIERS,与排序模式无关的独立门)
两种模式下都先过滤,再按名册元数据 rank_mode 定序(2026-09-17 工作包乙):upstream 按上游名次升序,
否则按分数降序。白名单从参数表读,缺行退回"强传导"(与持仓管理系统 settings 初值一致),空串不过滤。"""
try:
df = db.read_mysql(
"pms", "SELECT roster_json, meta_json, fetched_at FROM pms_plan_snapshot "
"WHERE plan_date = %s AND JSON_UNQUOTE(JSON_EXTRACT(meta_json, '$.kind')) = 'consumed' "
"ORDER BY id DESC LIMIT 1", (day,))
except Exception as e: # noqa: BLE001
# 异常原文会被印进周报的逐日注记。只进日志,不进报告。
print(f" (PMS 计划快照读取失败: {e!r})")
return [], "当天没能连上 PMS 数据库,取不到计划快照"
if df.empty:
return [], 'PMS 缺真实消费记录,排除消费效果统计'
roster = json.loads(df.iloc[0]["roster_json"] or "[]")
try:
meta = json.loads(df.iloc[0]["meta_json"] or "{}")
except (TypeError, ValueError):
meta = {}
if meta.get('kind') != 'consumed' or not meta.get('decision'):
return [], '旧名册未记录实际消费参数,排除消费效果统计'
return [common.to_prefix(c) for c in meta.get('order') or []], 'PMS 实际消费:' + str(meta.get('id'))
def _uniq_codes(values) -> list[str]:
"""代码列 -> 去重、去占位符(账本里宏观闸等行的 ts_code 是 "-")、转前缀式,保持出现顺序。"""
out, seen = [], set()
for v in values:
s = str(v or "").strip()
if not s or s == "-" or s.lower() == "nan":
continue
k = common.to_prefix(s.upper())
if k not in seen:
seen.add(k)
out.append(k)
return out
def ledger_lists(day: str) -> tuple[dict[str, list[str]], str]:
"""PMS 动作账本当日新建仓评审的三份名单:机器通过(研判闸 judge 放行)、人批、人拒。
decided_at 按日历日筛(day 零点到次日零点);读失败三份都为空并返回原因。"""
empty = {name: [] for name in LEDGER_LISTS}
nxt = (dt.date.fromisoformat(day) + dt.timedelta(days=1)).isoformat()
try:
df = db.read_mysql(
"pms", "SELECT ts_code, arbiter, verdict FROM pms_action_ledger "
"WHERE action = 'OPEN' AND decided_at >= %s AND decided_at < %s", (day, nxt))
except Exception as e: # noqa: BLE001
return empty, f"PMS 账本读取失败({e!r}),机器通过、人批、人拒三份名单为空"
if df.empty:
return empty, "PMS 账本当日无新建仓评审行"
arb = df["arbiter"].astype(str).str.strip().str.lower()
vd = df["verdict"].astype(str).str.strip().str.upper()
return {
"机器通过名单": _uniq_codes(df.loc[(arb == "judge") & (vd == "PASS"), "ts_code"]),
"人批名单": _uniq_codes(df.loc[(arb == "user") & (vd == "PASS"), "ts_code"]),
"人拒名单": _uniq_codes(df.loc[(arb == "user") & (vd == "REJECT"), "ts_code"]),
}, f"PMS 账本当日评审行 {len(df)} 条"
def timing_bullish(day: str) -> tuple[list[str], str]:
"""择时决策系统结论表当日 signal_type='BUY' 的票(trade_date 是整数 YYYYMMDD)。读失败为空。"""
try:
df = db.read_mysql(
"pms", "SELECT stock_code FROM strategy_daily_results "
"WHERE trade_date = %s AND signal_type = 'BUY'", (int(day.replace("-", "")),))
except Exception as e: # noqa: BLE001
return [], f"择时决策系统结论表读取失败({e!r}),择时看多名单为空"
return _uniq_codes(df["stock_code"]) if not df.empty else [], ""
def timing_self_eval(since: str, until: str | None) -> str:
"""择时决策系统自评口径与本期读数:判分表 decision_outcome 里日终策略(ref_type='strategy')
五日方向命中率——命中按原始收益方向判,不是超额(方案第 1.3 节列为已知缺陷)。读不到写"未接入"。"""
lo = int(since.replace("-", ""))
hi = int((until or dt.date.today().isoformat()).replace("-", ""))
try:
df = db.read_mysql(
"pms", "SELECT COUNT(*) AS n, SUM(dir_hit) AS hits FROM decision_outcome "
"WHERE ref_type = 'strategy' AND horizon = 5 AND dir_hit IS NOT NULL "
"AND base_date >= %s AND base_date <= %s", (lo, hi))
n = int(df.iloc[0]["n"] or 0) if not df.empty else 0
hits = int(df.iloc[0]["hits"] or 0) if not df.empty else 0
except Exception as e: # noqa: BLE001
# 表名是 PMS 的库表名,不该出现在周报的读数列里。原因写进运行日志。
print(f" (择时决策系统的打分表读取失败: {e!r})")
return (f"读不到择时决策系统的打分数据,"
f"{since} 至 {until or '今日'} 这段的五日方向命中率这期算不出来")
if n == 0:
# 与"读不到"分开写:这两种情况在表里要一眼看得出差别。
return "择时决策系统这段时间没有打过分的日终策略记录,这期没有命中率"
return (f"看 5 个交易日后涨跌方向判断对不对,{n} 条里对了 {hits} 条,"
f"命中率 {hits / n * 100:.0f}%({since} 至 {until or '今日'})")
def timing_head_eval(since: str, until: str | None, *, ref_type: str, horizon: int) -> str:
"""量价研判链某个头的方向命中率(2026-09-16 小改,配合数据基座量价判收第四条):
五日头判分种类 pv_h5 期限 5、二十日头 pv_h20 期限 20。查询与 timing_self_eval 同款,
只把 ref_type 与 horizon 换成参数。没有判分记录写"本期无判分记录",读不到写"读不到",两种分开。"""
lo = int(since.replace("-", ""))
hi = int((until or dt.date.today().isoformat()).replace("-", ""))
try:
df = db.read_mysql(
"pms", "SELECT COUNT(*) AS n, SUM(dir_hit) AS hits FROM decision_outcome "
"WHERE ref_type = %s AND horizon = %s AND dir_hit IS NOT NULL "
"AND base_date >= %s AND base_date <= %s", (ref_type, horizon, lo, hi))
n = int(df.iloc[0]["n"] or 0) if not df.empty else 0
hits = int(df.iloc[0]["hits"] or 0) if not df.empty else 0
except Exception as e: # noqa: BLE001
print(f" (量价 {ref_type} 判分表读取失败: {e!r})")
return "读不到"
if n == 0:
return f"本期无判分记录(判分种类 {ref_type} 尚未产生)"
return (f"看 {horizon} 个交易日后涨跌方向判断对不对,{n} 条里对了 {hits} 条,"
f"命中率 {hits / n * 100:.0f}%({since} 至 {until or '今日'})")
def decision_ledger_entries(path: str = DECISION_LEDGER_PATH) -> list[dict]:
"""解析 docs/复盘决定台账.md 的条目标题行 "## 0NN · 日期 · 标题" -> [{no, date, title}]。
文件不存在或没有条目返回空列表,周报对表节据此写"台账文件缺失"。"""
try:
with open(path, "r", encoding="utf-8") as f:
text = f.read()
except OSError:
return []
pat = re.compile(r"^##\s+(\d{3})\s*·\s*(\d{4}-\d{2}-\d{2})\s*·\s*(.+?)\s*$", re.M)
return [{"no": m.group(1), "date": m.group(2), "title": m.group(3)} for m in pat.finditer(text)]
# ============================================================================
# 收益
# ============================================================================
def forward(pivot: pd.DataFrame, days: list[str], day: str, h: int, start: str) -> pd.Series | None:
"""从 day 起按口径取后 h 日累计涨幅(每票)。数据不够返回 None。"""
if day not in days:
return None
i = days.index(day)
lo = i + (2 if start == "next_close" else 1)
hi = lo + h # 切片 [lo, hi)
if hi > len(days):
return None
block = pivot.loc[days[lo:hi]]
return block.sum(min_count=h)
# 表头的中文说法。周报是给人读的,列名不该是代码里的字段名。
# 有几处必须区分开,不能想当然地译:
# excess_all 与 beat 都跟"全池"比,但一个是收益差、一个是只数比例,
# 译成同一个说法会在同一张表里紧挨着撞车;
# h 不能译成"持有天数"——这个脚本开头反复写明不建仓、不计成本、不是回测,
# 它只是"往后看几个交易日";
# grade 只有两档(可读、方向),代码在 :387,导读段落此前写着"三档"是错的。
_COL_CN = {
"days": "一共几个计划日", "n": "一共几只股票", "ret": "名单平均涨跌%",
"excess_all": "比全池多涨几个点", "excess_main": "比主榜多涨几个点",
"excess_cap": "比同市值股票多涨几个点",
"beat": "跑赢全池的股票占比%", "share": "最多的一天占了多少%",
"grade": "样本够不够看", "h": "往后看几个交易日",
"list": "名单", "group": "分组", "date": "计划日",
"regime_post": "这几天全池是涨是跌", "regime_pre": "下单当天是不是弱势日",
}
# 加权版列名到本体列名的对应。多数是直接去掉 _w 后缀就能对上,只有 excess_w 例外——
# 它算的是相对全池的超额(:433),本体列叫 excess_all,去掉后缀查不到。
_W_BASE = {"excess_w": "excess_all"}
def _col_cn(c) -> str:
"""列名翻成中文。带 _w 后缀的是同一个读数的样本加权版本,只用于对账。
翻不出来的原样返回而不是硬编一个中文——列名对不上时宁可露出原名让人发现,
也好过给它安一个错的说法。
"""
name = str(c)
if name.endswith("_w"):
base = _COL_CN.get(_W_BASE.get(name) or name[:-2])
return f"股票多的日子算得重·{base}" if base else name
return _COL_CN.get(name, name)
def _md(df: pd.DataFrame) -> str:
"""自己拼 Markdown 表:桥镜像没装 tabulate,pandas.to_markdown 用不了。
表头统一在这里翻成中文,每张表都受益,不用逐处改。"""
if df is None or df.empty:
return "(无数据)"
cols = [_col_cn(c) for c in df.columns]
lines = ["| " + " | ".join(cols) + " |", "|" + "---|" * len(cols)]
for _, r in df.iterrows():
lines.append("| " + " | ".join("" if (isinstance(v, float) and pd.isna(v)) else str(v)
for v in r.tolist()) + " |")
return "\n".join(lines)
def summarize(ret: pd.Series, codes: list[str], base_all: float, base_main: float,
caps: dict | None = None, cap_base: dict | None = None) -> dict | None:
"""一份名单在一个计划日、一个期限上的读数。
excess_all 相对全池等权;excess_main 相对主榜等权(同为有券商覆盖的篮子,剥掉大票对小票的贝塔);
excess_cap 相对同市值桶均值(每票减当日同桶全池均值再平均,方案 1.8c 的市值中性口径)。"""
r = ret.reindex([c for c in codes if c in ret.index]).dropna()
if r.empty:
return None
out = {"n": int(len(r)), "ret": round(float(r.mean()), 2),
"excess_all": round(float(r.mean() - base_all), 2),
"excess_main": round(float(r.mean() - base_main), 2) if base_main is not None else None,
"excess_cap": None,
"beat": round(float((r > base_all).mean() * 100), 1)}
if caps and cap_base:
adj = [float(v) - cap_base[caps[c]] for c, v in r.items() if caps.get(c) in cap_base]
if adj:
out["excess_cap"] = round(sum(adj) / len(adj), 2)
return out
# ============================================================================
# 主流程
# ============================================================================
def _pricing_spread_md(groups_tbl: pd.DataFrame) -> str:
"""定价状态的"多空差"式对照(2026-09-08):候选单里价格发现与趋势延续两组的超额均值,减去高位兑现组,
按期限各一行。研报用它检验方向区分能力;我们只作名单级观察,样本不够只看方向。"""
if groups_tbl is None or groups_tbl.empty or "group" not in groups_tbl.columns:
return ""
g = groups_tbl[(groups_tbl["list"] == "候选单") & groups_tbl["group"].astype(str).str.startswith("定价状态=")]
if g.empty:
return "(定价状态分组本期无样本,多空差不算。)"
lines = ["定价状态的多空差(候选单,价格发现与趋势延续两组的「比全池多涨几个点」均值,减去高位兑现组):", ""]
for h, gh in g.groupby("h"):
val = {str(r["group"]).replace("定价状态=", ""): r for _, r in gh.iterrows()}
bull = [val[k] for k in ("价格发现", "趋势延续") if k in val]
bear = val.get("高位兑现")
if not bull or bear is None:
lines.append(f"- {h} 日:两端不齐(多头端 {len(bull)} 组,高位兑现组{'有' if bear is not None else '无'}),不算。")
continue
bull_ex = sum(float(r["excess_all"]) for r in bull) / len(bull)
n_bull = sum(int(r["n"]) for r in bull)
diff = bull_ex - float(bear["excess_all"])
lines.append(f"- {h} 日:多头端 {n_bull} 只样本、比全池多涨 {bull_ex:+.2f} 个点;高位兑现 {int(bear['n'])} 只、"
f"{float(bear['excess_all']):+.2f} 个点;差 {diff:+.2f} 个点,样本"
f"{'够' if n_bull >= 100 and int(bear['n']) >= 30 else '不够,只看方向'}。")
return "\n".join(lines)
def _read_review_snapshot(day: str):
"""读当日计划快照,整理成与 plan.collect 返回同形的字典(_full 放全量 main/observe,顶层带
candidates/watch)。快照不存在、坏 JSON、或 main 不是列表,回 None,由调用方回落到现算。"""
try:
import plan_versions
snap = plan_versions.load(config.PLAN_SNAPSHOT_DIR, day, morning=True)
if not plan_versions.morning_eligible(snap):
return None
except (OSError, ValueError):
return None
main = snap.get("main")
if not isinstance(main, list):
return None
return {"date": snap.get("date") or day,
'decision': snap.get('decision'), 'regime': snap.get('regime'),
"_full": {"main": main, "observe": snap.get("observe") or []},
"candidates": snap.get("candidates") or [], "watch": snap.get("watch") or []}
def _plan_for_review(day: str):
"""周报某个计划日的底本(工作包丙,2026-09-17 拍板):默认先读当天落盘快照(当天真出过的那份),
快照读不出才回落现算;开关 PLAN_REVIEW_SOURCE=live 直接现算。现算用跑周报那一刻的评析报告、
查询不按日期截断,质地成主轴后会把晚到的报告回头算进当天名单,四周复核要的是当天真出过的那份。
返回 (data, 底本名)。"""
snap = _read_review_snapshot(day)
if snap is None:
raise RuntimeError('缺可核验晨版,排除真实决策效果统计;不以当前研究回填')
return snap, '首个成功发布晨版'
def trace_rows(day):
"""逐版本、逐消费记录的独立对账底本,不把盘中多版当成多个独立交易日。"""
import plan_versions as pv
rows, versions = [], {}
try:
history = pv.history(config.PLAN_SNAPSHOT_DIR, day)
verified = bool(history) and pv.morning_eligible(history[0])
for i, p in enumerate(history):
d = p['decision']
versions[d['id']] = p
rows.append({'date': day, 'kind': 'morning' if i == 0 else 'revision',
'decision_id': d['id'], 'parent_id': d.get('parent_id'),
'at': d['cutoff_at'], 'reason': d['reason'], 'verified': verified,
'order': [r['code'] for r in p['main']], 'params': {}})
except (OSError, ValueError):
rows.append({'date': day, 'kind': 'missing_archive', 'verified': False})
try:
df = db.read_mysql('pms', 'SELECT id, fetched_at, meta_json FROM pms_plan_snapshot '
'WHERE plan_date = %s ORDER BY id', (day,))
for raw in df.to_dict('records'):
meta = json.loads(raw.get('meta_json') or '{}')
if meta.get('kind') not in ('consumed', 'rechecked'):
continue
did = (meta.get('decision') or {}).get('id')
rows.append({'date': day, 'kind': meta['kind'], 'decision_id': did,
'consumption_id': meta.get('id'), 'at': str(raw['fetched_at']),
'verified': did in versions, 'order': meta.get('order'),
'params': meta.get('params'), 'context': meta.get('context'),
'filtered': meta.get('filtered')})
except Exception as e:
rows.append({'date': day, 'kind': 'consumption_unavailable', 'verified': False,
'reason': type(e).__name__})
return rows
def run(since: str, until: str | None, horizons: tuple, start: str, out_dir: str,
with_cards: bool = True) -> dict:
days_plan = plan_dates(since, until)
if not days_plan:
raise SystemExit("区间内没有档位日。")
px = price_panel(since)
pivot = px.pivot_table(index="trade_date", columns="k", values="pct")
days = sorted(pivot.index.tolist())
accum_by_day = {d: dict(zip(g["k"], g["accum"])) for d, g in px.groupby("trade_date")}
rows, notes, traces = [], [], []
covered = 0
for day in days_plan:
traces.extend(trace_rows(day))
try:
data, benben = _plan_for_review(day)
except Exception as e: # noqa: BLE001
notes.append(f"{day}: 计划取数失败 {e!r}")
continue
full = data.get("_full") or {}
covered += 1
main_rows, obs_rows = full.get("main", []), full.get("observe", [])
main_codes = [r["code"] for r in main_rows]
obs_codes = [r["code"] for r in obs_rows]
tier_of = {r["code"]: r.get("tier") for r in main_rows}
verdict_of = {r["code"]: r.get("verdict") for r in main_rows + obs_rows}
seg_codes = sorted({r["code"] for r in main_rows + obs_rows if r.get("evidence")})
# 过渡期四周对照(2026-09-17):新序前二十(main_rows 已按 rank 排)与旧序前二十(按 rank_old)。
# rank_old 只在质地轴下有;旧快照缺该键就跳过这两份名单。
band_of = {r["code"]: r.get("quality_band") for r in main_rows}
main_new20 = [r["code"] for r in main_rows[:20]]
main_old20 = ([r["code"] for r in sorted(
main_rows, key=lambda r: r.get("rank_old") if r.get("rank_old") is not None else 1 << 60)[:20]]
if main_rows and main_rows[0].get("rank_old") is not None else None)
prod, prod_note = pms_roster(day)
if not prod:
# 无 PMS 快照的日子不再退化为桥重算(那不是 PMS 拿到的名单):交付名单当日剔除并注记(台账 010)
prod_note = f"{prod_note};无快照,交付名单当日剔除"
cands = [r["code"] for r in data.get("candidates") or []]
watch = [r["code"] for r in data.get("watch") or []]
ledger, ledger_note = ledger_lists(day)
bullish, bullish_note = timing_bullish(day)
caps = cap_bucket(day)
acc = accum_by_day.get(day, {})
reg = None
try:
import regime
reg = data.get('regime')
except Exception: # noqa: BLE001
reg = None
for h in horizons:
ret = forward(pivot, days, day, h, start)
if ret is None:
continue
base_all = float(ret.dropna().mean())
main_ret = ret.reindex([c for c in main_codes if c in ret.index]).dropna()
base_main = float(main_ret.mean()) if not main_ret.empty else None
cap_base: dict = {} # 当日三个市值桶各自的全池均值,供 excess_cap 用
if caps:
for cap in ("小盘", "中盘", "大盘"):
v = ret.reindex([c for c, b in caps.items() if b == cap and c in ret.index]).dropna()
if not v.empty:
cap_base[cap] = float(v.mean())
regime_post = "涨周" if base_all > 0 else "跌周"
regime_pre = (("弱势日" if reg.get("weak_day") else "非弱势日")
if reg and reg.get("weak_day") is not None else "无标签")
lists = {
"强传导交付名单": prod, "候选单": cands, "关注单": watch, "环节名单": seg_codes,
"主榜等权": main_codes, "观察档等权": obs_codes,
"全池等权": list(ret.dropna().index),
# 过渡期四周并列(2026-09-17):新序前二十与旧序前二十,看排序轴换掉后前列超额的变化。
"主榜新序前二十": main_new20,
**({"主榜旧序前二十": main_old20} if main_old20 else {}),
# 2026-09-03:PMS 账本三份与择时看多一份,与其余名单同口径算收益
**ledger, TIMING_LIST: bullish,
}
for name, codes in lists.items():
s = summarize(ret, codes, base_all, base_main, caps, cap_base)
if s:
rows.append({"date": day, "h": h, "list": name, "group": "全部",
"regime_post": regime_post, "regime_pre": regime_pre, **s})
# 分组:档位、判决、吸筹三态、市值
for tier in ("强传导", "弱传导", "无传导"):
codes = [c for c, t in tier_of.items() if t == tier]
s = summarize(ret, codes, base_all, base_main, caps, cap_base)
if s:
rows.append({"date": day, "h": h, "list": "主榜", "group": f"档位={tier}",
"regime_post": regime_post, "regime_pre": regime_pre, **s})
# 档位×质地带交叉分组(2026-09-17):看传导在质地档内还剩多少信息量
_band_label = {3: "好", 2: "中", 1: "无评析", 0: "差"}
for tier in ("强传导", "弱传导", "无传导"):
for b in (3, 2, 1, 0):
codes = [c for c, t in tier_of.items() if t == tier and band_of.get(c) == b]
s = summarize(ret, codes, base_all, base_main, caps, cap_base)
if s:
rows.append({"date": day, "h": h, "list": "主榜",
"group": f"档位×质地={tier}×{_band_label[b]}",
"regime_post": regime_post, "regime_pre": regime_pre, **s})
for v in ("候选", "关注", "仅展示"):
codes = [c for c, vv in verdict_of.items() if vv == v]
s = summarize(ret, codes, base_all, base_main, caps, cap_base)
if s:
rows.append({"date": day, "h": h, "list": "档位表", "group": f"判决={v}",
"regime_post": regime_post, "regime_pre": regime_pre, **s})
for st_label, pred in (("明确吸筹", lambda s: str(s).startswith("明确")),
("潜在吸筹", lambda s: str(s).startswith("潜在")),
("其他", lambda s: not (str(s).startswith("明确") or str(s).startswith("潜在")))):
codes = [c for c, s in acc.items() if s and pred(s)]
s = summarize(ret, codes, base_all, base_main, caps, cap_base)
if s:
rows.append({"date": day, "h": h, "list": "全池", "group": f"吸筹={st_label}",
"regime_post": regime_post, "regime_pre": regime_pre, **s})
if caps:
for cap in ("小盘", "中盘", "大盘"):
codes = [c for c in cands if caps.get(c) == cap]
s = summarize(ret, codes, base_all, base_main, caps, cap_base)
if s:
rows.append({"date": day, "h": h, "list": "候选单", "group": f"市值={cap}",
"regime_post": regime_post, "regime_pre": regime_pre, **s})
# 定价状态四情形与有无催化事件(2026-09-08《量价研判链吸收方案》3.4 第三件):
# 候选单与档位表各分一次,只作观察,决定"要不要当门槛"的依据在这里攒。
pricing_of = {r["code"]: (r.get("pricing_state") or {}).get("state") for r in main_rows + obs_rows}
event_of = {r["code"]: bool((r.get("events") or {}).get("events")) for r in main_rows + obs_rows}
for lst_name, lst_codes in (("候选单", cands), ("档位表", list(pricing_of))):
for st_name in ("价格发现", "趋势延续", "高位兑现", "震荡消化", "算不出"):
codes = [c for c in lst_codes if (pricing_of.get(c) or "算不出") == st_name]
s = summarize(ret, codes, base_all, base_main, caps, cap_base)
if s:
rows.append({"date": day, "h": h, "list": lst_name, "group": f"定价状态={st_name}",
"regime_post": regime_post, "regime_pre": regime_pre, **s})
for flag, label in ((True, "有"), (False, "无")):
codes = [c for c in lst_codes if event_of.get(c, False) is flag]
s = summarize(ret, codes, base_all, base_main, caps, cap_base)
if s:
rows.append({"date": day, "h": h, "list": lst_name, "group": f"催化事件={label}",
"regime_post": regime_post, "regime_pre": regime_pre, **s})
# 公司质地四档(2026-09-09 接入方案):好 / 中 / 差 / 无,候选单与档位表各分一次。
cq_of = {r["code"]: card.company_review_label(r.get("company_review")) for r in main_rows + obs_rows}
for lst_name, lst_codes in (("候选单", cands), ("档位表", list(cq_of))):
for label in ("好", "中", "差", "无"):
codes = [c for c in lst_codes if cq_of.get(c, "无") == label]
s = summarize(ret, codes, base_all, base_main, caps, cap_base)
if s:
rows.append({"date": day, "h": h, "list": lst_name, "group": f"公司质地={label}",
"regime_post": regime_post, "regime_pre": regime_pre, **s})
# 行业催化有无(2026-09-08 台账 051):环节级催化,只作观察分组;材料未到时全部落"无"。
ind_of = {r["code"]: bool(r.get("industry_catalyst")) for r in main_rows + obs_rows}
for lst_name, lst_codes in (("候选单", cands), ("档位表", list(ind_of))):
for flag, label in ((True, "有"), (False, "无")):
codes = [c for c in lst_codes if ind_of.get(c, False) is flag]
s = summarize(ret, codes, base_all, base_main, caps, cap_base)
if s:
rows.append({"date": day, "h": h, "list": lst_name, "group": f"行业催化={label}",
"regime_post": regime_post, "regime_pre": regime_pre, **s})
notes.append(f"{day}: 底本:{benben};主榜 {len(main_codes)} 观察 {len(obs_rows)} 候选 {len(cands)} "
f"关注 {len(watch)} 生产 {len(prod)}({prod_note});"
f"账本 机器通过 {len(ledger['机器通过名单'])} 人批 {len(ledger['人批名单'])} "
f"人拒 {len(ledger['人拒名单'])}({ledger_note});择时看多 {len(bullish)}"
+ (f"({bullish_note})" if bullish_note else ""))
df = pd.DataFrame(rows)
os.makedirs(out_dir, exist_ok=True)
stamp = days_plan[-1]
trace_path = os.path.join(out_dir, f'版本消费对账_{stamp}_{start}.csv')
trace_df = pd.DataFrame([{k: json.dumps(v, ensure_ascii=False, sort_keys=True)
if isinstance(v, (dict, list)) else v for k, v in row.items()}
for row in traces])
trace_df.to_csv(trace_path, index=False, encoding='utf-8-sig')
if df.empty:
raise SystemExit('没有可核验且期限成熟的样本;缺档明细已保存:' + trace_path)
csv_path = os.path.join(out_dir, f"复盘明细_{stamp}_{start}.csv")
df.to_csv(csv_path, index=False, encoding="utf-8-sig")
# 汇总:按名单 × 期限(全部);按分组 × 期限;按事后环境 × 名单(只作解释)
def agg(g: pd.DataFrame) -> pd.Series:
# 主口径按日等权:每个计划日先算名单均值,再跨日平均——一份名单一天一票;
# 带 _w 的三列按样本加权(大名单的日子权重大),与方案 1.8b/1.8c 手工读数同口径,只作对账。
n = g["n"].astype(float)
w = n / n.sum() if n.sum() else n
days, total = g["date"].nunique(), int(n.sum())
# 样本纪律(方案 2.4)机器标注,只有两档:可读=计划日≥20 且样本≥100;其余只看方向
grade = "够" if (days >= 20 and total >= 100) else "不够,只看方向"
return pd.Series({"days": days, "n": total,
"ret": round(g["ret"].mean(), 2),
"excess_all": round(g["excess_all"].mean(), 2),
"excess_main": round(g["excess_main"].mean(), 2) if g["excess_main"].notna().any() else None,
"excess_cap": round(g["excess_cap"].mean(), 2) if g["excess_cap"].notna().any() else None,
"beat": round(g["beat"].mean(), 1),
"share": round(float(n.max() / n.sum() * 100), 0) if n.sum() else None,
"grade": grade,
"ret_w": round(float((g["ret"] * w).sum()), 2),
"excess_w": round(float((g["excess_all"] * w).sum()), 2),
"beat_w": round(float((g["beat"] * w).sum()), 1)})
lists_tbl = df[df["group"] == "全部"].groupby(["list", "h"]).apply(agg).reset_index()
groups_tbl = df[df["group"] != "全部"].groupby(["list", "group", "h"]).apply(agg).reset_index()
regime_tbl = df[df["group"] == "全部"].groupby(["regime_post", "list", "h"]).apply(agg).reset_index()
pre_tbl = df[(df["group"] == "全部") & (df["regime_pre"] != "无标签")] \
.groupby(["regime_pre", "list", "h"]).apply(agg).reset_index()
h0 = int(df["h"].min())
daily_c = df[(df["list"] == "候选单") & (df["group"] == "全部") & (df["h"] == h0)] \
[["date", "n", "ret", "excess_all", "excess_cap", "beat", "regime_post"]].sort_values("date")
md = [f"# 候选单复盘 · {days_plan[0]} 至 {stamp}(起点价 {start})", "",
f"这份周报覆盖 {len(days_plan)} 个计划日。"
f"一份名单要够二十个计划日、且总共够一百只股票,读数才算够看;"
f"不够的只看方向,不看具体数值。", "",
"## 一、六份名单 × 期限", "",
"怎么读这张表。"
"「比全池多涨几个点」是拿这份名单和当天全部股票的平均涨跌相比;"
"「比主榜多涨几个点」是和主榜相比,这样能去掉大盘股和小盘股整体差异的影响;"
"「比同市值股票多涨几个点」是只和市值相近的股票比。"
"「跑赢全池的股票占比」和上面几列不是一回事:上面是收益差,这一列是只数比例。"
"全池自己这一行的占比只有四成多,因为少数大涨的股票把平均值拉高了;"
"所以读别的名单时要拿它和全池那一行相减,不能直接看绝对值。"
"「最多的一天占了多少」超过三成,说明整个读数被一天主导,那就只看逐日那张表。"
"「往后看几个交易日」不是持有天数——这个脚本不建仓、不计成本,不是回测。"
"不带前缀的列按计划日等权,一天算一票,这是主口径;"
"带「股票多的日子算得重」前缀的列是另一种算法,只用来和手工读数对账。", "",
_md(lists_tbl), "",
"## 二、分组读数", "", _md(groups_tbl), "",
"分组里的「定价状态」与「催化事件」两类是 2026-09-08 起加的:定价状态按最近一次券商正向事件日的"
"事件前涨幅、事件日跳空、收盘位置与量比归成四情形,催化事件是近 60 天有没有深度覆盖、上调盈利预测、"
"业绩超预期。两者都只展示不进判决,这两组读数是将来决定要不要当门槛的依据。", "",
_pricing_spread_md(groups_tbl), "",
f"## 二之二、候选单逐日(期限 {h0} 日;第一节按日等权的读数就是这张表的平均,看集中度)", "",
_md(daily_c), "",
"## 三、按事后环境分组(未来 h 日全池涨跌,只作解释,不作交易前置)", "",
_md(regime_tbl), ""]
if not pre_tbl.empty:
md += ["## 四、按事前线上标签分组(快照 regime 段,上线后才有)", "",
_md(pre_tbl), ""]
else:
md += ["## 四、按事前线上标签分组", "", "(区间内没有带环境标签的快照,本节待环境标签上线后出现。)", ""]
md += [f"可核验晨版覆盖:{covered}/{len(days_plan)};缺档与旧名册不计入真实效果。", "",
f"逐版本及消费对账:{os.path.basename(trace_path)};有效记录 "
f"{sum(bool(r.get('verified')) for r in traces)}/{len(traces)}。"
"日频交付名单采用当日最后一条实际消费,全部消费与修订另列,不混成独立交易日。", "",
"## 五、逐日注记", ""] + [f"- {n}" for n in notes] + ["",
"## 六、待决定事项", "", "(只列读数与选项,不改任何东西——由每周五人工填写。)", ""]
md += ["## 七、三套对照(选股系统、择时决策系统、PMS 账本各自的读数摆在一张表里,只对照不合并)", "",
_md(compare_table(lists_tbl, since, until)), ""]
md += ["## 八、台账对表(一致 / 不一致两列由人填;对表依据是方案第 4.1 节一致性检查表)", "",
_md(ledger_table()), ""]
md_path = os.path.join(out_dir, f"复盘_{stamp}_{start}.md")
with open(md_path, "w", encoding="utf-8") as f:
f.write("\n".join(md))
print("\n".join(md[:8]))
print(f"\n已写入 {md_path} 与 {csv_path}")
return {"md": md_path, "csv": csv_path, "days": len(days_plan)}
def _list_reading(lists_tbl: pd.DataFrame, name: str) -> str:
"""第一节汇总表里一份名单各期限的按日等权读数,拼成一句;没有样本写明。"""
if lists_tbl is None or lists_tbl.empty or "list" not in lists_tbl.columns:
return "无样本(区间内该名单没有可算的期限:名单为空、读失败或数据尾部不足)"
sub = lists_tbl[lists_tbl["list"] == name].sort_values("h")
if sub.empty:
return "无样本(区间内该名单没有可算的期限:名单为空、读失败或数据尾部不足)"
parts = []
for _, r in sub.iterrows():
parts.append(f"{int(r['h'])} 日:计划日 {int(r['days'])},样本 {int(r['n'])},"
f"比全池多涨 {r['excess_all']:+.2f} 个点,跑赢全池的占 {r['beat']:.1f}%,样本{r['grade']}")
return ";".join(parts)
def compare_table(lists_tbl: pd.DataFrame, since: str, until: str | None) -> pd.DataFrame:
"""第七节"三套对照":选股系统候选单按日等权读数;择时决策系统自评口径与本期方向命中率;
量价研判链两个头(五日头、二十日头)各自的方向命中率;PMS 账本四份名单读数。
三套口径不同,只并列不合并。两个头随量价研判链上线,二十日头头几周可能还没判分记录。"""
rows = [
{"系统": "选股系统", "口径": "候选单按计划日等权,相对全池等权超额与跑赢比例(第一节主口径)",
"读数": _list_reading(lists_tbl, "候选单")},
{"系统": "择时决策系统",
"口径": "择时决策系统自己打的分。每个交易日收盘后给出的策略,看 5 个交易日后涨跌"
"方向判断对不对,统计判对的比例。只看股票自己的涨跌,没有减去大盘涨跌,"
"与上一行候选单的超额口径不同,两个数字不能直接比大小。",
"读数": timing_self_eval(since, until)},
{"系统": "择时决策系统·五日头",
"口径": "量价研判链的五日头(判分种类 pv_h5、期限 5 个交易日)自己打的分的方向命中率,口径同上一行。",
"读数": timing_head_eval(since, until, ref_type="pv_h5", horizon=5)},
{"系统": "择时决策系统·二十日头",
"口径": "量价研判链的二十日头(判分种类 pv_h20、期限 20 个交易日)的方向命中率。"
"头几周二十日头可能还没产生判分,那时读数是「本期无判分记录」,属正常。",
"读数": timing_head_eval(since, until, ref_type="pv_h20", horizon=20)},
{"系统": "PMS 账本",
"口径": "这一行是 PMS 当天的新开仓审批记录,拆成三份名单:系统自动放行的、"
"人工同意的、人工否决的。否决的也照样算收益,用来看当初拒得对不对。"
"另外单列一份择时决策系统当天看多的股票。这四份名单的买入时点、"
"往后看几天、跟谁比,都和候选单完全一样,可以直接跟候选单那一行对着看。",
"读数": ";".join(f"{name}—{_list_reading(lists_tbl, name)}"
for name in (*LEDGER_LISTS, TIMING_LIST))},
]
return pd.DataFrame(rows)
def ledger_table() -> pd.DataFrame:
"""第八节"台账对表":台账条目编号、日期、标题,加"一致""不一致"两列空着给人填。"""
entries = decision_ledger_entries()
if not entries:
return pd.DataFrame([{"编号": "—", "日期": "—", "标题": f"台账文件缺失或无条目({DECISION_LEDGER_PATH})",
"一致": "", "不一致": ""}])
return pd.DataFrame([{"编号": e["no"], "日期": e["date"], "标题": e["title"], "一致": "", "不一致": ""}
for e in entries])
def weekly_window(today=None, *, tail_days: int = 7, span_days: int = 21) -> tuple[str, str]:
"""每周五固定动作的复盘窗口(2026-09-07 方案第五件之三)。
截止日取 7 个自然日前,让最短的 5 日期限对窗口尾部的计划日也算得出收益;
起点再往前 21 个自然日,约十五个计划日。返回 ISO 日期字符串 (since, until)。"""
import datetime as dt
today = today or dt.date.today()
until = today - dt.timedelta(days=tail_days)
since = until - dt.timedelta(days=span_days)
return since.isoformat(), until.isoformat()
def main() -> int:
ap = argparse.ArgumentParser(description="候选单复盘(只读,名单级观察收益,不是回测)")
ap.add_argument("--since", default="2026-07-29")
ap.add_argument("--until")
ap.add_argument("--horizons", default="5,10,20")
ap.add_argument("--start-price", choices=["next_close", "signal_close"], default="next_close",
help="next_close=次日收盘起算(默认,实盘口径);signal_close=信号日收盘起算(对账方案 1.8 系列)")
ap.add_argument("--out", default="data/review")
ap.add_argument("--weekly", action="store_true",
help="按每周五固定动作的滚动窗口跑(截止 7 天前、往前 21 天),忽略 --since/--until")
a = ap.parse_args()
hs = tuple(int(x) for x in a.horizons.split(",") if x.strip())
since, until = (weekly_window() if a.weekly else (a.since, a.until))
run(since, until, hs, a.start_price, a.out)
return 0
if __name__ == "__main__":
raise SystemExit(main())