量化交易 on 远思码技术实验室

每日选股信号的自动化：systemd timer + 企业微信推送

Sun, 25 Oct 2026 07:30:00 +0800

远思为径，码动价值。欢迎来到远思码技术实验室的最新技术实践记录。

研究做得再漂亮，如果每天还要手动开 Jupyter 跑一遍 notebook，那它就永远只是个练习。这一篇把前面六篇串成一条无人值守的流水线：每个交易日盘后自动取数、算因子、生成信号，并把结果推到手机上。

一、整条链路

┌─────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌─────────┐
│ 取行情 │ → │ 算因子 │ → │ 模型打分 │ → │ 组合构建 │ → │ 推送+落库│
└─────────┘ └──────────┘ └──────────┘ └──────────┘ └─────────┘
 失败 → 重试 3 次 → 仍失败则告警 → 记录死信

设计原则只有三条：

幂等：同一天重跑一百次，结果一样，不会重复推送；
可见：每次运行都有日志、有退出码、有心跳；
可停：任何一个环节失败都不会污染已有信号。

二、先判断是不是交易日

节假日不跑，是这条流水线最重要的一条规则。systemd 的 OnCalendar 只认星期几，不认 A 股节假日，所以判断必须写在程序里。

# quant/calendar.py
from __future__ import annotations

import datetime as dt

import akshare as ak
import pandas as pd

_cache: pd.DataFrame | None = None


def trade_dates() -> list[dt.date]:
 """A 股历史交易日序列（含未来已公布日期）。首次调用约 1 秒，之后走缓存。"""
 global _cache
 if _cache is None:
 df = ak.tool_trade_date_hist_sina() # 列: trade_date
 _cache = pd.to_datetime(df["trade_date"]).dt.date
 return list(_cache)


def is_trading_day(day: dt.date | None = None) -> bool:
 day = day or dt.date.today()
 return day in trade_dates()


def last_trading_day(day: dt.date | None = None) -> dt.date:
 """最近一个 <= day 的交易日（用于补跑）。"""
 day = day or dt.date.today()
 dates = [d for d in trade_dates() if d <= day]
 if not dates:
 raise RuntimeError(f"{day} 之前没有交易日数据，检查交易日历缓存")
 return dates[-1]

为什么不干脆只在 OnCalendar=Mon..Fri 上跑？因为调休。2026 年的春节、国庆前后都有"周六上班"的交易日，只在周一到周五跑会漏；反过来节假日又白跑。让程序判断交易日、让 timer 每天都触发一次，是最省心的组合。

三、主流程：一次运行做五件事

# quant/pipeline.py
from __future__ import annotations

import datetime as dt
import logging
import sys

import pandas as pd

from quant.calendar import is_trading_day, last_trading_day
from quant.config import CFG
from quant.db import save_signals
from quant.features import build_features
from quant.model import load_model, score_panel
from quant.notify import push_wecom
from quant.portfolio import build_portfolio

log = logging.getLogger("quant.pipeline")


def run_once(force: bool = False, day: dt.date | None = None) -> int:
 """返回进程退出码：0 成功/跳过，1 失败。"""
 day = day or last_trading_day()
 if not force and not is_trading_day(day):
 log.info("非交易日 %s，跳过", day)
 return 0

 # 1) 取数（失败直接抛，由 systemd 的重试策略兜底）
 close, volume, pct, factor_panel = build_features(day)
 log.info("取数完成：%d 只标的，%d 个因子", close.shape[1], factor_panel.shape[1])

 # 2) 模型打分
 model = load_model(CFG.model_path)
 scores = score_panel(model, factor_panel)

 # 3) 组合构建：top 20 等权，行业偏离 <= 3%
 weights = build_portfolio(scores, factor_panel["industry"], top_n=CFG.top_n)
 log.info("组合构建完成：%d 只标的，合计权重 %.2f", (weights > 0).sum(), weights.sum())

 # 4) 落库（唯一约束保证幂等）
 n = save_signals(day, weights, scores)
 log.info("信号已入库 %d 条", n)

 # 5) 推送
 push_wecom(day, weights, scores)
 log.info("推送完成")
 return 0

if __name__ == "__main__" 的入口保持极薄，方便用 python -m quant.pipeline --force 手动补跑：

# quant/__main__.py
import argparse
import datetime as dt
import logging
import sys

from quant.pipeline import run_once

logging.basicConfig(
 level=logging.INFO,
 format="%(asctime)s %(levelname)s %(name)s - %(message)s",
)

parser = argparse.ArgumentParser()
parser.add_argument("--day", type=dt.date.fromisoformat, default=None)
parser.add_argument("--force", action="store_true", help="忽略交易日判断，强制运行")
args = parser.parse_args()
sys.exit(run_once(force=args.force, day=args.day))

四、幂等落库

信号表的唯一约束是幂等的全部保证：

CREATE TABLE IF NOT EXISTS daily_signal (
 trade_date date NOT NULL,
 symbol text NOT NULL,
 score double precision NOT NULL,
 weight double precision NOT NULL,
 model_ver text NOT NULL,
 created_at timestamptz NOT NULL DEFAULT now(),
 PRIMARY KEY (trade_date, symbol)
);

# quant/db.py
from __future__ import annotations

import datetime as dt

import pandas as pd
from sqlalchemy import create_engine, text

from quant.config import CFG

engine = create_engine(CFG.dsn, pool_pre_ping=True, pool_size=2)

UPSERT = text("""
 INSERT INTO daily_signal (trade_date, symbol, score, weight, model_ver)
 VALUES (:trade_date, :symbol, :score, :weight, :model_ver)
 ON CONFLICT (trade_date, symbol) DO UPDATE
 SET score = EXCLUDED.score,
 weight = EXCLUDED.weight,
 model_ver = EXCLUDED.model_ver
""")


def save_signals(day: dt.date, weights: pd.Series, scores: pd.Series) -> int:
 rows = [
 {"trade_date": day, "symbol": sym, "score": float(scores[sym]),
 "weight": float(w), "model_ver": CFG.model_version}
 for sym, w in weights.items() if w > 0
 ]
 if not rows:
 return 0
 with engine.begin() as conn:
 conn.execute(UPSERT, rows)
 return len(rows)

推送也需要幂等——同一天重复推送会把手机刷屏。用一个简单的 push_log 表打标记：

def already_pushed(day: dt.date, channel: str) -> bool:
 with engine.connect() as conn:
 hit = conn.execute(text(
 "SELECT 1 FROM push_log WHERE trade_date = :d AND channel = :c"
 ), {"d": day, "c": channel}).first()
 return hit is not None

五、推送：企业微信机器人

企业微信群机器人的 webhook 是最省事的通道——不需要申请公众号、不需要服务器回调，一条 HTTP POST 就到手机。

# quant/notify.py
from __future__ import annotations

import datetime as dt
import logging
import time

import requests

from quant.config import CFG
from quant.db import already_pushed, mark_pushed

log = logging.getLogger("quant.notify")


def _fmt_message(day: dt.date, weights, scores) -> str:
 top = weights[weights > 0].sort_values(ascending=False).head(10)
 lines = [f"### 📈 量化信号 {day.isoformat()}",
 f"> 模型版本 `{CFG.model_version}`，持仓 {int((weights > 0).sum())} 只，"
 f"总仓位 {weights.sum():.0%}",
 ""]
 for sym, w in top.items():
 lines.append(f"- `{sym}` 权重 {w:.1%}，得分 {scores[sym]:+.3f}")
 lines.append("")
 lines.append("<font color=\"comment\">本消息由远思码实验室自动生成，不构成投资建议。</font>")
 return "\n".join(lines)


def push_wecom(day: dt.date, weights, scores, retries: int = 3) -> None:
 if CFG.dry_run:
 log.warning("DRY_RUN 开启，跳过推送")
 return
 if already_pushed(day, "wecom"):
 log.info("%s 已推送过，跳过", day)
 return

 payload = {"msgtype": "markdown",
 "markdown": {"content": _fmt_message(day, weights, scores)}}
 last_err: Exception | None = None
 for attempt in range(1, retries + 1):
 try:
 resp = requests.post(CFG.wecom_webhook, json=payload, timeout=5)
 data = resp.json()
 # 企业微信的成功码是 0；频率限制是 45009
 if data.get("errcode") == 0:
 mark_pushed(day, "wecom")
 return
 raise RuntimeError(f"企业微信返回 {data}")
 except Exception as exc: # noqa: BLE001
 last_err = exc
 wait = 2 ** attempt
 log.warning("推送失败（第 %d 次）：%s，%ds 后重试", attempt, exc, wait)
 time.sleep(wait)
 raise RuntimeError(f"推送最终失败：{last_err}")


def push_alert(msg: str) -> None:
 """告警用：单次尝试、不重试、失败只写日志（告警本身不该再触发告警）。"""
 if CFG.dry_run:
 log.warning("DRY_RUN 开启，告警内容：%s", msg)
 return
 try:
 requests.post(CFG.wecom_webhook,
 json={"msgtype": "text", "text": {"content": msg}},
 timeout=5)
 except Exception as exc: # noqa: BLE001
 log.error("告警推送失败：%s", exc)

webhook 里有 key，不要写进代码库。用 EnvironmentFile 注入，权限 600。

六、systemd：为什么不用 crontab

以前写过 crontab 的用法，但这条流水线更适合 systemd，理由很具体：

需求	cron	systemd timer
依赖别的服务（数据库、网络）	手写 `sleep 30`	`After=network-online.target postgresql.service`
失败重试	自己写包装脚本	`Restart=on-failure` + `RestartSec`
日志	重定向到文件，自己轮转	`journalctl -u` 现成，带结构化输出
立即手动触发	找到那行注释掉再跑	`systemctl start quant-signal.service`
错过补跑（机器重启）	不会补	`Persistent=true`
随机延迟（避免整点打爆 API）	不支持	`RandomizedDelaySec=`
资源限制	无	`MemoryMax` / `CPUQuota`

# /etc/systemd/system/quant-signal.service
[Unit]
Description=Daily quant signal pipeline
Wants=network-online.target
After=network-online.target postgresql.service
# 失败时最多跑 3 次
StartLimitIntervalSec=3600
StartLimitBurst=3

[Service]
Type=oneshot
User=siyuan
Group=siyuan
WorkingDirectory=/home/siyuan/code/python/quant
EnvironmentFile=/etc/quant/quant.env
ExecStart=/home/siyuan/miniconda3/envs/quant/bin/python -m quant
# 超时保护：超过 30 分钟说明卡住了
TimeoutStartSec=1800
Restart=on-failure
RestartSec=120
# 资源兜底，避免把研究机拖死
MemoryMax=6G
CPUQuota=300%
# 最小权限
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=read-only
ReadWritePaths=/home/siyuan/code/python/quant/logs
StandardOutput=journal
StandardError=journal
SyslogIdentifier=quant-signal

[Install]
WantedBy=multi-user.target

# /etc/systemd/system/quant-signal.timer
[Unit]
Description=Run quant signal pipeline after market close

[Timer]
# 17:30 触发；A 股 15:00 收盘，盘后数据源一般 16:30 之前更新完毕
OnCalendar=Mon..Fri 17:30:00
# 机器关机期间错过的任务，开机后补跑
Persistent=true
# 随机延迟 0~10 分钟，避免每天同一秒打爆 akshare 接口
RandomizedDelaySec=600
Unit=quant-signal.service

[Install]
WantedBy=timers.target

安装与验证：

sudo systemctl daemon-reload
sudo systemctl enable --now quant-signal.timer

# 看下次触发时间
systemctl list-timers quant-signal.timer

# 立即手动跑一次（验证用）
sudo systemctl start quant-signal.service
journalctl -u quant-signal.service -n 50 --no-pager

# 查看历史所有执行
journalctl -u quant-signal.service --since "7 days ago" | grep -E "完成|失败|跳过"

EnvironmentFile 内容（权限 600，属主 root）：

