学术量化论文复现指南：从阅读到代码实现
"所有量化策略的起点，不是一行代码，而是一篇被你圈满批注的论文。"
这是许多量化研究员共同的记忆——凌晨三点，屏幕上是密密麻麻的数学符号，手里攥着打印出来的论文，咖啡已经凉透。文章读了三遍，公式推导了一遍又一遍，直到某个瞬间，"我懂了"——然后打开 IDE，发现无从下手。
学术论文与生产级策略之间，隔着一整套工程化能力：数据怎么来、回测怎么搭、参数怎么调、结果怎么验证。这篇文章不是论文导读，而是一份实操手册——手把手拆解如何把论文里的策略变成可运行的代码，并复现出与原论文可比的结果。
一、为什么你的论文复现总是失败
在开始之前，有必要正视一个事实：量化论文的复现失败率，远比你想象中高。
造成复现失败的原因通常有三类：
第一，数据不匹配。 论文用的是 1990-2010 年的美股分钟数据，你用的是 2015 年后的日线数据。交易品种、时间跨度、数据频率三者任一不同，结果都可能天差地别。
第二，实现细节缺失。 论文给出的是"因子 IC 达到 0.15"，但没说用的是等权还是市值加权、窗口期是多少、滑点假设多少、剔除停牌股还是直接用原始数据。每一个细节都影响最终结果。
第三，理解偏差。 把"市值中性"理解为"不控制市值"，把"市值因子"当成"总市值取对数"，这类概念理解上的偏差，会导致信号构造完全错误。
理解了失败的原因，复现的路径就清晰了：
- 论文精读——吃透策略逻辑和假设条件
- 数据规划——确定需要什么数据、去哪里获取
- 信号实现——把数学公式翻译成代码
- 回测框架——构建完整的回测闭环
- 结果验证——与论文结果对比，排查差异
下面逐一展开。
二、论文精读：读什么、怎么读
2.1 三遍阅读法
论文阅读不应从头读到尾，而应分三个层次：
| 轮次 | 重点 | 产出 |
|---|---|---|
| 第一遍 | 摘要 + 结论 + 图表 | 快速判断论文价值，了解核心结论 |
| 第二遍 | 方法论 + 数据说明 | 理解策略逻辑，确定需要的数据类型 |
| 第三遍 | 公式推导 + 附录 | 验证对核心算法的理解是否正确 |
第一遍只需要 15-20 分钟，目的是判断"这篇论文值不值得我花时间复现"。如果结论平庸、方法论不清晰，直接跳过。
第二遍是核心。这一遍要重点关注：
- 数据来源和时间跨度
- 因子构造方法
- 样本划分方式（训练/测试、滚动窗口）
- 风险控制和归因方法
第三遍针对代码实现。逐行推导核心公式，标注出每一个需要确定的参数。
2.2 关键信息的提取清单
复现论文前，必须从原文提取以下信息（以因子类论文为例）：
□ 因子名称和定义（数学表达式）
□ 数据来源（哪个数据库、时间跨度、频率）
□ 样本筛选条件（行业、市值、流动性门槛）
□ 权重计算方式（等权、市值加权、风险加权）
□ 回测参数（滑点、佣金、冲击成本）
□ 对比基准
□ 核心指标（IC、IR、夏普、最大回撤）
□ 附录中的补充说明
如果论文没有提供数据来源或参数设置，这通常意味着两个可能：要么论文本身不够严谨，要么关键信息藏在附录里——务必下载附录通读一遍。
三、数据获取：构建论文所需的数据环境
3.1 数据需求分析
根据论文提取的信息，首先明确你需要什么类型的数据：
| 数据类型 | 用途 | TickDB 支持情况 |
|---|---|---|
| 历史 K 线 | 日频/分钟频因子计算 | 美股 10 年级别，支持多时间周期 |
| 实时行情 | 实盘信号触发 | WebSocket 推送，<100ms |
| 订单簿深度 | 流动性分析 | depth 频道（港股 10 档） |
| 逐笔成交 | 订单流分析 | 港股/数字货币支持 |
以一个典型的多因子选股策略为例，需要的数据可能包括：
- 日线 OHLCV（收盘价、成交量）
- 市值数据（总股本 × 收盘价）
- 财务数据（PE、ROE、营收增速）
- 行业分类
3.2 TickDB 数据获取实战
下面展示如何用 TickDB API 获取论文复现所需的历史 K 线数据。
import os
import time
import requests
from typing import Optional, List, Dict
class TickDBDataFetcher:
"""TickDB 历史数据获取器 - 适用于论文复现场景"""
BASE_URL = "https://api.tickdb.ai/v1"
def __init__(self, api_key: Optional[str] = None):
self.api_key = api_key or os.environ.get("TICKDB_API_KEY")
if not self.api_key:
raise ValueError("API Key 未设置，请设置环境变量 TICKDB_API_KEY")
self.headers = {"X-API-Key": self.api_key}
def get_klines(
self,
symbol: str,
interval: str = "1d",
start_time: Optional[int] = None,
end_time: Optional[int] = None,
limit: int = 1000
) -> List[Dict]:
"""
获取历史 K 线数据
Args:
symbol: 交易品种，如 "AAPL.US"
interval: K 线周期，支持 1m/5m/15m/1h/4h/1d/1w
start_time: 开始时间戳（毫秒）
end_time: 结束时间戳（毫秒）
limit: 单次最大返回条数（最大 1000）
"""
params = {
"symbol": symbol,
"interval": interval,
"limit": limit
}
if start_time:
params["start"] = start_time
if end_time:
params["end"] = end_time
# ⚠️ 生产环境建议增加本地缓存逻辑，避免重复请求
retry_count = 0
max_retries = 3
while retry_count < max_retries:
try:
response = requests.get(
f"{self.BASE_URL}/market/kline",
headers=self.headers,
params=params,
timeout=(3.05, 10) # 连接超时 3.05s，读取超时 10s
)
if response.status_code == 200:
data = response.json()
if data.get("code") == 0:
return data.get("data", [])
elif data.get("code") == 3001:
# 请求频率超限，读取 Retry-After
retry_after = int(response.headers.get("Retry-After", 5))
wait_time = retry_after + 1 # 多加 1 秒缓冲
print(f"触发限频，等待 {wait_time} 秒")
time.sleep(wait_time)
retry_count += 1
continue
else:
raise RuntimeError(f"API 错误: {data.get('code')} - {data.get('message')}")
else:
raise RuntimeError(f"HTTP 错误: {response.status_code}")
except requests.exceptions.Timeout:
retry_count += 1
wait_time = min(2 ** retry_count, 30) # 指数退避，最大 30 秒
print(f"请求超时，第 {retry_count} 次重试，等待 {wait_time} 秒")
time.sleep(wait_time)
raise RuntimeError(f"重试 {max_retries} 次后仍失败")
def batch_get_klines(
self,
symbols: List[str],
interval: str = "1d",
start_time: Optional[int] = None,
end_time: Optional[int] = None
) -> Dict[str, List[Dict]]:
"""批量获取多个标的历史 K 线（带频率控制）"""
results = {}
for i, symbol in enumerate(symbols):
try:
results[symbol] = self.get_klines(
symbol=symbol,
interval=interval,
start_time=start_time,
end_time=end_time
)
print(f"[{i+1}/{len(symbols)}] {symbol} 数据获取成功")
except Exception as e:
print(f"[{i+1}/{len(symbols)}] {symbol} 获取失败: {e}")
results[symbol] = []
# ⚠️ 两次请求间隔至少 100ms，避免触发限频
if i < len(symbols) - 1:
time.sleep(0.15)
return results
# 使用示例：获取苹果公司 2023-2024 年的日线数据
if __name__ == "__main__":
fetcher = TickDBDataFetcher()
# 时间戳（毫秒）
start_ts = int(pd.Timestamp("2023-01-01").timestamp() * 1000)
end_ts = int(pd.Timestamp("2024-12-31").timestamp() * 1000)
klines = fetcher.get_klines(
symbol="AAPL.US",
interval="1d",
start_time=start_ts,
end_time=end_ts,
limit=500 # 两年日线约 500 条
)
print(f"获取到 {len(klines)} 条 K 线数据")
if klines:
print(f"最新一条: {klines[-1]}")
工程提示：批量获取多只股票数据时，必须加入请求间隔（建议 ≥100ms）和限频处理逻辑。TickDB 对高频请求返回 3001 错误码，正确读取
Retry-After头并等待，是保证数据完整性的关键。
3.3 数据质量验证
获取数据后，不要急于开始回测。先做以下验证：
import pandas as pd
import numpy as np
def validate_kline_data(df: pd.DataFrame, symbol: str) -> bool:
"""验证 K 线数据质量"""
# 1. 检查空值
assert df.notna().all().all(), f"{symbol} 存在空值"
# 2. 检查时间连续性（交易日应该连续）
df["timestamp"] = pd.to_datetime(df["t"], unit="ms")
df = df.sort_values("timestamp")
expected_freq = {"1d": "B", "1h": "H"}[df["interval"].iloc[0]]
# 3. 检查价格合理性（收盘价应在日内高低之间）
assert (df["c"] <= df["h"]).all() and (df["c"] >= df["l"]).all(), \
f"{symbol} 收盘价超出日内范围"
# 4. 检查成交量（应 >= 0）
assert (df["v"] >= 0).all(), f"{symbol} 存在负成交量"
print(f"✅ {symbol} 数据验证通过")
return True
四、信号实现：从公式到代码
4.1 因子构造的通用模式
学术论文中的因子，通常可以归纳为以下几种构造模式：
| 模式 | 描述 | 示例 |
|---|---|---|
| 截面单期 | 基于当期数据的静态计算 | PE、PB、市值 |
| 时间序列滚动 | 基于滚动窗口的统计量 | 均线、波动率、趋势强度 |
| 差分/变化率 | 关注变化的量而非绝对值 | 营收增速、换手率变化 |
| 横截面排名 | 在截面上计算相对位置 | 市值排名、IC 值 |
| 复合因子 | 多因子加权组合 | 猫狗混因子 |
无论哪种模式，实现的核心都是：明确定义"对谁、什么时间、怎么算"。
4.2 案例：动量因子的实现
假设论文描述了一个"12-1 个月动量因子"——过去 12 个月累计收益，剔除最近 1 个月（避免短期反转干扰）。
import pandas as pd
import numpy as np
class MomentumFactor:
"""动量因子构造器"""
def __init__(self, lookback_period: int = 252,
skip_period: int = 21): # 252 交易日 ≈ 12 个月
"""
Args:
lookback_period: 回看期（交易日），默认 252 天
skip_period: 剔除最近期（交易日），默认 21 天 ≈ 1 个月
"""
self.lookback = lookback_period
self.skip = skip_period
def calculate(self, price_data: pd.DataFrame) -> pd.Series:
"""
计算动量因子
Args:
price_data: DataFrame，必须包含 'symbol' 和 'close' 列
"""
# 剔除最近 N 日，计算累计收益率
# 公式: Momentum = (P_t-1-skip / P_t-1-lookback) - 1
result = {}
for symbol in price_data["symbol"].unique():
stock_data = price_data[price_data["symbol"] == symbol].copy()
stock_data = stock_data.sort_values("timestamp")
prices = stock_data["close"].values
# 滑动窗口计算
momentum = []
for i in range(len(prices)):
if i < self.lookback:
momentum.append(np.nan)
continue
end_idx = i - self.skip # 剔除最近 skip 天
start_idx = end_idx - self.lookback
if start_idx < 0:
momentum.append(np.nan)
continue
ret = (prices[end_idx] / prices[start_idx]) - 1
momentum.append(ret)
for idx, val in zip(stock_data.index, momentum):
result[(symbol, idx)] = val
return pd.Series(result)
4.3 参数敏感度测试
论文复现时，必须测试关键参数在不同取值下的表现，而不是直接采用论文给定的参数：
def parameter_sensitivity(
factor_calculator,
price_data: pd.DataFrame,
param_name: str,
param_range: list,
metric_func: callable
) -> pd.DataFrame:
"""
参数敏感度分析
Args:
factor_calculator: 因子计算器实例
price_data: 价格数据
param_name: 参数名
param_range: 参数取值范围
metric_func: 评估函数，如 IC 函数
"""
results = []
for param_value in param_range:
setattr(factor_calculator, param_name, param_value)
factor_values = factor_calculator.calculate(price_data)
metric = metric_func(factor_values)
results.append({"param": param_value, "metric": metric})
return pd.DataFrame(results)
# 示例：测试回看期对 IC 的影响
sensitivity_df = parameter_sensitivity(
factor_calculator=MomentumFactor(),
price_data=price_df,
param_name="lookback_period",
param_range=[126, 189, 252, 315, 378], # 6 个月到 18 个月
metric_func=lambda f: f.autocorr() # 用自相关系数作为替代指标
)
五、回测框架：构建可信赖的验证环境
5.1 回测框架的核心组件
一个合格的回测框架，需要包含以下组件：
| 组件 | 作用 | 常见陷阱 |
|---|---|---|
| 数据层 | 提供清洗后的历史数据 | 前视偏差、幸存者偏差 |
| 信号层 | 生成交易信号 | 信号泄露、参数过拟合 |
| 组合层 | 构建持仓组合 | 权重过于集中、流动性不足 |
| 交易层 | 模拟订单执行 | 滑点假设不现实 |
| 风控层 | 仓位控制和止损 | 风控规则被绕过 |
| 绩效层 | 计算评估指标 | 年化收益虚高 |
5.2 事件驱动回测模板
对于股票策略，推荐使用事件驱动回测而非向量化的固定周期回测：
import pandas as pd
from dataclasses import dataclass
from typing import Dict, List, Optional
from datetime import datetime
@dataclass
class Position:
"""持仓"""
symbol: str
quantity: float
entry_price: float
entry_date: pd.Timestamp
@dataclass
class Signal:
"""交易信号"""
symbol: str
action: str # "buy" / "sell" / "hold"
strength: float # 信号强度 [0, 1]
class BacktestEngine:
"""事件驱动回测引擎"""
def __init__(
self,
initial_capital: float = 1_000_000,
commission_rate: float = 0.001,
slippage_rate: float = 0.0005,
max_position_size: float = 0.1 # 单只最大仓位 10%
):
self.initial_capital = initial_capital
self.commission_rate = commission_rate
self.slippage_rate = slippage_rate
self.max_position_size = max_position_size
self.cash = initial_capital
self.positions: Dict[str, Position] = {}
self.portfolio_value = initial_capital
self.trade_log: List[dict] = []
self.equity_curve: List[dict] = []
def generate_signals(self, date: pd.Timestamp, data: pd.DataFrame) -> List[Signal]:
"""子类重写：实现具体的信号生成逻辑"""
raise NotImplementedError
def calculate_position_size(self, signal: Signal, price: float) -> float:
"""计算仓位"""
# 基础仓位 = 账户净值 × 信号强度 × 最大仓位比例
base_value = self.portfolio_value * self.max_position_size
target_value = base_value * signal.strength
shares = int(target_value / price)
return max(0, shares)
def execute_trade(
self,
signal: Signal,
price: float,
date: pd.Timestamp
):
"""执行交易"""
action = signal.action
symbol = signal.symbol
if action == "buy" and symbol not in self.positions:
# 买入开仓
quantity = self.calculate_position_size(signal, price)
if quantity <= 0:
return
cost = quantity * price * (1 + self.slippage_rate + self.commission_rate)
if cost > self.cash:
# 钱不够，按最大可买数量下单
quantity = int(self.cash / (price * (1 + self.slippage_rate + self.commission_rate)))
if quantity <= 0:
return
cost = quantity * price * (1 + self.slippage_rate + self.commission_rate)
self.cash -= cost
self.positions[symbol] = Position(
symbol=symbol,
quantity=quantity,
entry_price=price,
entry_date=date
)
self.trade_log.append({
"date": date,
"symbol": symbol,
"action": "buy",
"quantity": quantity,
"price": price,
"cost": cost
})
elif action == "sell" and symbol in self.positions:
# 卖出平仓
position = self.positions[symbol]
proceeds = position.quantity * price * (1 - self.slippage_rate - self.commission_rate)
self.cash += proceeds
del self.positions[symbol]
self.trade_log.append({
"date": date,
"symbol": symbol,
"action": "sell",
"quantity": position.quantity,
"price": price,
"proceeds": proceeds,
"pnl": proceeds - position.quantity * position.entry_price
})
def update_equity(self, date: pd.Timestamp, prices: pd.Series):
"""更新净值"""
position_value = sum(
pos.quantity * prices.get(pos.symbol, pos.entry_price)
for pos in self.positions.values()
)
self.portfolio_value = self.cash + position_value
self.equity_curve.append({
"date": date,
"cash": self.cash,
"position_value": position_value,
"total_value": self.portfolio_value
})
def run(self, data: pd.DataFrame, factor_calculator):
"""运行回测"""
dates = sorted(data["timestamp"].unique())
for i, date in enumerate(dates):
# 1. 生成信号
date_data = data[data["timestamp"] == date]
signals = self.generate_signals(date, date_data, factor_calculator)
# 2. 获取收盘价
prices = date_data.set_index("symbol")["close"]
# 3. 执行交易
for signal in signals:
self.execute_trade(signal, prices.get(signal.symbol), date)
# 4. 更新净值
self.update_equity(date, prices)
def get_performance_report(self) -> dict:
"""生成绩效报告"""
equity_df = pd.DataFrame(self.equity_curve)
equity_df["returns"] = equity_df["total_value"].pct_change()
total_return = (self.portfolio_value / self.initial_capital - 1) * 100
annual_return = ((self.portfolio_value / self.initial_capital) ** (252 / len(equity_df)) - 1) * 100
# 年化波动率
annual_vol = equity_df["returns"].std() * np.sqrt(252) * 100
# 夏普比率（假设无风险利率 3%）
risk_free_rate = 0.03
sharpe = (annual_return / 100 - risk_free_rate) / (annual_vol / 100)
# 最大回撤
cumulative = (1 + equity_df["returns"]).cumprod()
rolling_max = cumulative.cummax()
drawdown = (cumulative - rolling_max) / rolling_max
max_drawdown = drawdown.min() * 100
# 胜率
trades_df = pd.DataFrame(self.trade_log)
winning_trades = trades_df[trades_df["pnl"] > 0] if "pnl" in trades_df.columns else pd.DataFrame()
win_rate = len(winning_trades) / len(trades_df) * 100 if len(trades_df) > 0 else 0
return {
"总收益率": f"{total_return:.2f}%",
"年化收益率": f"{annual_return:.2f}%",
"年化波动率": f"{annual_vol:.2f}%",
"夏普比率": f"{sharpe:.2f}",
"最大回撤": f"{max_drawdown:.2f}%",
"交易次数": len(trades_df),
"胜率": f"{win_rate:.1f}%"
}
六、结果对比：论文 vs 复现
6.1 对比指标体系
复现结果与论文对比时，需要逐项对比以下指标：
| 指标类别 | 具体指标 | 对比方法 |
|---|---|---|
| 因子指标 | IC、ICIR、分组回测收益 | 数值差异 < 10% 可接受 |
| 风险收益 | 夏普比率、最大回撤、年化收益 | 方向一致 + 量级相近 |
| 交易统计 | 换手率、交易次数、胜率 | 量级相近 |
| 时间序列 | 收益曲线走势 | 相关性 > 0.8 |
6.2 差异排查清单
如果对比结果与论文差异较大，按以下顺序排查：
□ 数据问题
├─ 时间范围是否一致？
├─ 频率是否一致（日线 vs 分钟线）？
└─ 是否包含红利再投资、拆股调整？
□ 样本问题
├─ 剔除条件是否一致（停牌、ST、退市）？
├─ 行业划分标准是否一致？
└─ 市值门槛是否一致？
□ 因子构造问题
├─ 参数取值是否完全一致？
├─ 加权方式是否一致？
└─ 中性化处理是否一致？
□ 回测问题
├─ 滑点假设是否一致？
├─ 佣金费率是否一致？
└─ 仓位控制是否一致？
6.3 复现结果记录模板
class ReplicationReport:
"""论文复现报告"""
def __init__(self, paper_info: dict):
self.paper_info = paper_info # 论文基本信息
self.replication_results = {}
self.difference_analysis = []
def add_metric(self, metric_name: str, paper_value: float,
replication_value: float, tolerance: float = 0.1):
"""添加指标对比"""
diff_pct = abs(replication_value - paper_value) / abs(paper_value)
status = "✅ 通过" if diff_pct <= tolerance else "❌ 需排查"
self.replication_results[metric_name] = {
"论文结果": paper_value,
"复现结果": replication_value,
"差异": f"{diff_pct*100:.1f}%",
"状态": status
}
if status == "❌ 需排查":
self.difference_analysis.append({
"指标": metric_name,
"论文": paper_value,
"复现": replication_value,
"差异原因": "待分析"
})
def generate_summary(self) -> str:
"""生成报告摘要"""
passed = sum(1 for v in self.replication_results.values() if "✅" in v["状态"])
total = len(self.replication_results)
summary = f"""
## 论文复现报告
**论文**: {self.paper_info.get('title', 'N/A')}
**作者**: {self.paper_info.get('authors', 'N/A')}
**年份**: {self.paper_info.get('year', 'N/A')}
### 指标对比
| 指标 | 论文结果 | 复现结果 | 差异 | 状态 |
|------|---------|---------|------|------|
"""
for name, values in self.replication_results.items():
summary += f"| {name} | {values['论文结果']} | {values['复现结果']} | {values['差异']} | {values['状态']} |\n"
summary += f"""
### 总体评价
通过率: {passed}/{total} ({passed/total*100:.0f}%)
"""
if self.difference_analysis:
summary += "### 差异分析\n\n"
for item in self.difference_analysis:
summary += f"- **{item['指标']}**: 需进一步排查\n"
return summary
七、实战案例：Fama-French 三因子模型的复现
7.1 模型回顾
Fama-French (1993) 三因子模型认为股票收益可以由三个因子解释：
- 市场因子 (MKT)：市场超额收益
- 规模因子 (SMB)：小市值股票减大市值股票收益
- 价值因子 (HML)：高账面市值比股票减低账面市值比股票收益
7.2 数据获取
# 完整代码示例：获取 A 股三因子模型数据
import pandas as pd
# 注意：这里展示完整的数据获取逻辑
fetcher = TickDBDataFetcher()
# 1. 获取股票列表
symbols_response = requests.get(
"https://api.tickdb.ai/v1/symbols/available",
headers=fetcher.headers
)
available_symbols = symbols_response.json().get("data", [])
# 筛选 A 股主要股票（示例）
a_share_symbols = [s for s in available_symbols if s.endswith(".SH") or s.endswith(".SZ")][:100]
# 2. 获取日线数据
start_ts = int(pd.Timestamp("2020-01-01").timestamp() * 1000)
end_ts = int(pd.Timestamp("2024-12-31").timestamp() * 1000)
price_data = fetcher.batch_get_klines(
symbols=a_share_symbols,
interval="1d",
start_time=start_ts,
end_time=end_ts
)
# 3. 转换为 DataFrame
df = pd.DataFrame([
{"symbol": s, "timestamp": k["t"], "open": k["o"],
"high": k["h"], "low": k["l"], "close": k["c"], "volume": k["v"]}
for s, klines in price_data.items()
for k in klines
])
7.3 因子构造与回归
def calculate_fama_french_regression(
stock_returns: pd.Series,
market_returns: pd.Series,
smb_returns: pd.Series,
hml_returns: pd.Series
) -> dict:
"""
计算三因子回归
R_i - R_f = α + β₁(MKT) + β₂(SMB) + β₃(HML) + ε
"""
import statsmodels.api as sm
# 合并数据
data = pd.DataFrame({
"stock": stock_returns,
"mkt": market_returns,
"smb": smb_returns,
"hml": hml_returns
}).dropna()
if len(data) < 30:
return {"error": "样本量不足"}
# OLS 回归
X = data[["mkt", "smb", "hml"]]
X = sm.add_constant(X)
y = data["stock"]
model = sm.OLS(y, X).fit()
return {
"alpha": model.params["const"],
"beta_mkt": model.params["mkt"],
"beta_smb": model.params["smb"],
"beta_hml": model.params["hml"],
"r_squared": model.rsquared,
"n_obs": len(data)
}
八、总结：复现能力的本质
回到开篇的问题：为什么你的论文复现总是失败？
不是因为你不够聪明，而是因为论文只展示结论，不展示过程。真正的量化研究能力，不在于读懂了多少篇论文，而在于：
- 快速识别论文核心价值——判断这篇论文值得不值得复现
- 精确还原数据环境——知道去哪里、用什么频率、怎么清洗
- 严格遵循工程规范——回测不是"跑一下看看"，而是系统性验证
- 建立差异排查框架——知道结果不对时，从哪里开始排查
这四种能力，都不是读论文能读出来的，必须靠大量的实操复现来积累。
下一阶段，建议从以下选题开始练习：
- 入门级：复现一个经典的技术指标策略（均线交叉、布林带）
- 进阶级：复现一篇近 5 年的因子论文（Fama-French、动量、价值）
- 挑战级：复现一篇包含复杂风控或组合优化的论文（CVaR、Black-Litterman）
每一个完整的复现周期，都是一次从"理解"到"验证"的闭环。当你能独立复现 10 篇论文并达到论文结果的 80% 以上，你的量化研究能力就已经超越了 90% 的市场参与者。
下一步行动
如果你是量化新人，建议从 Fama-French 三因子开始：
- 阅读原文（Fama & French, 1993, Journal of Financial Economics）
- 用 TickDB 获取股票历史数据
- 按照本文框架完成一次完整复现
- 对比 Kenneth French 官网公布的实际因子收益
如果你已有一定基础：
尝试复现近 3 年的顶刊论文，关注数据来源标注是否完整——这是判断论文可复现性的关键信号。
如果你希望获取更多论文复现案例：
访问 tickdb.ai 查看行业研究栏目，定期更新基于真实数据的策略复现与验证。
本文不构成任何投资建议。论文复现的结果仅供参考，市场有风险，投资需谨慎。