回测 on 远思码技术实验室

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

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)，如果年化收益暴跌，说明策略严重依赖即时信息，值得警惕。

结语

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

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