# /etc/quant/quant.env
QUANT_DSN=postgresql+psycopg2://quant:***@127.0.0.1:5432/quant
WECOM_WEBHOOK=https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=***
MODEL_VERSION=lgb-20261020
DRY_RUN=0

七、心跳与告警：让沉默也能被发现

最危险的故障不是报错，而是什么都没发生。程序悄悄没跑，而你以为它在跑。实验室用一个心跳表解决：

# quant/heartbeat.py
import datetime as dt

from sqlalchemy import text

from quant.db import engine


def beat(name: str, ok: bool, msg: str = "") -> None:
 with engine.begin() as conn:
 conn.execute(text("""
 INSERT INTO heartbeat (task, last_run_at, ok, msg)
 VALUES (:t, now(), :ok, :msg)
 ON CONFLICT (task) DO UPDATE
 SET last_run_at = now(), ok = EXCLUDED.ok, msg = EXCLUDED.msg
 """), {"t": name, "ok": ok, "msg": msg[:500]})

再挂一个每天中午的看门狗 timer：如果 quant-signal 最近一次心跳早于上一个交易日 18:00，就推一条告警。

# quant/watchdog.py
import datetime as dt

from sqlalchemy import text

from quant.calendar import last_trading_day
from quant.db import engine
from quant.notify import push_alert

def check() -> int:
 with engine.connect() as conn:
 row = conn.execute(text(
 "SELECT last_run_at, ok FROM heartbeat WHERE task = 'quant-signal'"
 )).first()
 today = dt.date.today()
 expect_after = dt.datetime.combine(last_trading_day(today), dt.time(18, 0))
 if row is None or row.last_run_at < expect_after:
 push_alert(f"⚠️ 量化信号未在 {expect_after} 前完成，请检查 journalctl -u quant-signal")
 return 1
 if not row.ok:
 push_alert("⚠️ 上次量化信号执行失败，详见日志")
 return 1
 return 0

八、踩过的坑

OnCalendar 的时间是本地时区，但容器里常常是 UTC。如果哪天把服务塞进容器，17:30 会变成凌晨 1:30。
WorkingDirectory 必须显式设置，否则 Type=oneshot 的工作目录是 /，相对路径的配置、模型文件全部找不到。
ProtectHome=read-only 与 conda 环境：conda 在某些操作下要写 ~/.cache，如果策略要写缓存目录，得把 ReadWritePaths 加上。
akshare 接口偶尔 503。重试要带指数退避，而且要区分"接口挂了"和"今天本来没数据"——前者该重试，后者重试只会放大问题。
推送成功 ≠ 你看到了。机器人被移出群、被限流（每分钟 20 条）都会静默失败，所以 push_log 与心跳两者都要有。
别在 ExecStart 里用 shell 管道。ExecStart 不经过 shell，>>、&& 都不会生效；需要 shell 就写包装脚本。

结语

这条链路跑通之后，整个量化研究才算真正闭环：研究 → 回测 → 上线 → 反馈。每天早上八点看手机上那几条消息，比看任何回测曲线都更能暴露问题——真实的价格、真实的公告、真实的滑点，会立刻告诉你模型对不对。

六篇量化系列的导航：

远思为径，码动价值。让它每天自己跑起来，是量化从"研究"变成"系统"的最后一步。

TFT 与 ST-GNN：深度时序模型在 A 股选股中的真实收益边界

Fri, 23 Oct 2026 21:10:00 +0800

远思为径，码动价值。欢迎来到远思码技术实验室的最新技术实践记录。

LightGBM 那篇的结论是：多个弱因子合成后 RankIC 0.042。想要再往上，直觉上有两条路——捕捉时序结构（今天的形态和 20 天前有关）与捕捉截面结构（同行业的股票会互相传染）。

这两条正好对应 TFT 与 ST-GNN。这篇记录实验室在这两个模型上的实测，包括一个不太讨喜的结论：它们在 IC 上没有赢过 GBDT，只在组合稳定性上略有优势，而推理成本高一个数量级。

一、为什么深度模型在这类任务上不占优势

先说清楚约束条件，否则容易陷入"模型越大越好"的误区：

样本量陷阱：A 股每天约 5000 只股票 × 250 天 ≈ 125 万样本/年，听起来很多，但有效独立样本远小于此——同一天的股票高度相关，同一只股票的相邻日高度相关。
信噪比极低：日频截面收益的可预测部分只有万分之几，深度模型的参数量动辄百万级。
信号衰减快：因子有效期 5~20 个交易日，模型学到的模式可能在下个季度就失效。

因此深度模型在 A 股的正确姿势不是"替代 GBDT"，而是"提供 GBDT 看不到的那部分信息"：时序上的形态演变、行业间的溢出。

二、数据张量化：从面板到 (样本, 时间步, 特征)

TFT 需要三维输入。构造滑动窗口时要格外小心——窗口内不能混入标签期之后的数据。

# ml/deep/dataset.py
from __future__ import annotations

import numpy as np
import pandas as pd
import torch
from torch.utils.data import Dataset

FEATURES = ["mom_5", "mom_20", "mom_60", "rev_5", "vol_20", "turn_20", "amihud"]


class WindowDataset(Dataset):
 """把面板数据切成 (lookback, n_features) 的时间窗，预测未来 horizon 日截面排名。

 关键约定：window 截止于 t 日（含），标签是 t+1..t+horizon 的收益。
 """

 def __init__(self, panel: pd.DataFrame, close: pd.DataFrame,
 lookback: int = 60, horizon: int = 5, min_hist: int = 250):
 self.lookback = lookback
 self.horizon = horizon
 # panel: 多级索引 (trade_date, symbol)，列为特征
 self.dates = sorted(panel.index.get_level_values(0).unique())
 self.panel = panel
 self.close = close

 xs, ys, ds = [], [], []
 for i, date in enumerate(self.dates):
 if i < min_hist or i + horizon >= len(self.dates):
 continue
 window = self.dates[i - lookback + 1: i + 1]
 block = panel.loc[window] # (lookback * n_symbols, n_feat)
 symbols = block.index.get_level_values(1).unique()
 arr = np.stack([
 block.xs(d, level=0).reindex(symbols)[FEATURES].to_numpy()
 for d in window
 ]) # (lookback, n_symbols, n_feat)
 arr = np.nan_to_num(arr, nan=0.0)
 xs.append(torch.tensor(arr.transpose(1, 0, 2), dtype=torch.float32)) # (n_symbols, lookback, n_feat)
 ds.append(date)

 c = close.loc[date, symbols]
 c_end = close.loc[self.dates[i + horizon], symbols]
 ret = (c_end / c - 1).rank(pct=True) * 2 - 1 # 截面排名标签
 ys.append(torch.tensor(ret.to_numpy(), dtype=torch.float32))

 self.x = xs
 self.y = ys
 self.date_index = ds

 def __len__(self) -> int:
 return len(self.x)

 def __getitem__(self, idx: int):
 return self.x[idx], self.y[idx]

内存是第一个坎：n_symbols × lookback × n_features 的 float32 张量，5000 × 60 × 7 ≈ 8.4 MB/天。1200 天就是 10 GB。所以在 48GB UMA 的机器上，实验室的折衷是 lookback=60、特征 7 个、只取沪深 300 + 中证 500 成分股（约 800 只），单天 1.3 MB，全量 1.5 GB，正好塞进内存。

三、TFT：可解释性才是它的卖点

pytorch-forecasting 的 TFT 把"变量选择网络（VSN）+ 多头注意力"包好了，我们只需要喂 TimeSeriesDataSet：

# ml/deep/tft_model.py
from __future__ import annotations

import lightning.pytorch as pl
from pytorch_forecasting import TemporalFusionTransformer, TimeSeriesDataSet
from pytorch_forecasting.metrics import QuantileLoss

CONFIG = dict(
 max_encoder_length=60,
 max_prediction_length=5, # 预测未来 5 日
 hidden_size=64,
 attention_head_size=4,
 dropout=0.2,
 hidden_continuous_size=32,
 learning_rate=1e-3,
 batch_size=256,
 max_epochs=30,
)


def build_dataset(df, predict: bool = False, training: TimeSeriesDataSet | None = None) -> TimeSeriesDataSet:
 return TimeSeriesDataSet(
 df,
 time_idx="time_idx",
 target="label",
 group_ids=["symbol"],
 max_encoder_length=CONFIG["max_encoder_length"],
 max_prediction_length=CONFIG["max_prediction_length"],
 time_varying_known_reals=["time_idx"], # 交易日序号，未来可知
 time_varying_unknown_reals=["mom_5", "mom_20", "mom_60",
 "rev_5", "vol_20", "turn_20", "amihud"],
 static_categoricals=["industry"],
 predict_mode=predict,
 training=training,
 allow_missing_timesteps=True,
 add_relative_time_idx=True,
 )


def build_trainer(gpus: int = 1) -> pl.Trainer:
 return pl.Trainer(
 max_epochs=CONFIG["max_epochs"],
 accelerator="gpu" if gpus else "cpu",
 precision="bf16-mixed", # ROCm 上 bf16 比 fp16 稳定
 gradient_clip_val=0.5,
 enable_checkpointing=False,
 logger=False,
 enable_progress_bar=True,
 )


def build_model(training_ds: TimeSeriesDataSet) -> TemporalFusionTransformer:
 return TemporalFusionTransformer.from_dataset(
 training_ds,
 learning_rate=CONFIG["learning_rate"],
 hidden_size=CONFIG["hidden_size"],
 attention_head_size=CONFIG["attention_head_size"],
 dropout=CONFIG["dropout"],
 hidden_continuous_size=CONFIG["hidden_continuous_size"],
 output_size=7, # 7 个分位数（默认 QuantileLoss）
 loss=QuantileLoss(),
 reduce_on_plateau_patience=4,
 )

TFT 真正的价值不在精度，而在可解释性输出：

def interpretation(model, trainer, dataloader) -> dict:
 raw = model.predict(dataloader, mode="raw", return_x=True, trainer=trainer)
 return model.interpret_output(raw.output, reduction="sum") # attention / 变量权重

interpretation 会给你三样东西：每个历史时间步的注意力权重（模型在关注 5 天前还是 40 天前）、每个变量的重要度（动量还是换手在起作用）、持续性权重（历史形态对未来预测的持续影响）。这三样东西能反过来修正因子设计，比 IC 高 0.005 有用得多。

四、ST-GNN：把行业关系建成图

截面信息传播的想法很自然：某只股票异动，同行业/上下游的股票往往跟随。用图神经网络表达就是：特征矩阵 + 邻接矩阵 → 消息传递 → 更新的特征。

# ml/deep/stgnn.py
from __future__ import annotations

import torch
import torch.nn.functional as F
from torch import nn
from torch_geometric.nn import GCNConv


def build_industry_adjacency(industry: torch.Tensor, n_keep: int = 4) -> torch.Tensor:
 """同一行业的股票两两连边，并做行归一化。industry: (n_symbols,) 的整数标签。"""
 n = industry.size(0)
 same = industry.unsqueeze(0) == industry.unsqueeze(1)
 adj = same.float()
 adj.fill_diagonal_(1.0)
 # 行业过大时每行只保留相似度最高的 n_keep 个（防止金融板块把噪声全拉进来）
 if n_keep:
 topv, topi = adj.topk(min(n_keep + 1, n), dim=1)
 keep = torch.zeros_like(adj)
 keep.scatter_(1, topi, 1.0)
 adj = adj * keep
 return adj / adj.sum(dim=1, keepdim=True).clamp_min(1e-9)


class STGNNBlock(nn.Module):
 """空间（GCN 传递截面信息）+ 时间（GRU 聚合时序）的交替堆叠。"""

 def __init__(self, n_feat: int, hidden: int = 32, edge_index: torch.Tensor | None = None):
 super().__init__()
 self.gcn = GCNConv(n_feat, hidden)
 self.gru = nn.GRU(hidden, hidden, batch_first=True, num_layers=1)
 self.head = nn.Linear(hidden, 1)
 self.edge_index = edge_index

 def forward(self, x: torch.Tensor) -> torch.Tensor:
 """x: (n_symbols, lookback, n_feat) -> (n_symbols,) 预测分数。"""
 n, t, f = x.shape
 feats = x.reshape(n * t, f)
 # 空间聚合：每行构造 block-diagonal 的边索引
 if self.edge_index is None:
 raise ValueError("edge_index 未设置")
 src, dst = self.edge_index
 ei = torch.cat([src + i * n for i in range(t)]).long(), torch.cat([dst + i * n for i in range(t)]).long()
 h = F.relu(self.gcn(feats, ei))
 h = h.view(n, t, -1)
 out, _ = self.gru(h)
 return self.head(out[:, -1, :]).squeeze(-1)

图怎么建，比模型怎么改更重要。实验室试过三种邻接：

图的构造	IC 均值	备注
不建图（GRU-only）	0.031	基线
同行业连边	0.036	稳定提升
行业 + 20 日收益相关性 top-3	0.038	提升但噪声变大
行业 + 供应链（供应商/客户）	0.033	数据稀疏，覆盖度不足

供应链图理论上最有价值，但 A 股的供应商客户关系披露覆盖率太低，最终 30% 的股票没有一条边。图的覆盖率决定了图模型的上限。

五、ROCm 上的训练细节

本地算力节点是 AMD Radeon 890M（gfx1150）+ 48GB UMA 内存，ROCm 7.2.3。要点：

# PyTorch 必须装 ROCm 构建版本
pip install torch torchvision --index-url https://download.pytorch.org/whl/rocm7.2
pip install pytorch-forecasting pytorch-lightning torch-geometric

# 核显架构白名单覆盖（890M -> gfx1150）
export HSA_OVERRIDE_GFX_VERSION=11.5.0
python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))"

precision="bf16-mixed" 是必需的。核显上 fp16 的 loss scaling 容易溢出，训练到第 10 个 epoch 左右突然 loss 变 NaN，我为此浪费了两天。
UMA 内存是把双刃剑：48GB 共享内存意味着 batch 可以开很大，但也意味着 CPU 内存吃紧时会直接 OOM。建议 export HSA_ENABLE_SDMA=0 减少内存拷贝抖动。
torch_geometric 的 scatter 操作在 ROCm 上比 CUDA 慢 20~30%，图很大时要控制每行邻居数。

实测训练时间（800 只股票 × 1200 天，lookback 60）：

模型	单 epoch	30 epoch	显存峰值
LightGBM（CPU）	—	约 40 秒	—
TFT（hidden 64）	95 秒	约 48 分钟	3.1 GB
ST-GNN（4 层）	60 秒	约 30 分钟	2.4 GB

六、结果：一个不性感的对照表

同一份特征、同一份样本、同一套 purged 时序切分，三个模型的表现：

模型	RankIC	ICIR	多空年化（未计成本）	多空最大回撤	推理耗时/天
LightGBM	0.042	0.31	16.4%	-12.7%	0.8 秒
TFT	0.038	0.29	17.9%	-9.4%	6.2 秒
ST-GNN	0.036	0.26	15.1%	-11.8%	4.5 秒

结论得诚实地说：

IC 上 GBDT 依然最好。深度模型没有"发现"新 alpha；
TFT 的多空组合回撤更小（-9.4% vs -12.7%），说明它学到的东西更"稳"，可能与时序注意力对趋势转折的敏感性有关；
深度模型的推理成本高 5~8 倍，对日频策略无所谓，但如果做分钟级就完全不可接受。

实验室最终的选择是：主策略用 LightGBM，TFT 的输出作为"风格因子"叠加——两者相关性只有 0.6 左右，合成的 IC 能达到 0.048，这是深度模型唯一真正值钱的地方：它与 GBDT 的误差不相关。

七、踩坑清单

窗口跨越停牌期：停牌 3 个月后复牌，窗口里 60 个交易日中有 40 个是 NaN，nan_to_num 填 0 会让模型以为"这只股票波动突然归零"。正确做法是给一个 is_suspended 掩码。
样本权重：不同日期的股票数量差异很大（2015 年牛市 vs 2018 年熊市），不加权会让模型偏向样本多的时期。实验室用 1 / 当日样本数 做权重。
随机种子敏感：深度模型的 IC 在不同种子下波动 ±0.006，报告结果必须给出多个种子的均值，否则就是在挑好看的种子。
predict_mode 与 training 参数：pytorch-forecasting 里构造验证集时必须传 training=training_dataset，否则特征缩放不一致，验证集 IC 会莫名其妙地低。
不要用全样本拟合归一化：GroupNormalizer 的 groups 参数决定了按什么分组归一化，用 symbol 会导致每只股票各自的尺度，跨股票不可比。

结语

写到这里，量化这条线上的核心环节都跑通了：数据 → 因子 → 回测 → 策略 → 机器学习 → 深度模型。

但研究做完不等于能跑。最后一篇回到工程：把这套流程变成每天早上 8 点自动生成信号并推送到手机的服务，用 systemd timer 而不是 crontab，因为失败重试、日志与依赖管理都要靠它。

远思为径，码动价值。深度模型不会给你 alpha，但它会给你更清楚的自我怀疑。

LightGBM 截面选股：把因子流水线变成预测模型

Wed, 21 Oct 2026 20:20:00 +0800

远思为径，码动价值。欢迎来到远思码技术实验室的最新技术实践记录。

上一篇文章的策略是"人工写规则"，参数换了就要重跑一遍。机器学习选股的思路不同：把多个因子交给模型，让它自己学加权方式。

听起来很美，但实验室第一次做的时候，IC 跑到了 0.15（这个数字在 A 股日频里强得不像真的），回测年化 60%。查了两天才发现——标签用到了未来 5 天的收盘价，而特征里的换手率是"未来 5 天平均换手"。这不是机器学习，这是拿着答案考试。

这篇把正确的流程完整走一遍，重点标出那些"看起来没问题、其实在泄露"的环节。

一、问题定义：截面回归，不是时间序列预测

先说清楚我们在预测什么：

对每个交易日 t，输入当期所有股票的因子截面，输出每只股票未来 5 个交易日收益的横截面排名。

为什么是排名而不是绝对收益？因为 A 股有系统性涨跌（beta），模型容易把"市场要涨"学成"所有股票都好"。去掉截面均值之后，模型只能学相对强弱，这也和最终"买前 N 只"的决策方式一致。

# ml/labels.py
import numpy as np
import pandas as pd


def forward_return(close: pd.DataFrame, horizon: int = 5) -> pd.DataFrame:
 """未来 horizon 日收益。注意：这里的时间箭头是指向未来的，永远只能用于标签。"""
 return close.shift(-horizon) / close - 1


def cross_section_rank(y: pd.DataFrame) -> pd.DataFrame:
 """截面排序归一化到 [-1, 1]，比 z-score 更抗极端值。"""
 return y.rank(axis=1, pct=True) * 2 - 1

二、特征：因子池 + 截面处理

特征直接复用因子工程里落库的 factor_value 表，再补几个：

组别	特征	说明
动量	`mom_5 / mom_20 / mom_60 / mom_120`	多尺度动量
反转	`rev_5 / rev_20`	短期反转
波动	`vol_20 / vol_60 / max_dd_60`	风险特征
流动性	`turn_20 / amount_20 / amihud`	换手与冲击成本代理
估值	`pe_ttm / pb / ps_ttm`	财务因子（低频，按季更新）
行业	`industry`	类别特征，LightGBM 原生支持

关键纪律：所有特征都必须在截面上做稳健标准化，并且标准化只用当日截面信息（不用全样本均值），这样在任何时点重算都一致。

# ml/features.py
from __future__ import annotations

import numpy as np
import pandas as pd


def load_factor_panel(factor_names: list[str], start: str, end: str) -> pd.DataFrame:
 """从 factor_value 取宽表并堆成 (trade_date, symbol) 长表。"""
 from sqlalchemy import create_engine

 engine = create_engine("postgresql+psycopg2://quant:quant@127.0.0.1:5432/quant")
 sql = """
 SELECT trade_date, symbol, factor_name, z
 FROM factor_value
 WHERE factor_name = ANY(%(names)s)
 AND trade_date BETWEEN %(start)s AND %(end)s
 """
 df = pd.read_sql(sql, engine, params={"names": factor_names, "start": start, "end": end})
 return df.pivot_table(index=["trade_date", "symbol"], columns="factor_name", values="z")


def add_industry_and_label(panel: pd.DataFrame, close: pd.DataFrame,
 industry: pd.DataFrame, horizon: int = 5) -> pd.DataFrame:
 """拼上行业标签与截面排序标签，并丢弃最后 horizon 天（没有未来收益）。"""
 y = cross_section_rank(forward_return(close, horizon))
 long = y.stack().rename("label").reset_index()
 long.columns = ["trade_date", "symbol", "label"]

 ind = industry.stack().rename("industry").reset_index()
 ind.columns = ["trade_date", "symbol", "industry"]

 out = panel.reset_index().merge(long, on=["trade_date", "symbol"], how="inner")
 out = out.merge(ind, on=["trade_date", "symbol"], how="left")
 # 行业标签在每个截面内部统一成 category，未知记为 "UNKNOWN"
 out["industry"] = out["industry"].fillna("UNKNOWN").astype("category")
 return out.dropna(subset=["label"])

三、时序切分：purged 与 embargo

这是整篇文章最重要的部分。机器学习课教你 K-Fold 随机切分，在量化里这是灾难：

标签是未来 5 日收益，t 日的样本和 t+3 日的样本标签区间重叠 → 训练集和验证集"共享答案"；
相邻交易日的特征高度自相关 → 模型只要记住"这几天"，就能在验证集上蒙对。

实验室用的是按时间切分的 purged walk-forward + embargo：

# ml/split.py
from __future__ import annotations

import pandas as pd


def purged_time_split(dates: pd.Series, n_splits: int = 5, embargo: int = 5) -> list[tuple]:
 """按时间切成 n_splits 段，训练集与验证集之间留 embargo 天缓冲。

 返回 [(train_mask, valid_mask), ...]，mask 是与 dates 同长度的布尔数组。
 """
 uniq = sorted(dates.unique())
 fold = len(uniq) // (n_splits + 1)
 idx = pd.Series(range(len(uniq)), index=uniq)
 splits = []
 for k in range(1, n_splits + 1):
 train_end = k * fold
 valid_start = train_end + embargo
 valid_end = valid_start + fold
 if valid_end > len(uniq):
 break
 train_days = set(uniq[:train_end])
 valid_days = set(uniq[valid_start:valid_end])
 splits.append((dates.isin(train_days), dates.isin(valid_days)))
 return splits

embargo=5 的含义：训练集最后 5 天的样本，其标签区间与验证集第一天重叠，必须整体切除。少了这一步，验证集 IC 能凭空高 30%。

四、训练：LightGBM

# ml/train.py
from __future__ import annotations

import lightgbm as lgb
import numpy as np
import pandas as pd

FEATURES = ["mom_5", "mom_20", "mom_60", "mom_120", "rev_5", "rev_20",
 "vol_20", "vol_60", "max_dd_60", "turn_20", "amount_20", "amihud"]

PARAMS = dict(
 objective="regression_l2",
 metric="l2",
 learning_rate=0.03,
 num_leaves=15, # 别太大，截面样本噪声很重
 min_data_in_leaf=200,
 feature_fraction=0.75,
 bagging_fraction=0.8,
 bagging_freq=1,
 lambda_l2=5.0, # 强正则，防止记住某几天
 max_depth=5,
 verbosity=-1,
 seed=42,
 num_threads=8,
)


def train_model(df: pd.DataFrame, train_mask, valid_mask) -> lgb.Booster:
 X_tr = df.loc[train_mask, FEATURES + ["industry"]]
 y_tr = df.loc[train_mask, "label"].to_numpy()
 X_va = df.loc[valid_mask, FEATURES + ["industry"]]
 y_va = df.loc[valid_mask, "label"].to_numpy()

 dtrain = lgb.Dataset(X_tr, label=y_tr, categorical_feature=["industry"], free_raw_data=False)
 dvalid = lgb.Dataset(X_va, label=y_va, categorical_feature=["industry"], reference=dtrain)

 booster = lgb.train(
 PARAMS,
 dtrain,
 num_boost_round=2000,
 valid_sets=[dtrain, dvalid],
 valid_names=["train", "valid"],
 callbacks=[lgb.early_stopping(100, verbose=False), lgb.log_evaluation(0)],
 )
 return booster

几个参数选择的理由，比参数本身更值得记：

num_leaves=15 + max_depth=5 + lambda_l2=5：截面数据的信噪比极低（IC 0.03 就算不错），复杂模型几乎必然过拟合到某几段行情；
min_data_in_leaf=200：一天全市场几千只股票，叶子太小就等于记住个股；
early_stopping 只看验证集，测试集从头到尾不参与训练决策。

五、评价：不看 R²，只看 IC 与分层

回归任务的 R² 在这里毫无意义（0.01 也算"显著"）。真正的评价指标还是那三个：

# ml/evaluate.py
import numpy as np
import pandas as pd
from scipy.stats import spearmanr


def predict_panel(booster, df: pd.DataFrame) -> pd.Series:
 pred = booster.predict(df[FEATURES + ["industry"]])
 return pd.Series(pred, index=df.index)


def ic_by_date(df: pd.DataFrame, pred: pd.Series, label_col: str = "label") -> pd.Series:
 tmp = df.assign(pred=pred)
 ic = tmp.groupby("trade_date").apply(
 lambda g: spearmanr(g["pred"], g[label_col]).statistic
 if len(g) >= 50 else np.nan,
 include_groups=False,
 )
 return ic.dropna()


def ic_stats(ic: pd.Series) -> dict:
 return {
 "IC均值": round(float(ic.mean()), 4),
 "ICIR": round(float(ic.mean() / ic.std(ddof=1)), 3),
 "IC>0占比": round(float((ic > 0).mean()), 3),
 "IC衰减(后20%)": round(float(ic.iloc[-len(ic) // 5:].mean()), 4),
 }


def long_short_backtest(df: pd.DataFrame, pred: pd.Series, top_pct: float = 0.1) -> pd.Series:
 """按预测分位做多空组合，返回每日收益（未计成本）。"""
 tmp = df.assign(pred=pred)
 daily = []
 for date, g in tmp.groupby("trade_date"):
 n = max(10, int(len(g) * top_pct))
 g = g.sort_values("pred", ascending=False)
 daily.append((date, g.head(n)["label"].mean() - g.tail(n)["label"].mean()))
 s = pd.Series(dict(daily)).sort_index()
 return s

实验室的实测水平（示例，2018-2025 的日频、5 日持有）：

指标	数值	评价
RankIC 均值	0.042	可用（> 0.03）
ICIR	0.31	弱但稳定
IC > 0 占比	0.58	尚可
多空年化（未计成本）	16.4%	与 IC 量级相符
多空最大回撤	-12.7%	可接受

注意这里的 IC 只有 0.042，远低于我第一版的 0.15。0.15 不是好消息，是报警信号。

六、过拟合诊断：三个必查项

6.1 特征重要性是否稳定

同一套流程在 2020-2022 和 2023-2025 两段数据上分别训练，如果两次的 top 特征完全不同，说明模型学的是噪声。

def top_features(booster, k: int = 6) -> list[str]:
 imp = booster.feature_importance(importance_type="gain")
 names = booster.feature_name()
 order = np.argsort(imp)[::-1][:k]
 return [names[i] for i in order]

实验室两次训练的 top 特征都是 rev_5 / mom_20 / turn_20 / vol_20，只有排序在变——这才叫稳定。

6.2 分年度 IC 是否衰减

by_year = ic.groupby(ic.index.str[:4]).agg(["mean", "count"])

如果 2024 年之后 IC 突然接近 0，那不是"市场变了"，更可能是因子被交易过度拥挤了。任何因子都有生命周期，要接受它。

6.3 SHAP 方向是否反常识

import shap

def explain_one_day(booster, df: pd.DataFrame, date: str, top_n: int = 5) -> pd.DataFrame:
 day = df[df["trade_date"] == date]
 explainer = shap.TreeExplainer(booster)
 sv = explainer.shap_values(day[FEATURES + ["industry"]])
 shap_df = pd.DataFrame(sv, columns=FEATURES + ["industry"], index=day.index)
 return shap_df.abs().mean().sort_values(ascending=False).head(top_n)

如果 SHAP 告诉你"换手率越低越好"，而你去查因子定义发现写反了符号——这类 bug 在 IC 评价里看不出来，但会在实盘里原形毕露。

七、从预测到组合：别忽略这一步

模型输出的是相对分数，不是权重。从分数到组合中间还有几件事：

截断极值：按预测分位取前 10%，而不是简单取 top 50 只（防止小盘股霸榜）；
行业约束：行业偏离不超过 3%，否则模型会集中押注某几个行业；
权重平滑：用分数排名加权（w ∝ rank），比等权更能利用信息，但换手更高；
在池内选股：只在沪深 300 / 中证 500 成分股里选，避免流动性黑洞。

这些环节对最终净值的影响，往往比换一个更强的模型更大。

八、踩坑清单

标签泄露：forward_return 只能用于 y，如果它不小心进入特征表（比如按 symbol merge 时列名撞车），IC 会好到不真实。
复权口径不一致：特征用前复权、标签用未复权，除权日会凭空出现 -30% 的标签。
行业分类会变：申万行业每年调整，历史行业标签要用当期分类，不能用今天的分类回填。
停牌股：停牌期间没有任何成交，标签却是"未来 5 日收益"，必须按可交易性把样本剔除，否则模型会学到"停牌股复牌后大涨"的伪规律。
groupby.apply 的 include_groups：pandas 2.2 之后行为变了，老代码会静默丢列，IC 计算直接错位。

结语

LightGBM 这条路的上限是清楚的：它能把多个弱因子合成一个稍强的信号，但不会凭空创造 alpha。IC 从单因子的 0.03 提到 0.042，靠的是模型对非线性与交互的捕捉，以及行业信息的利用。

如果还想往上走，就要引入序列结构——这正是下一篇的主题：用 TFT 与 ST-GNN 捕捉时序与截面图结构。那条路的坑，比 LightGBM 多得多。

远思为径，码动价值。模型不会让你赚钱，只会放大你流程里的漏洞。

双均线与动量轮动策略实战：参数稳健性比收益率更重要

Mon, 19 Oct 2026 21:00:00 +0800

远思为径，码动价值。欢迎来到远思码技术实验室的最新技术实践记录。

有了回测引擎，第一件想做的事一定是"跑一个看起来能赚钱的策略"。实验室也不例外，但我们刻意选了最简单、最没有故事性的两个策略来做基准，因为它们最不容易过拟合，也最容易暴露研究流程里的问题。

重要声明：本文所有回测结果均为实验室内部示例，使用的历史区间有限、未考虑全部交易限制，不构成任何投资建议。

一、策略 A：双均线择时

逻辑烂大街：短均线上穿长均线满仓，下穿空仓。它的价值不在于赚钱，而在于给我们一个"基准尺子"——任何复杂策略如果连它都打不过，就没必要继续。

# strategies/ma_cross.py
import pandas as pd


def ma_cross_signal(close: pd.Series, fast: int = 20, slow: int = 60) -> pd.Series:
 """返回目标仓位序列：1 满仓 / 0 空仓。只在收盘后生成，次日生效。"""
 ma_fast = close.rolling(fast).mean()
 ma_slow = close.rolling(slow).mean()
 sig = (ma_fast > ma_slow).astype(float)
 # 均线未成型期间不持仓
 sig[ma_slow.isna()] = 0.0
 return sig

把它接到引擎上只需要构造 target_w 矩阵：

# strategies/run_ma.py
import pandas as pd

from backtest.engine import BacktestConfig, run_backtest
from strategies.ma_cross import ma_cross_signal


def run_ma_backtest(symbol: str, start: str, end: str,
 fast: int = 20, slow: int = 60) -> dict:
 from src.data.loader import load_bars

 df = load_bars([symbol], start, end, adjust="qfq")
 close = df.pivot(index="trade_date", columns="symbol", values="close")
 volume = df.pivot(index="trade_date", columns="symbol", values="volume")
 pct = load_bars([symbol], start, end, adjust="none")
 pct = pct.pivot(index="trade_date", columns="symbol", values="pct_chg")

 sig = ma_cross_signal(close[symbol], fast, slow)
 target_w = pd.DataFrame({symbol: sig}, index=close.index)
 # 引擎内部会做 shift(1)：sig 在 T 日收盘生成，T+1 日承担收益
 res = run_backtest(close, volume, target_w, pct_chg=pct)
 return res.metrics

实验室以沪深 300 ETF（510300）为标的，2019-01 ~ 2025-06 的结果（示例）：

参数 (fast, slow)	年化收益	夏普	最大回撤	年化换手
(20, 60)	7.2%	0.62	-18.4%	2.1 倍
(10, 30)	5.8%	0.49	-21.7%	4.6 倍
(30, 120)	6.9%	0.66	-16.2%	0.9 倍
买入持有	3.4%	0.28	-42.1%	0

有价值的结论只有一个：择时把最大回撤从 -42% 压到 -18%，代价是年化收益只从 3.4% 提到 7.2%。这才是双均线的真实贡献——它是个风险管理工具，不是收益引擎。

二、策略 B：ETF 动量轮动

第二个策略稍微进阶：在一个 ETF 池里按动量排名，只持有最强的几只。

# strategies/momentum_rotation.py
from __future__ import annotations

import numpy as np
import pandas as pd


def momentum_score(close: pd.DataFrame, lookback: int = 20,
 vol_window: int = 20) -> pd.DataFrame:
 """风险调整动量：过去 N 日收益 / 过去 N 日波动。截面排名用。"""
 ret = close / close.shift(lookback) - 1
 vol = close.pct_change().rolling(vol_window).std()
 return (ret / vol).replace([np.inf, -np.inf], np.nan)


def build_target_weights(close: pd.DataFrame, score: pd.DataFrame,
 top_k: int = 2, rebalance: str = "M",
 min_score: float = 0.0) -> pd.DataFrame:
 """月末选动量最强的 top_k 只等权持有，其余现金。

 rebalance='M' 表示只在每月最后一个交易日调仓，中间日权重保持不变。
 """
 idx = close.index
 if rebalance == "M":
 # 每月最后一个交易日。这里统一转成 Timestamp，避免 datetime64 与 Timestamp
 # 在 set 里哈希不一致导致"一个调仓日都没命中"的静默 bug。
 month_end = pd.Series(idx, index=idx).groupby(idx.to_period("M")).max()
 rebal_set = {pd.Timestamp(d).normalize() for d in month_end}
 else:
 rebal_set = {pd.Timestamp(d).normalize() for d in idx}

 target = pd.DataFrame(0.0, index=idx, columns=close.columns)
 last_w = pd.Series(0.0, index=close.columns)
 for date, row in score.iterrows():
 if pd.Timestamp(date).normalize() in rebal_set:
 valid = row.dropna()
 # 只买动量为正的标的，否则空仓
 valid = valid[valid > min_score].sort_values(ascending=False)
 picks = valid.head(top_k).index
 last_w = pd.Series(0.0, index=close.columns)
 if len(picks):
 last_w[picks] = 1.0 / top_k
 target.loc[date] = last_w
 return target

ETF 池选了六只，覆盖股、债、商品、海外：

POOL = {
 "510300": "沪深300ETF",
 "510500": "中证500ETF",
 "159915": "创业板ETF",
 "513100": "纳指ETF",
 "518880": "黄金ETF",
 "511010": "国债ETF",
}

2019-01 ~ 2025-06，lookback=20, top_k=2, 月度调仓 的示例结果：

指标	动量轮动	沪深300 买入持有
年化收益	11.8%	3.4%
年化波动	14.2%	21.5%
夏普	0.79	0.28
最大回撤	-19.6%	-42.1%
Calmar	0.60	0.08
年化换手	8.4 倍	0
日胜率	53.1%	48.6%

分年度看，它并不每年都赢：

年份	轮动	沪深300	差异
2019	+21.4%	+36.1%	-14.7%
2020	+28.6%	+27.2%	+1.4%
2021	+16.3%	-5.2%	+21.5%
2022	-8.9%	-21.6%	+12.7%
2023	+5.2%	-11.4%	+16.6%
2024	+14.7%	+14.7%	0.0%
2025H1	+6.1%	+2.8%	+3.3%

2019 年跑输 15 个点，原因是牛市里持有单一最强动量 ETF，反而在板块轮动中来回挨打。这个"缺陷"贯穿了后面所有讨论：动量策略在趋势延续时赚钱，在急切换时亏钱。

三、参数稳健性：热力图比单点更好看也更诚实

实验室的规矩是：任何策略都不允许只看一组参数的结果。于是把 lookback × 调仓周期 打成一张热力图。

# scripts/grid_robustness.py
import itertools

import pandas as pd

from strategies.momentum_rotation import build_target_weights, momentum_score
from strategies.run_ma import run_ma_backtest # noqa: F401 (示意：复用取数/引擎)


def grid_search(close: pd.DataFrame, volume: pd.DataFrame, pct: pd.DataFrame) -> pd.DataFrame:
 rows = []
 for lookback, top_k, rebal in itertools.product([10, 20, 40, 60], [1, 2, 3], ["M", "W"]):
 score = momentum_score(close, lookback=lookback)
 w = build_target_weights(close, score, top_k=top_k, rebalance=rebal)
 res = run_backtest(close, volume, w, pct_chg=pct)
 rows.append({"lookback": lookback, "top_k": top_k, "rebal": rebal,
 **{k: res.metrics[k] for k in ("年化收益", "夏普", "最大回撤", "年化换手")}})
 return pd.DataFrame(rows)


def robustness_table(df: pd.DataFrame) -> pd.DataFrame:
 """汇总：多少比例的参数组合夏普 > 0.5，多少 > 0.3。"""
 return pd.DataFrame({
 "夏普>0.8": [(df["夏普"] > 0.8).mean()],
 "夏普>0.5": [(df["夏普"] > 0.5).mean()],
 "夏普>0.3": [(df["夏普"] > 0.3).mean()],
 "夏普中位数": [df["夏普"].median()],
 "最差夏普": [df["夏普"].min()],
 })

24 组参数的实际分布（示例）：

夏普中位数 0.61，最好 0.88，最差 0.12；
18/24 组夏普 > 0.4，说明策略不是靠某一组魔法参数撑起来的；
但 top_k=1 的 8 组里有 5 组夏普 < 0.4，集中度过高是这个策略的脆弱点。

判断标准很朴素：如果参数热力图上有大片"深坑"，说明策略在拟合噪声；如果是一片"高原"，参数不敏感，策略逻辑本身站得住。上面这张表勉强算高原。

四、成本敏感性：把假设打回原形

回测里最贵的不是滑点，是乐观。把成本参数逐级调高，看策略还剩多少：

成本假设	年化收益	夏普
佣金万三 + 无滑点	13.2%	0.88
佣金万三 + 单边 0.1% 滑点	11.8%	0.79
佣金万三 + 单边 0.2% 滑点	10.4%	0.70
再加 0.1% 冲击成本	8.1%	0.55
极端：单边 0.5%	3.2%	0.22

换手 8.4 倍的策略，成本每提高 0.1%，年化就掉 1.3~1.4 个点。这是 ETF 轮动真实的脆弱面——它需要每月真金白银地换仓。

也正因为这个原因，实验室的实盘版本改成了"只在新信号与当前持仓差异超过一定阈值时才调仓"，把年化换手从 8.4 倍压到 4 倍左右，年化收益只掉了 0.8 个点。这类工程细节，永远比再找一个因子更值钱。

五、几个只在实盘阶段才暴露的问题

ETF 溢价与流动性。纳指 ETF（513100）长期有溢价，回测里按净值成交的假设在实盘会被吃掉 1~3%。更麻烦的是它偶尔限购，大资金根本买不进去。
上市时间不同。创业板 ETF 2011 年就有，纳指 ETF 2013 年上市。如果起始日期按最长的算，早期回测里那些"缺失标的"会被当成持续下跌处理，动量排名就失真了。正确做法是只在当期有数据的标的里排名（dropna() 已经处理，但要检查是不是真的这么做的）。
幸存者偏差。ETF 池是按今天的名单选的。2019 年时并没有现在这么多行业 ETF，如果回测里混进了"因为后来表现好才被记住的品种"，结论就不可信。
分红与拆分。ETF 分红会导致价格跳空，未做复权的动量会误判趋势反转。

六、结论：策略的意义在于暴露流程问题

两个策略跑完，实验室得到的收获不是"找到了一条年化 12% 的曲线"，而是三件事：

择时工具的价值主要在压回撤，不要在它身上指望超额收益；
参数稳健性比单点最优重要一个数量级，热力图上的高原才是真信号；
换手是隐形税，任何策略的第一版都应该先算"成本翻倍后还剩多少"。

下一阶段，我们从"规则策略"转向"机器学习选股"——用 LightGBM 做截面收益预测，那里会碰到比参数网格更危险的东西：信息泄露。

远思为径，码动价值。回测里每一条平滑的曲线，背后都藏着一堆没写进报告的前提。

向量化回测引擎：从零实现一个可信的日频回测框架

Sat, 17 Oct 2026 20:40:00 +0800

远思为径，码动价值。欢迎来到远思码技术实验室的最新技术实践记录。

回测是量化研究里最容易产生幻觉的一步。同样一段策略逻辑，用不同框架、不同参数假设跑出来的年化收益率可以差出十几个点，而绝大多数差异都藏在三件小事里：成交价、交易限制、成本。

实验室的结论是：先自己写一个能看懂每一行的引擎，再去用现成框架。这篇就是那个引擎，全部代码不到 200 行。

一、引擎的契约

在写代码之前，先把输入输出定死，这是防止自己作弊的第一步：

输入	形状	含义
`close`	T×N	复权收盘价矩阵
`volume`	T×N	成交量矩阵（用于判断可交易性）
`pct_chg`	T×N	当日涨跌幅，用于判断涨跌停
`target_w`	T×N	T 日收盘后决定的下一期目标权重，行和 ≤ 1，余下为现金

输出	含义
`nav`	净值曲线（起点为 1）
`holdings`	每日实际持仓权重、换手、成本明细

关键约定只有一条：target_w 的第 t 行，是从第 t 日收盘之后开始生效的权重。引擎内部自己做 shift(1) 来实现"信号滞后一期"，策略代码里严禁再手动 shift，否则会重复滞后。

二、骨架：收益、漂移、成本

# backtest/engine.py
from __future__ import annotations

import itertools
from dataclasses import dataclass, field

import numpy as np
import pandas as pd


@dataclass
class BacktestConfig:
 fee_rate: float = 0.0003 # 佣金，双边
 stamp_duty: float = 0.0005 # 印花税，仅卖出
 slippage: float = 0.0010 # 单边滑点
 impact_coef: float = 0.0015 # 冲击成本系数（相对换手）
 rf: float = 0.02 # 无风险利率（年化）
 periods: int = 244 # 年化交易日


@dataclass
class BacktestResult:
 nav: pd.Series
 daily_return: pd.Series
 turnover: pd.Series
 cost: pd.Series
 holdings: pd.DataFrame
 metrics: dict = field(default_factory=dict)

核心循环全部用矩阵运算完成，一行 for 都不需要：

def run_backtest(close: pd.DataFrame,
 volume: pd.DataFrame,
 target_w: pd.DataFrame,
 pct_chg: pd.DataFrame | None = None,
 cfg: BacktestConfig | None = None) -> BacktestResult:
 cfg = cfg or BacktestConfig()
 close, volume = close.align(volume, join="inner")
 target_w = target_w.reindex(index=close.index, columns=close.columns).fillna(0.0)

 ret = close.pct_change().fillna(0.0) # 第 t 日收益，close_{t-1} -> close_t

 # ---- 1. 可交易性：停牌(volume=0) / 涨跌停 / 缺失价 ----
 tradable = (volume > 0) & close.notna() & (target_w.notna())
 if pct_chg is not None:
 pct = pct_chg.reindex_like(tradable)
 # 主板 ±10%、创业板/科创板 ±20%，用绝对阈值统一近似：≥9.8% 视为涨停不可买
 limit_up = pct >= 9.8
 limit_down = pct <= -9.8
 # 目标权重 > 0 且涨停 -> 买不进；目标权重 < 0 且跌停 -> 卖不出
 can_buy = tradable & ~limit_up
 can_sell = tradable & ~limit_down
 w_prev = target_w.shift(1)
 blocked_buy = (w_prev.isna() | (w_prev <= 0)) & (target_w > 0) & ~can_buy
 blocked_sell = (w_prev > 0) & (target_w <= 0) & ~can_sell
 target_w = target_w.mask(blocked_buy, 0.0).mask(blocked_sell, w_prev)

 # ---- 2. 归一化：不足 1 的部分视为现金 ----
 # 允许做多为主；若行和 > 1 则等比压缩，避免隐式杠杆
 gross = target_w.sum(axis=1).replace(0, np.nan)
 scale = np.where(gross > 1, 1 / gross, 1.0)
 target_w = target_w.mul(pd.Series(scale, index=target_w.index), axis=0).fillna(0.0)

 # ---- 3. 实际持仓 = 上一期目标权重（信号滞后一期） ----
 w_hold = target_w.shift(1).fillna(0.0)

 # ---- 4. 毛收益：今日持仓 × 今日收益 ----
 gross_ret = (w_hold * ret).sum(axis=1)

 # ---- 5. 权重漂移：今日收盘后各资产权重自然变化 ----
 denom = (1 + gross_ret).replace(0, np.nan)
 w_drift = w_hold.mul(1 + ret, axis=0).div(denom, axis=0).fillna(0.0)

 # ---- 6. 换手与成本：今日收盘调仓，相对漂移权重 ----
 delta = target_w - w_drift
 turnover_buy = delta.clip(lower=0).sum(axis=1) # 买入额占比
 turnover_sell = (-delta).clip(lower=0).sum(axis=1) # 卖出额占比
 turnover = turnover_buy + turnover_sell

 cost = (turnover_buy * (cfg.fee_rate + cfg.slippage)
 + turnover_sell * (cfg.fee_rate + cfg.slippage + cfg.stamp_duty)
 + turnover * cfg.impact_coef * turnover) # 冲击成本近似平方项

 port_ret = gross_ret - cost
 nav = (1 + port_ret).cumprod()

 res = BacktestResult(nav=nav, daily_return=port_ret, turnover=turnover,
 cost=cost, holdings=w_hold)
 res.metrics = performance(nav, port_ret, turnover, cfg)
 return res

有几处设计值得展开说：

w_hold = target_w.shift(1) 就是"信号滞后一期"的全部实现。策略在 T 日收盘后生成信号，T+1 日才能享受（或承受）收益。
漂移权重 w_drift 常被忽略。如果你 T 日满仓买入，T+1 日股票涨了 5%，那么 T+1 收盘时它在组合里的权重是 5% 之后的自然权重，不是当初的目标权重。调仓换手必须相对它算，否则每次调仓的换手都会被高估。
冲击成本写成 turnover * coef * turnover，即随换手平方增长。这比线性模型更贴近现实：大额调仓的边际成本上升。

三、绩效指标

def performance(nav: pd.Series, ret: pd.Series, turnover: pd.Series,
 cfg: BacktestConfig) -> dict:
 n = len(nav)
 if n < 2 or nav.iloc[-1] <= 0:
 return {"error": "样本不足或净值归零"}
 ann = nav.iloc[-1] ** (cfg.periods / n) - 1
 vol = ret.std(ddof=1) * np.sqrt(cfg.periods)
 sharpe = (ann - cfg.rf) / vol if vol else np.nan

 dd = nav / nav.cummax() - 1
 mdd = dd.min()
 calmar = ann / abs(mdd) if mdd else np.nan
 # 最大回撤持续天数（净值在水面之下的最长连续区间）
 underwater = (dd < 0).astype(int)
 max_flat = max((len(list(g)) for k, g in itertools.groupby(underwater) if k == 1),
 default=0)

 win = (ret > 0).mean()
 avg_turnover = turnover.mean()
 return {
 "累计收益": round(float(nav.iloc[-1] - 1), 4),
 "年化收益": round(float(ann), 4),
 "年化波动": round(float(vol), 4),
 "夏普": round(float(sharpe), 3),
 "最大回撤": round(float(mdd), 4),
 "最大回撤天数": int(max_flat),
 "Calmar": round(float(calmar), 3),
 "日胜率": round(float(win), 3),
 "日均换手": round(float(avg_turnover), 4),
 "年化换手": round(float(avg_turnover * cfg.periods), 2),
 "交易日数": int(n),
 }

这里 日均换手 × 244 = 年化换手 是个粗略但足够用的口径。日频策略年化换手超过 30 倍，成本假设就必须认真对待，不能再用"万一三"敷衍过去。

四、把正确性钉死：三个单元测试

引擎写完不测，等于没写。实验室用三个手算案例做回归测试，任何改动都必须过：

# tests/test_engine.py
import numpy as np
import pandas as pd
from backtest.engine import BacktestConfig, run_backtest

def _frames(ret_rows):
 """由收益矩阵构造价格矩阵（起点 10 元）。"""
 close = (1 + pd.DataFrame(ret_rows)).cumprod() * 10
 volume = pd.DataFrame(1e6, index=close.index, columns=close.columns)
 return close, volume


def test_single_stock_buy_and_hold():
 # 两天，每天涨 10%。T日收盘建仓 -> T+1 才吃到收益
 close, volume = _frames([[0.10], [0.10]])
 w = pd.DataFrame([[1.0], [1.0]], index=close.index, columns=close.columns)
 res = run_backtest(close, volume, w, cfg=BacktestConfig(fee_rate=0, stamp_duty=0,
 slippage=0, impact_coef=0))
 # 第一天无持仓（w 被 shift），第二天满仓吃 10%
 assert abs(res.nav.iloc[0] - 1.0) < 1e-12
 assert abs(res.nav.iloc[1] - 1.10) < 1e-12


def test_cost_is_charged_on_turnover():
 close, volume = _frames([[0.0], [0.0]])
 w = pd.DataFrame([[1.0], [0.0]], index=close.index, columns=close.columns)
 cfg = BacktestConfig(fee_rate=0.001, stamp_duty=0.001, slippage=0, impact_coef=0)
 res = run_backtest(close, volume, w, cfg=cfg)
 # 第一天：w.shift 后仍为 0 -> 无持仓；第二天持仓 1 后立刻清仓？
 # 实际：hold 恒为 [0, 1]，故第二天收盘换手 = 1，卖出成本 = 1*(佣金0.001+印花税0.001)
 assert res.turnover.iloc[1] == 1.0
 assert abs(res.cost.iloc[1] - 0.002) < 1e-12


def test_weights_never_imply_leverage():
 close, volume = _frames([[0.01], [0.01], [0.01]], )
 w = pd.DataFrame([[0.8], [0.8], [0.8]], index=close.index, columns=close.columns)
 res = run_backtest(close, volume, w, cfg=BacktestConfig(fee_rate=0, stamp_duty=0,
 slippage=0, impact_coef=0))
 assert (res.holdings.sum(axis=1) <= 1 + 1e-9).all()

第二个测试看起来有点绕，但它锁住了一个非常具体的语义：换手发生在"目标权重与漂移权重不一致"的那一天，成本当天计提。这个语义一旦写错，所有策略的成本都会被系统性低估。

五、什么时候该换成事件驱动框架

向量化引擎的假设是：同一时点所有股票都能按收盘价成交，且份额可以无限细分。它在下列场景会失真：

场景	向量化引擎的问题	建议
分钟级 / 盘口撮合	无法表达排队、部分成交	事件驱动（vn.py / backtrader / 自研撮合）
资金量大于标的日成交额的 1%	冲击成本模型过于乐观	引入成交量参与率约束
需要盘中撤单、止损单	无订单生命周期	事件驱动
组合再平衡涉及资金约束（现金不足）	权重假设掩盖了资金不足	加现金约束层

实验室的日常研究 90% 用向量化，因为要跑几千组参数；只有在策略进入仿真阶段，才用事件驱动复核一遍。先用快而粗糙的尺子找方向，再用慢而精确的尺子确认。

六、一个常见误用

有人会把 target_w 直接设成"今天涨得最好的股票"，然后跑出 500% 的年化——因为他在 T 日收盘时用了 T 日的数据去选股，而引擎的 shift(1) 让这份"未来信息"合法化了。

判断方法很简单：把 shift(1) 改成 shift(2)，如果年化收益暴跌，说明策略严重依赖即时信息，值得警惕。

结语

到这里我们有了两样东西：可检验的因子，和可信的尺子。下一篇用它们跑第一个真实策略——双均线与动量轮动的组合，顺带把参数稳健性检验做完。

远思为径，码动价值。回测是用来证伪的，不是用来给自己发奖金的。

TimescaleDB 量化行情库进阶：分区、压缩与连续聚合

Wed, 14 Oct 2026 21:30:00 +0800

远思为径，码动价值。欢迎来到远思码技术实验室的最新技术实践记录。

在量化数据存储选型那篇里，我留下了一个结论：冷数据归档用 ClickHouse，热数据计算交给 DolphinDB。但实验室真正跑日常研究的那套库，最后选了第三个选项——TimescaleDB。

原因很朴素：A 股日线一年也就一百多万行，任何数据库都扛得住；真正稀缺的是"能不能用 SQL 直接把数据拼出来"。TimescaleDB 是 PostgreSQL 扩展，意味着我可以用窗口函数、DISTINCT ON、CTE、generate_series 这些熟悉的东西，而不用为了一次取数去写一段 DolphinDB 脚本。

这篇记录的是把它从"能存"做到"能长期跑"的几个关键点。

一、超表分区：时间维度 + 空间维度

上一篇文章里我们建了最简单的超表：

CREATE TABLE daily_bar (
 symbol text NOT NULL,
 trade_date date NOT NULL,
 open double precision,
 high double precision,
 low double precision,
 close double precision,
 volume bigint,
 amount double precision,
 turnover double precision,
 pct_chg double precision,
 adj_factor double precision DEFAULT 1.0,
 PRIMARY KEY (symbol, trade_date)
);

SELECT create_hypertable('daily_bar', 'trade_date',
 chunk_time_interval => INTERVAL '1 year',
 if_not_exists => TRUE);

日线量级下这样完全够用。但当我把分钟线也接进来（5 分钟 K 线，全市场一年约 1.6 亿行）之后，问题出现了：单个 chunk 内部扫的是全市场。查询"贵州茅台最近一年 5 分钟线"仍然要扫过所有股票的 5 分钟数据。

解决办法是引入空间维度，按 symbol 做哈希分区：

SELECT create_hypertable('minute_bar', 'ts',
 partitioning_column => 'symbol',
 number_partitions => 8,
 chunk_time_interval => INTERVAL '7 days',
 if_not_exists => TRUE);

建完之后，一张超表实际变成 8 × 时间片 个物理子表。查询条件里带 symbol 时，规划器直接裁掉 7/8 的分区。

经验值：number_partitions 别超过 CPU 核心数的两倍太多。分区太碎会让插入时的元数据开销超过收益，8 分片在实验室的 8 核机器上正好。

二、压缩：按 symbol 分段，按时间排序

时序数据最大的浪费是重复。同一只股票、连续的交易日，symbol 完全重复，价格变化很小。TimescaleDB 的列式压缩把"同一 segment 内的行"转成数组存储，压缩比通常在 5~20 倍。

ALTER TABLE minute_bar SET (
 timescaledb.compress,
 timescaledb.compress_segmentby = 'symbol',
 timescaledb.compress_orderby = 'ts DESC'
);

-- 7 天以前的数据自动压缩
SELECT add_compression_policy('minute_bar', INTERVAL '7 days');

两个参数的选择逻辑：

compress_segmentby 决定了"哪些行会被放在一起"。因为绝大多数查询都是按股票取一段连续时间，所以分段键选 symbol。
compress_orderby 决定段内排序。时间倒序排列，让"最新 N 条"的查询能快速定位。

实验室实测（8 核 / 32GB / NVMe，A 股 5 分钟线 1 年）：

状态	表大小	单股 1 年查询耗时
未压缩	6.3 GB	210 ms
压缩后	780 MB	240 ms
压缩后 + 带 symbol 条件	780 MB	35 ms

压缩后写入变慢（约 1.4 倍），但我们的写入集中在盘后批处理，完全无所谓。如果你的场景是盘中高频写入 + 实时查询，压缩窗口不要设得太短——被压缩的 chunk 不能再直接 INSERT，新数据会跑到新的 chunk 去，这是设计使然而不是缺陷。

三、连续聚合：日线自动滚成月线

研究里最烦的是"每次都要手写一段 group by 把日线变月线"。连续聚合（Continuous Aggregate）把这一步变成库里的物化视图，增量刷新：

CREATE MATERIALIZED VIEW monthly_bar
WITH (timescaledb.continuous) AS
SELECT symbol,
 time_bucket('1 month', trade_date) AS trade_month,
 first(open, trade_date) AS open,
 max(high) AS high,
 min(low) AS low,
 last(close, trade_date) AS close,
 sum(volume) AS volume,
 sum(amount) AS amount
FROM daily_bar
GROUP BY symbol, trade_month
WITH NO DATA;

SELECT add_continuous_aggregate_policy('monthly_bar',
 start_offset => INTERVAL '3 years',
 end_offset => INTERVAL '1 day',
 schedule_interval => INTERVAL '1 hour');

注意 end_offset => INTERVAL '1 day'：只刷新到昨天为止。当月数据还在变，如果聚合到当天，物化结果就是一个会不断被改写的"半成品"，容易在回测里用到未完成的月线。查询时当月数据仍然走实时聚合（TimescaleDB 会自动 union 未物化的部分）。

真实用法是这样：

-- 查询某只股票的月线序列，物化部分 + 实时部分自动拼接
SELECT trade_month, open, close, volume
FROM monthly_bar
WHERE symbol = '600519' AND trade_month >= '2020-01-01'
ORDER BY trade_month;

四、增量写入：幂等 upsert 与复权因子

盘后同步任务每天会重跑，必须保证幂等。ON CONFLICT DO UPDATE 是标准解法：

INSERT INTO daily_bar (symbol, trade_date, open, high, low, close,
 volume, amount, turnover, pct_chg, adj_factor)
VALUES (:symbol, :trade_date, :open, :high, :low, :close,
 :volume, :amount, :turnover, :pct_chg, :adj_factor)
ON CONFLICT (symbol, trade_date) DO UPDATE
SET close = EXCLUDED.close,
 volume = EXCLUDED.volume,
 pct_chg = EXCLUDED.pct_chg,
 adj_factor = EXCLUDED.adj_factor;

这里有个容易忽略的设计：存未复权价 + 复权因子，而不是直接存前复权价。

前复权价会在每次除权后整体重算，历史数据被"改写"，导致同一天的因子值在不同时间点算出来不一样；
业界惯例（也是 akshare 的 hfq 接口）是存后复权或存 adj_factor，复权在查询层做，历史数值永远不变。

查前复权价时在 SQL 里乘一下即可：

SELECT trade_date,
 close * adj_factor / MAX(adj_factor) OVER () AS close_qfq
FROM daily_bar WHERE symbol = '000001' ORDER BY trade_date;

反面教材：早期我用"每天重写整段前复权序列"的方式同步数据，结果同一个因子在 3 月跑出来 IC 是 0.031，6 月重跑变成 0.027。差的那一点就是除权。数值漂移是量化研究里最隐蔽的 bug。

五、保留策略与冷热分层

分钟线不能无限堆。实验室的策略是：

-- 3 年前的分钟线直接删除
SELECT add_retention_policy('minute_bar', INTERVAL '3 years');

日线则不删，因为它小到可以忽略（15 年 A 股日线约 2 GB，压缩后 300 MB 左右）。

如果要做真正的归档，可以把老 chunk 的压缩数据 COPY 导出到对象存储（实验室用的是内网的 MinIO），再用 drop_chunks 释放：

-- 导出后再删除
COPY (SELECT * FROM minute_bar WHERE ts < '2021-01-01')
TO PROGRAM 'gzip > /mnt/minio-archive/minute_bar_2020.csv.gz' CSV HEADER;

SELECT drop_chunks('minute_bar', older_than => INTERVAL '5 years');

六、一个取数函数，统一到矩阵

数据库再好，研究时用的还是 DataFrame。实验室封装了一个按需取数的函数，把"复权、停牌、字段选择"都收在这里：

# src/data/loader.py
from __future__ import annotations

import pandas as pd
from sqlalchemy import create_engine

DSN = "postgresql+psycopg2://quant:quant@127.0.0.1:5432/quant"


def load_bars(symbols: list[str], start: str, end: str,
 freq: str = "1d", adjust: str = "qfq",
 engine=None) -> pd.DataFrame:
 """取行情长表，自动按 adjust 做复权。

 adjust: 'none' | 'qfq'(前复权) | 'hfq'(后复权)
 返回列: symbol, trade_date, open, high, low, close, volume, amount
 """
 engine = engine or create_engine(DSN, pool_pre_ping=True)
 table = "daily_bar" if freq == "1d" else "minute_bar"
 tcol = "trade_date" if freq == "1d" else "ts"

 sql = f"""
 SELECT symbol, {tcol} AS trade_date, open, high, low, close,
 volume, amount, adj_factor
 FROM {table}
 WHERE {tcol} BETWEEN :start AND :end
 AND symbol = ANY(:symbols)
 ORDER BY symbol, {tcol}
 """
 df = pd.read_sql(sql, engine, params={"start": start, "end": end, "symbols": symbols})

 if adjust in ("qfq", "hfq") and not df.empty:
 df = df.sort_values(["symbol", "trade_date"])
 grp = df.groupby("symbol", sort=False)["adj_factor"]
 ratio = grp.transform("last") if adjust == "qfq" else 1.0
 for col in ["open", "high", "low", "close"]:
 df[col] = df[col] * df["adj_factor"] / ratio
 return df.drop(columns=["adj_factor"])

ratio 那一行就是前复权的全部秘密：把当前复权因子归一，最新的价格保持原始数值，历史价格被等比缩小。

七、踩过的坑清单

ALTER TABLE hypertable 的坑：超表上加索引必须建在超表上（CREATE INDEX ON daily_bar (...)）），不要手动往 chunk 上建，重建 chunk 之后索引就丢了。
主键必须包含时间分区列。TimescaleDB 的约束要求唯一索引包含分区列，PRIMARY KEY (symbol) 会直接报错。
time_bucket 与交易日历不是一回事。“按月"聚合出来的是自然月，2 月只有 15 个交易日，用它算月收益没问题，但用它算"每月调仓"就会和交易日错位。
别在压缩 chunk 上做大量 UPDATE。压缩块和解压块的写入路径不同，反复更新老数据会把压缩收益吃光。需要修正历史数据时，一次性 decompress_chunk → 更新 → compress_chunk。
vacuum 不是万能的。时序表几乎只增不改，但 drop_chunks 之后还是建议看一眼 autovacuum 的触发情况。

结语

数据层做到这里，已经不是"能存数据"的层次，而是”取数不成为研究瓶颈"：单股分钟线 35 ms、全市场日线截面 1 秒内出结果。

数据齐了、因子有了，接下来是最容易自欺欺人的一环：回测。下一篇从零写一个向量化回测引擎，把手续费、滑点、涨跌停、T+1 全部显式建模。

远思为径，码动价值。基础设施的耐心，最终都会体现在回测曲线是否可信上。

因子工程实战：从行情数据到可检验的 Alpha 因子

Mon, 12 Oct 2026 20:10:00 +0800

远思为径，码动价值。欢迎来到远思码技术实验室的最新技术实践记录。

在上一篇数据抓取里，我们已经把 A 股日线行情写进了 TimescaleDB 的超表。但干净的数据不等于可用的信号——从"能取到数据"到"能下单"，中间隔着整个因子工程。

这篇文章把我们实验室的因子流水线拆开讲：怎么写、怎么校验、怎么避免自己骗自己。

一、先立四条纪律

因子工程里绝大多数翻车，不是因为数学不够花哨，而是因为违反了下面前四条之一：

不使用未来信息。T 日收盘后才能拿到的数据，只能在 T 日收盘后生成信号，T+1 开盘执行。任何 center=True 的滚动窗口、任何全样本拟合的标准化，都是未来函数。
截面可比。因子值必须在同一个交易日的横截面上做标准化，而不是用时间序列均值。
可复现。因子定义、参数、数据版本都写进代码与因子表，重跑必须得到同样的数字。
可检验。一个因子在入库前必须回答两个问题：它对未来收益有没有单调信息（IC / 分层），扣掉成本后还剩多少（换手）。

第 4 条最容易被跳过，而它恰好是唯一真正重要的一条。

二、取数：把宽表拉成矩阵

实验室的行情表结构在上一篇文章里已经建好，核心字段是 symbol / trade_date / close / volume / amount / turnover / pct_chg。因子计算更适合"矩阵"而不是"长表"，所以第一步先 pivot：

# src/data/market.py
from __future__ import annotations

import pandas as pd
from sqlalchemy import create_engine

DSN = "postgresql+psycopg2://quant:quant@127.0.0.1:5432/quant"


def load_price_matrix(start: str, end: str, engine=None) -> dict[str, pd.DataFrame]:
 """返回 {'close','volume','amount','turnover','pct_chg'} 五张 T×N 矩阵。"""
 engine = engine or create_engine(DSN, pool_pre_ping=True, pool_size=4)
 sql = """
 SELECT symbol, trade_date, close, volume, amount, turnover, pct_chg
 FROM daily_bar
 WHERE trade_date BETWEEN %(start)s AND %(end)s
 ORDER BY trade_date, symbol
 """
 df = pd.read_sql(sql, engine, params={"start": start, "end": end})

 out: dict[str, pd.DataFrame] = {}
 for col in ["close", "volume", "amount", "turnover", "pct_chg"]:
 out[col] = df.pivot(index="trade_date", columns="symbol", values=col).sort_index()
 # 停牌日通常缺失，这里保留 NaN：后续因子计算里 NaN 会自然传播成"不可交易"
 return out

两个细节值得强调：

不要 fillna(method="ffill") 无脑填充。停牌日的价格是"没有成交"，强行前向填充会让动量因子把停牌期算成 0 收益，回测里会凭空产生收益。
矩阵的列（股票）会随时间变化。新股上市、退市都会造成列不对齐，后续用 DataFrame.align 或直接按日截面处理。

三、五个基础因子，先够用再说

不用一上来就上百个因子。实验室的第一版只用了五类，覆盖量价四个维度：

因子	定义	逻辑
`mom_20`	过去 20 日收益	动量效应
`rev_5`	过去 5 日收益取负	短期反转
`vol_20`	20 日收益率标准差取负	低波动异象
`turn_20`	20 日平均换手取负	高换手 = 拥挤
`bias_20`	`close / MA20 - 1` 取负	均值回复

# src/factor/basic.py
import numpy as np
import pandas as pd


def momentum(close: pd.DataFrame, n: int = 20) -> pd.DataFrame:
 """n 日动量：T 日因子 = T 日收盘 / T-n 日收盘 - 1（截止当日，不含未来信息）。"""
 return close / close.shift(n) - 1


def reversal(close: pd.DataFrame, n: int = 5) -> pd.DataFrame:
 return -momentum(close, n)


def volatility(pct: pd.DataFrame, n: int = 20) -> pd.DataFrame:
 # pct_chg 已是百分数，先转成小数
 return -(pct / 100).rolling(n).std()


def turnover_avg(turnover: pd.DataFrame, n: int = 20) -> pd.DataFrame:
 return -turnover.rolling(n).mean()


def bias(close: pd.DataFrame, n: int = 20) -> pd.DataFrame:
 ma = close.rolling(n).mean()
 return -(close / ma - 1)

上面每个因子都只用「截止当日」的数据，这是故意保持的语义：因子定义里不包含任何执行滞后，滞后只在回测引擎里统一做一次。原因很实际——如果因子内部先 shift(1)，回测引擎再叠一层 shift(1)，策略就凭空慢了半拍，收益会被系统性低估；反过来如果某处漏了 shift，又会偷到未来收益。滞后只在一处发生，才方便审计。下一篇的引擎会严格实现这条约定。

四、去极值与标准化：截面处理三步

原始因子值直接进模型会被几只极端值股票带偏。截面处理固定三步：

# src/factor/process.py
import numpy as np
import pandas as pd


def mad_winsorize(df: pd.DataFrame, n: float = 3.0) -> pd.DataFrame:
 """按日截面做 MAD 去极值（中位数 ± n * 1.4826 * MAD）。"""
 med = df.median(axis=1)
 mad = (df.sub(med, axis=0)).abs().median(axis=1) * 1.4826
 upper = med + n * mad
 lower = med - n * mad
 return df.clip(lower=lower, upper=upper, axis=0)


def zscore(df: pd.DataFrame) -> pd.DataFrame:
 """按日截面做 z-score。std=0（全市场同一个值）时返回 0 而不是 inf。"""
 mu = df.mean(axis=1)
 sd = df.std(axis=1).replace(0, np.nan)
 return df.sub(mu, axis=0).div(sd, axis=0)


def industry_neutralize(factor: pd.DataFrame, industry: pd.DataFrame) -> pd.DataFrame:
 """行业中性化：对每个交易日，把因子对行业哑变量做 OLS，取残差。

 industry: 与 factor 同形状的行业标签矩阵（如 "银行"、"电子"），缺失记为 NaN。
 """
 residual = factor.copy() * np.nan
 for date in factor.index:
 y = factor.loc[date]
 g = industry.loc[date]
 mask = y.notna() & g.notna()
 if mask.sum() < 30:
 continue
 dummies = pd.get_dummies(g[mask], drop_first=True, dtype=float)
 if dummies.empty:
 residual.loc[date] = y[mask]
 continue
 X = np.column_stack([np.ones(mask.sum()), dummies.to_numpy()])
 yv = y[mask].to_numpy()
 beta, *_ = np.linalg.lstsq(X, yv, rcond=None)
 residual.loc[date, mask] = yv - X @ beta
 return residual

顺序很重要：先 MAD 去极值 → 再行业中性化 → 最后 z-score。如果先标准化再中性化，残差的量纲会乱，后面做因子加权时权重就失去意义了。

提醒：行业中性化一定会"吃掉"一部分收益。如果你的因子本来就是行业轮动逻辑（比如"超配银行"），中性化之后就只剩行业内选股能力了——这不是坏事，只是要清楚自己在测什么。

五、检验：IC、分层、换手，一个都不能少

因子是否有效，实验室只用三个指标下结论。

5.1 IC 与 ICIR

# src/factor/evaluate.py
import numpy as np
import pandas as pd
from scipy.stats import spearmanr


def forward_return(close: pd.DataFrame, hold: int = 5) -> pd.DataFrame:
 """未来 hold 日收益（用于评价，绝不进入因子计算）。"""
 return close.shift(-hold) / close - 1


def daily_ic(factor: pd.DataFrame, fwd_ret: pd.DataFrame, method: str = "spearman") -> pd.Series:
 """每个交易日横截面上的因子与未来收益的相关性。"""
 ics = {}
 for date in factor.index:
 x, y = factor.loc[date], fwd_ret.loc[date]
 mask = x.notna() & y.notna()
 if mask.sum() < 50:
 continue
 if method == "spearman":
 ics[date] = spearmanr(x[mask], y[mask]).statistic
 else:
 ics[date] = np.corrcoef(x[mask], y[mask])[0, 1]
 return pd.Series(ics).sort_index()


def ic_summary(ic: pd.Series, periods_per_year: int = 244) -> dict:
 ir = ic.mean() / ic.std(ddof=1) if ic.std(ddof=1) else np.nan
 return {
 "IC均值": round(float(ic.mean()), 4),
 "IC标准差": round(float(ic.std(ddof=1)), 4),
 "ICIR": round(float(ir), 3),
 "IC>0占比": round(float((ic > 0).mean()), 3),
 "年化ICIR": round(float(ir * np.sqrt(periods_per_year / 5)), 2) if ir == ir else None,
 "样本天数": int(len(ic)),
 }

经验阈值（日频、5 日持有）：|IC均值| > 0.02、ICIR > 0.3、IC > 0 占比 > 0.55 才值得往下做分层测试。低于这个水平，后面所有回测都只是在拟合噪声。

5.2 分层收益

def layered_return(factor: pd.DataFrame, fwd_ret: pd.DataFrame, q: int = 5) -> pd.DataFrame:
 """按日截面分 q 组，等权持有 forward 收益，返回每组的年化收益。"""
 groups: dict[int, list[float]] = {i: [] for i in range(q)}
 for date in factor.index:
 x, y = factor.loc[date], fwd_ret.loc[date]
 mask = x.notna() & y.notna()
 if mask.sum() < q * 10:
 continue
 labels = pd.qcut(x[mask].rank(method="first"), q, labels=False)
 for g, idx in labels.groupby(labels).groups.items():
 groups[int(g)].append(float(y[mask].loc[idx].mean()))
 annual = {}
 for g, rets in groups.items():
 s = pd.Series(rets)
 annual[f"Q{g + 1}"] = round(float(s.mean() * (244 / 5)), 4) if len(s) else None
 return pd.DataFrame([annual], index=["年化收益"])

一个真正有效的因子，Q1 → Q5 应该单调，并且首尾组年化差异是稳定的，而不是靠某一年撑起来的。

5.3 换手率

IC 再漂亮，如果因子每天把整个组合换个遍，扣完成本就归零。实验室的标准做法是算因子秩的日间自相关来近似换手：

def rank_autocorr(factor: pd.DataFrame, lag: int = 1) -> float:
 """因子截面秩的自相关，越高越稳定（0.9 以上说明换手很低）。"""
 ranks = factor.rank(axis=1, pct=True)
 vals = []
 for date in ranks.index[lag:]:
 a = ranks.loc[date]
 b = ranks.shift(lag).loc[date]
 mask = a.notna() & b.notna()
 if mask.sum() < 50:
 continue
 vals.append(float(np.corrcoef(a[mask], b[mask])[0, 1]))
 return float(np.nanmean(vals))

六、落库：因子表长什么样

因子算完不要停在 notebook 里。实验室统一写入 factor_value 表，主键 (factor_name, trade_date, symbol)，字段 raw / z，外加版本号：

CREATE TABLE IF NOT EXISTS factor_value (
 factor_name text NOT NULL,
 trade_date date NOT NULL,
 symbol text NOT NULL,
 raw double precision,
 z double precision,
 version text NOT NULL DEFAULT 'v1',
 PRIMARY KEY (factor_name, trade_date, symbol)
);

SELECT create_hypertable('factor_value', 'trade_date',
 chunk_time_interval => INTERVAL '90 days',
 if_not_exists => TRUE);

写入时用 ON CONFLICT DO UPDATE 做幂等 upsert，这样重跑某一天的因子不会产生重复行：

from sqlalchemy import text

UPSERT = text("""
 INSERT INTO factor_value (factor_name, trade_date, symbol, raw, z, version)
 VALUES (:factor_name, :trade_date, :symbol, :raw, :z, :version)
 ON CONFLICT (factor_name, trade_date, symbol)
 DO UPDATE SET raw = EXCLUDED.raw, z = EXCLUDED.z, version = EXCLUDED.version
""")

七、几个一定会踩的坑

复权基准会变。前复权价格在每次除权后整体重算，历史因子值会"漂移"。实验室的做法是因子表存未复权价 + 复权因子，复权只在计算时做，并且记录 version。
ST / 退市股没剔除。z 值算对了，但买不进去。因子入库前就该把"不可交易"标出来，别等到回测才过滤。
成分股用的是今天的名单。这是幸存者偏差的经典来源，做指数增强类策略时必须用当期成分股快照。
IC 算的是样本内。因子是全样本算出来的，IC 也是全样本。真正的检验要在滚动窗口里做，下一篇会展开。

结语

到这里，我们有了一个可复现、可检验的因子表。接下来两件事必须按顺序做：先把回测引擎写对，再用它去证伪这些因子——先有可信的尺子，再去量东西。

远思为径，码动价值。数据给了原料，因子给了假设，剩下的交给回测去审判。

A 股量化交易实战路线图：从数据到实盘的七个环节

Sun, 11 Oct 2026 19:30:00 +0800

远思为径，码动价值。欢迎来到远思码技术实验室的最新技术实践记录。

经常有人问我：“想做量化，从哪开始？” 我的回答一直是同一句：从回测开始，而不是从策略开始。因为不能证伪的策略，连讨论的资格都没有。

这篇文章是实验室量化系列的总入口，把七个环节的顺序、选型、踩坑优先级一次讲清，每个环节都链接到对应的实战长文。

一、全景：七个环节

①数据 → ②因子 → ③回测 → ④策略 → ⑤机器学习 → ⑥深度模型
 ↘ ↗
 ⑦实盘自动化（调度 + 推送 + 监控）────────────────┘

#	环节	核心问题	实战文章
①	数据获取	用免费数据能走多远？	Akshare 财经数据抓取实战
①′	数据存储	日线/分钟线用什么存？	TimescaleDB 量化行情库进阶、ClickHouse vs DolphinDB
②	因子工程	怎么判断一个因子是否有用？	因子工程实战
③	回测	回测为什么总是骗人？	向量化回测引擎
④	策略	参数不稳的策略能上线吗？	双均线与动量轮动策略实战
⑤	机器学习	模型能替代人工因子吗？	LightGBM 截面选股
⑥	深度模型	TFT/ST-GNN 值不值得？	TFT 与 ST-GNN 的真实收益边界
⑦	实盘自动化	怎么让它自己跑起来？	每日选股信号的自动化

二、顺序很重要，顺序错了就是浪费时间

实验室的推荐顺序，是从"能证伪的东西“往”不确定的东西“推进：

先把回测引擎写对（环节③）。很多人一上来就研究因子，结果跑出来的超额收益全部来自成本假设太乐观、停牌没剔除、T+1 没做。引擎不对，后面所有结论都要重做。
再做因子（环节②）。有了可信的尺子，才能判断因子死活。
然后才是策略组合（环节④）。单因子跑通后再谈多因子加权、行业约束。
机器学习放在第五步（环节⑤⑥）。它建立在因子池之上，跳过前两步直接用 GBDT 喂原始价量，几乎必然过拟合。
最后接自动化（环节⑦）。它不难，但前提是前面每一步都能被脚本调用——notebook 里的代码是没法定时跑的。

如果你只有两周时间，我建议的分配是：引擎 1 周、因子 4 天、策略 3 天，其余都可以往后放。

三、硬件与环境清单

实验室跑这套流程的真实配置（2026 年）：

角色	设备	说明
主力算力	Minisforum N5 Pro，AMD Radeon 890M iGPU，48GB UMA 统一内存	日频策略绰绰有余，深度模型也能跑
数据节点	同一台机器上的 TimescaleDB + MinIO	日线 15 年约 2GB，分钟线靠压缩压到 1/8
系统	Ubuntu 26.04 LTS	见安装与调优指南
Python	Miniconda3 + systemd 守护	见安装与 systemd 配置
GPU 加速	ROCm 7.2.3 + PyTorch ROCm 构建	见 llama.cpp ROCm 部署笔记

一个反直觉的结论：日频 A 股量化对硬件的要求低得惊人。5000 只股票 × 250 天 × 20 个因子，约 2500 万个浮点数，普通笔记本都能跑。真正的瓶颈是数据质量与流程严谨性，不是算力。

四、技术栈选型表

层	选择	备选	理由
数据处理	pandas	polars / DuckDB	生态完整，向量化回测够用；性能瓶颈真出现再换
时序库	TimescaleDB	ClickHouse / DolphinDB	PostgreSQL 生态，SQL 直达，运维成本最低
回测	自研向量化引擎	backtrader / vn.py	每一行都看得懂，才能信任结论
因子检验	scipy + statsmodels	alphalens	自己算 IC/分层，避免工具黑箱
机器学习	LightGBM	XGBoost / CatBoost	表格数据的最优解，训练快、正则强
深度学习	PyTorch + pytorch-forecasting	TensorFlow	ROCm 支持好，TFT 有现成实现
调度	systemd timer	cron / Airflow	依赖管理、重试、日志开箱即用
部署	单机 + nginx	Docker Compose	策略服务的复杂度不值得上 K8s

五、免费数据能走多远？说实话

这是被问得最多的问题。实验室的观点：

日频价量 + 财务数据，免费数据完全够用。Akshare、Tushare 免费档、交易所官网，能覆盖 95% 的日频研究需求。
分钟线也能凑，但质量参差。免费分钟线常见问题：停牌期缺失、集合竞价缺失、复权因子不全。
付费数据的价值在"非价格信息”：龙虎榜、资金流、公告文本、行业分类。这些才是 2026 年之后超额收益的主要来源。
不要为了数据花钱，先花时间把流程做对。我见过太多人买了 3 万的数据，却用着含未来函数的回测。

六、五个最常见的误区

“我的策略年化 80%” —— 先查三件事：有没有用未来数据、有没有扣成本、有没有剔除 ST 与停牌。
“参数调一调就好了” —— 参数热力图上的深坑才是真实分布，单点最优是拟合结果。
“加个止损就能提高收益” —— 止损降低波动，但通常也降低收益，它改善的是持有体验而非期望。
“机器学习不需要因子” —— 模型只能组合信息，不能创造信息。喂原始价量的 GBDT 通常打不过十个手工因子。
“跑通就能实盘” —— 从回测到实盘，中间还隔着滑点、流动性、涨跌停、ETF 溢价与自己的心理。

七、一条完整的执行清单

如果你打算按这条路走下去，可以直接抄这份清单：

环境就绪：Python 3.12+、pandas 2.x、TimescaleDB 跑通
行情落库：日线全市场，含复权因子，幂等增量更新
回测引擎：三个单元测试通过，成本/涨跌停/T+1 全部显式建模
因子库：至少 10 个因子，写清定义与 IC 记录
基准策略：双均线择时 + 动量轮动，作为后续对比基线
模型：LightGBM 跑通，purged 时序切分，分年度 IC 稳定
深度模型：TFT 作为风格因子叠加，验证与 GBDT 的低相关性
自动化：systemd timer + 幂等落库 + 推送 + 心跳告警
小资金实盘：跑满 3 个月，对比回测与实盘的偏差

最后一条最重要：小资金实盘三个月，比对回测曲线与真实净值。那三个月的偏差，会告诉你前面所有环节哪里在骗你。

结语

量化不是一场关于"找到圣杯"的竞赛，而是一场关于减少自欺的工程。数据要干净、回测要老实、成本要算足、上线要可监控——把这些做到位，年化个位数的稳定收益并不难；做不到，年化三位数的曲线也只是纸面上的。

远思为径，码动价值。愿你跑出的每一条曲线，都经得起自己的审问。

本文系列中所有数据、参数与回测结果均为实验室内部示例，用于说明方法论，不构成任何投资建议。市场有风险，决策需谨慎。