做量化策略，最容易的事情其实是“想一个策略”。
找几个指标，拼几个条件：
MA 金叉买入
RSI 超卖买入
MACD 金叉买入
成交量放大确认
跌破均线卖出
代码写出来并不难。
真正麻烦的是后面的事情。
策略写完以后，要准备数据，要写回测，要改参数，要重复跑几十次甚至几百次，还要把每次结果记下来。发现问题以后再回头改代码，重新测试。
整个过程非常机械，而且特别容易乱。
跑到最后，经常会出现一个很现实的问题：
这个参数为什么是 20，不是 19？
这个条件为什么要加？
上一版到底为什么表现更好？
现在这个结果到底是真的有效，还是只是把历史行情“拟合”出来了？
这也是我最近尝试把 Hermes 接到量化策略研发流程里的主要原因。
不是让 Hermes 替我选股票，更不是让它凭空“预测行情”。
我更愿意把它当成一个负责执行策略研发工作的助手：
给它一个策略想法，它负责写代码、跑回测、整理结果、做参数实验，再把结果反馈回来。
人负责判断策略思路，Hermes 负责把大量重复工作跑完。
这套方式用起来以后，最大的变化不是策略突然变得多厉害，而是：
以前需要反复手工操作的量化实验，现在终于可以连起来了。
一、先把 Hermes 放在正确的位置
先说一个很容易搞错的问题：
Hermes 不是回测引擎。
它本身不是专门用来计算收益率、最大回撤、Sharpe Ratio 的量化框架。
Hermes 更适合干的是：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 理解任务
↓
查看项目
↓
编写/修改代码
↓
执行程序
↓
读取结果
↓
分析问题
↓
修改策略
↓
再次执行
|
而真正的回测计算，还是交给 Python 回测程序。
整个架构可以简单理解成：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| Hermes
│
┌──────────┼──────────┐
│ │ │
↓ ↓ ↓
策略设计 代码实现 结果分析
│ │ │
└──────────┼──────────┘
↓
回测程序
↓
历史数据
↓
回测结果
↓
Hermes
↓
分析 + 优化
↓
再次回测
|
这样分工比较合理。
Hermes 负责过程，回测程序负责计算。
也正因为如此，量化项目最好还是保持一个明确的工程结构，而不是把所有东西都塞进一个 Python 文件里。
二、先从一个最简单的策略开始
这次用一个很常见的趋势策略做例子：
均线 + 成交量确认。
策略假设很简单：
当短期趋势明显强于长期趋势，同时价格站在短期均线上方，并且成交量得到确认时，趋势可能更容易延续。
第一版只用三个条件。
买入条件
1
2
3
| MA20 > MA60
Close > MA20
Volume > Volume_MA20
|
三个条件同时满足，产生买入信号。
卖出条件
1
2
3
| MA20 < MA60
OR
Close < MA20
|
这里有一个很重要的原则：
第一版策略不要一开始就堆十几个指标。
先验证最基本的交易逻辑。
因为我们首先想回答的是：
这个想法本身有没有价值？
而不是：
怎么把历史收益率调到最高？
这两个问题完全不是一回事。
三、第一步不是优化，而是建立 Baseline
很多人上来就开始优化参数。
这是不太好的习惯。
正确做法应该是先把最初版本跑出来，作为基准。
也就是：
Baseline
例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 初始资金：100000
时间范围：2018-01-01 ~ 2025-12-31
Fast MA：20
Slow MA：60
总收益率：XX%
年化收益率：XX%
最大回撤：XX%
Sharpe：XX
胜率：XX%
交易次数：XX
|
以后所有调整，都跟这个结果比较。
例如：
| 策略版本 | 年化收益 | 最大回撤 | Sharpe | 胜率 | 交易次数 |
|---|
| Baseline | 18.2% | -16.5% | 1.12 | 52% | 86 |
| V2 | 21.5% | -18.9% | 1.08 | 55% | 73 |
| V3 | 20.1% | -11.2% | 1.36 | 51% | 61 |
这时候就很有意思了。
V2 的收益最高，但 V3 的 Sharpe 更高、回撤更小。
到底哪个更好？
这时候就不能只看收益率了。
四、回测最不能只盯着收益率
这是量化初学者最容易掉进去的坑。
看到：
第一反应是：
这个策略不错。
实际上完全可能是：
也就是说，账户可能曾经从：
然后才涨回来。
这种策略即使最后赚钱，也未必适合真正拿钱去跑。
所以，一个完整的回测结果至少要看：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| 总收益率
年化收益率
最大回撤
Sharpe Ratio
Sortino Ratio
胜率
平均盈利
平均亏损
盈亏比
Profit Factor
交易次数
平均持仓时间
最大连续盈利
最大连续亏损
|
再进一步，还应该看：
1
2
3
4
| 不同年份
不同市场阶段
不同股票
不同参数
|
这样才能真正知道一个策略到底是怎么赚钱的。
五、让 Hermes 先把策略写出来
比如直接给 Hermes 一个任务：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
| 你现在处理一个量化策略回测任务。
请检查当前项目结构和历史行情数据格式。
实现一个“均线趋势 + 成交量确认”策略。
买入条件：
1. MA20 > MA60
2. Close > MA20
3. Volume > Volume_MA20
三个条件同时满足时产生买入信号。
卖出条件：
1. MA20 < MA60
或者
2. Close < MA20
要求：
1. 使用 Python 实现
2. 策略代码独立成模块
3. 不修改原始行情数据
4. 增加交易成本和滑点参数
5. 输出交易记录
6. 输出资金曲线
7. 输出总收益率
8. 输出年化收益率
9. 输出最大回撤
10. 输出 Sharpe Ratio
11. 输出胜率
12. 输出 Profit Factor
13. 回测结果保存到 results/
14. 保存本次使用的策略参数
15. 保留后续继续优化的接口
先检查当前项目的数据结构，再开始实现。
|
这里有一个细节非常重要：
不要让 Hermes 只返回代码。
让它直接在项目里完成：
1
2
3
4
5
6
7
| 代码
↓
执行
↓
回测
↓
结果
|
这样效率会高很多。
六、一个比较合理的量化项目目录
实际做起来，我比较推荐把项目拆成这样：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| quant/
├── data/
│ ├── daily/
│ └── index/
│
├── strategies/
│ ├── ma_volume_v001.py
│ ├── ma_volume_v002.py
│ └── ma_volume_v003.py
│
├── backtest/
│ ├── engine.py
│ ├── metrics.py
│ └── runner.py
│
├── optimize/
│ ├── parameter_search.py
│ └── walk_forward.py
│
├── results/
│ ├── trades/
│ ├── equity/
│ ├── reports/
│ └── parameter_results.csv
│
└── config/
└── backtest.yaml
|
这样做最大的好处就是：
策略、数据、回测、优化、结果互相独立。
以后换策略的时候，不需要整个项目一起改。
七、Baseline 跑通以后，再做参数实验
现在策略里有两个最明显的参数：
很自然就会想到：
MA20 和 MA60 是最优的吗？
当然不是。
于是可以让 Hermes 自动进行参数实验。
例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| Fast MA：
5
10
15
20
25
30
Slow MA：
40
50
60
80
100
120
|
然后自动组合。
例如：
1
2
3
4
5
6
7
8
9
10
11
12
| MA5 / MA40
MA5 / MA50
MA5 / MA60
MA10 / MA40
MA10 / MA50
MA10 / MA60
MA20 / MA40
MA20 / MA50
MA20 / MA60
...
|
最后得到一个实验结果表：
| Fast MA | Slow MA | 年化收益 | 最大回撤 | Sharpe |
|---|
| 5 | 40 | 25.2% | -23.1% | 1.10 |
| 10 | 50 | 27.5% | -18.4% | 1.32 |
| 20 | 60 | 24.8% | -14.2% | 1.41 |
| 30 | 100 | 22.6% | -11.8% | 1.38 |
然后让 Hermes 继续分析。
八、参数优化最怕“挑第一名”
如果结果是：
千万不要马上定它。
真正应该看的，是：
参数稳定性
比如：
1
2
3
4
5
6
7
8
9
| MA18 / MA55 → Sharpe 1.31
MA19 / MA60 → Sharpe 1.35
MA20 / MA60 → Sharpe 1.41
MA21 / MA65 → Sharpe 1.37
MA22 / MA65 → Sharpe 1.33
|
这一片区域都不错。
这种情况通常比：
1
| MA20 / MA60 → Sharpe 1.41
|
其他附近参数突然全部掉到 0.5 更健康。
因为它说明：
这个策略对参数没有那么敏感。
反过来，如果只有一个参数点特别漂亮，周围都很差，那么这个参数就值得警惕。
可能是：
过拟合。
所以参数优化真正应该找的是：
稳定区域，而不是唯一最优值。
九、让 Hermes 专门做参数敏感性分析
这一步非常值得单独做。
可以直接给它这样的任务：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| 请对当前策略进行参数敏感性分析。
不要只寻找收益最高的参数。
请重点检查：
1. Sharpe 稳定性
2. 最大回撤
3. 年化收益
4. Profit Factor
5. 交易次数
6. 相邻参数的表现变化
重点判断：
1. 是否存在明显的稳定区域
2. 是否存在单点异常高收益
3. 参数轻微变化后是否出现明显恶化
4. 是否存在过拟合风险
最后输出：
推荐参数
推荐参数范围
稳定区域
高风险参数区域
|
这时候 Hermes 做的事情就不是简单的：
“找一个最优参数。”
而是：
“帮你看参数结构。”
这比直接跑一次网格搜索有价值很多。
十、加入交易成本，否则回测很容易失真
很多策略第一次回测特别漂亮，原因很简单：
没有真实成本。
实际交易中至少要考虑：
尤其是高频策略。
假设：
加入成本：
再加入滑点：
那么这个策略的实际生命力就比较一般。
所以 Hermes 在回测的时候，最好要求它固定带上：
并且把这两个参数写到回测配置里，而不是直接写死在策略代码里面。
例如：
1
2
| commission: 0.0003
slippage: 0.001
|
以后所有策略统一走同一套成本模型。
这样做出来的策略，横向比较才有意义。
十一、成交限制也不能忽略
做 A 股尤其要注意这一点。
如果你自己的回测引擎没有处理：
1
2
3
4
5
6
| 涨停
跌停
停牌
一字板
成交量不足
无法成交
|
那么有些回测结果实际上很难直接参考。
例如：
1
2
3
4
5
6
| 策略：
今天产生买入信号
↓
价格涨停
↓
回测程序直接按收盘价成交
|
现实里可能根本买不进去。
所以做策略回测，真正需要关注的不只是：
信号准不准。
还有：
这个信号在当时到底能不能成交。
这也是量化回测从“数学实验”走向“实际交易”必须跨过去的一步。
十二、参数优化以后，不要马上进入实盘
这里才是整个流程最关键的一步：
Walk-Forward
假设历史数据有：
1
2
3
4
5
6
7
8
| 2018
2019
2020
2021
2022
2023
2024
2025
|
错误的做法是：
1
2
3
4
5
| 2018~2025 全部拿来优化
↓
找到最优参数
↓
继续在 2018~2025 回测
|
因为你已经用完整历史数据“看过答案”了。
一个更合理的方式是：
1
2
3
4
5
6
7
8
9
10
11
| 训练：2018~2021
测试：2022
训练：2018~2022
测试：2023
训练：2018~2023
测试：2024
训练：2018~2024
测试：2025
|
也就是：
训练 → 优化 → 测试 → 滚动 → 再训练。
这样得到的是一组更加接近真实使用场景的 Out-of-Sample 结果。
十三、让 Hermes 自动跑 Walk-Forward
可以把任务直接丢给 Hermes：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| 请对当前策略执行 Walk-Forward Analysis。
要求：
1. 使用滚动时间窗口
2. 每个训练区间用于参数优化
3. 测试区间完全禁止参与参数选择
4. 每个测试区间独立记录结果
5. 汇总全部测试区间
6. 输出总收益
7. 输出年化收益
8. 输出最大回撤
9. 输出 Sharpe
10. 输出每个测试区间的表现
11. 检查策略是否出现明显的性能衰减
12. 分析不同测试区间之间的稳定性
不要因为某个测试区间表现差，
就修改测试区间的数据或参数。
|
这一步的价值很大。
因为你最终真正应该关心的是：
没有提前看到答案的数据上，这套策略还能不能工作。
十四、再把市场环境拆开看
策略整体赚钱，并不代表它任何时候都有效。
特别是趋势策略，经常会出现：
所以可以把回测拆成：
分别看：
1
2
3
4
5
| 收益
最大回撤
Sharpe
交易次数
胜率
|
比如最后发现：
| 市场环境 | 年化收益 | 最大回撤 | Sharpe |
|---|
| 牛市 | 31% | -12% | 1.80 |
| 震荡 | 5% | -15% | 0.51 |
| 熊市 | -8% | -21% | 0.20 |
那就很清楚了：
这不是一个万能策略，它更适合趋势行情。
那下一步该做什么？
未必是继续调整 MA。
更合理的研究方向可能是：
加一个市场环境过滤器。
比如：
1
2
3
4
5
6
7
8
9
10
| 指数趋势向上
AND
个股趋势向上
→ 正常交易
指数趋势向下
→ 降低仓位
指数进入极端弱势
→ 暂停新开仓
|
这就属于策略逻辑上的优化，而不是不停地“堆指标”。
十五、让 Hermes 找出策略真正的问题
这一部分，我觉得比自动写代码更有价值。
你可以直接让 Hermes 阅读交易结果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| 请不要修改策略。
先分析当前回测结果，
找出策略表现不佳的主要原因。
重点检查：
1. 利润主要来自哪些交易
2. 亏损主要发生在哪些交易
3. 是否存在少数交易贡献大部分利润
4. 是否存在连续亏损
5. 最大回撤发生在哪个时间段
6. 哪些年份表现明显偏弱
7. 哪种市场环境下表现最差
8. 参数是否敏感
9. 交易频率是否过高
10. 成本和滑点是否显著影响收益
11. 是否存在过拟合迹象
最后只给出三个最值得验证的优化方向。
每个方向说明：
为什么值得研究
准备修改什么
希望改善什么
如何验证
|
这种工作方式比：
“帮我把收益率做到最高。”
靠谱得多。
因为量化策略优化真正要解决的不是：
怎么让曲线更漂亮。
而是：
为什么这个策略有效，为什么会失效。
十六、策略优化不要只改指标，还要看仓位
很多人做策略优化，第一反应就是：
1
2
3
4
5
| 加 RSI
加 MACD
加 KDJ
加布林带
加 ATR
|
最后整个策略变成：
1
2
3
4
5
6
7
8
9
10
11
12
13
| MA
+
MACD
+
RSI
+
KDJ
+
BOLL
+
成交量
+
...
|
条件非常复杂。
但交易系统未必因此更好。
有时候真正应该优化的是：
仓位管理
比如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| 固定 100% 仓位
或者
最大 80%
或者
波动率调整仓位
或者
分批建仓
或者
分批止盈
|
同一个入场信号，换一个仓位模型，风险收益结构可能完全不同。
所以可以让 Hermes 做另外一轮实验：
1
2
3
4
| 版本 A：固定 100%
版本 B：固定 80%
版本 C：波动率动态仓位
版本 D：分批建仓
|
然后比较：
1
2
3
4
5
| 年化收益
最大回撤
Sharpe
资金使用率
连续亏损
|
很多时候，策略改进并不来自“更聪明的指标”。
而来自：
更合理的风险控制。
十七、止损也应该作为独立实验
不要一上来就随便写：
然后认为这是合理的。
止损本身也应该经过实验。
例如：
1
2
3
4
5
6
7
8
9
10
11
| 无止损
固定 3%
固定 5%
固定 8%
ATR 止损
均线止损
|
然后分别测试。
更重要的是要看：
1
2
3
4
5
6
7
8
9
10
11
| 加入止损后：
收益是否提升？
最大回撤是否下降？
Sharpe 是否提升？
交易次数是不是暴涨？
是不是把正常波动误判成止损？
|
有些止损设置虽然让回撤变小，但同时把策略原本的盈利结构破坏掉。
所以：
止损不是越严格越好。
十八、把每一次实验都记录下来
量化策略做到后面，很容易遇到一个问题：
你忘了自己为什么改它。
所以我建议每次实验都保存：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| 策略名称
版本号
参数
数据区间
股票池
交易成本
滑点
回测时间
Git Commit
总收益
年化收益
最大回撤
Sharpe
交易次数
|
例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| Strategy: MA_VOLUME
Version: V003
Fast MA: 20
Slow MA: 60
Data:
2018-01-01 ~ 2025-12-31
Commission:
0.03%
Slippage:
0.10%
Annual Return:
XX%
Max Drawdown:
XX%
Sharpe:
XX%
Trade Count:
XX
|
最好再加一项：
写清楚：
本次调整为什么做，结果发生了什么。
这样过几个月回来，你还能看懂当时做了什么。
十九、把策略版本化，而不是不停覆盖
量化代码尤其容易变成：
1
2
3
4
5
6
7
| strategy.py
strategy_new.py
strategy_new2.py
strategy_final.py
strategy_final2.py
strategy_final_ok.py
strategy_final_really_ok.py
|
最后自己都不知道哪个是真的。
建议一开始就做版本控制：
1
2
3
4
5
| strategies/
├── ma_volume_v001.py
├── ma_volume_v002.py
├── ma_volume_v003.py
└── ma_volume_v004.py
|
再配合 Git。
这样每一次回测都能对应到明确的代码版本。
最终就能回答：
这个结果到底是哪一版代码跑出来的？
这个问题非常重要。
二十、把 Hermes 做成自己的量化 Skill
前面的流程跑通几次以后，就没有必要每次重新告诉 Hermes 一遍规则。
这时候可以把整套流程固化成一个 Skill。
例如：
1
2
3
4
5
6
7
8
9
10
11
12
| quant-research/
├── SKILL.md
├── references/
│ ├── backtest.md
│ ├── metrics.md
│ ├── optimization.md
│ ├── walk-forward.md
│ └── anti-overfitting.md
└── scripts/
├── run_backtest.py
├── optimize.py
└── walk_forward.py
|
以后进入量化项目后，只需要给一个明确任务：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 回测当前策略。
先跑 Baseline。
然后进行参数敏感性分析。
再做参数优化。
加入交易成本和滑点。
最后执行 Walk-Forward。
禁止使用测试区间进行参数选择。
输出完整实验报告。
|
流程就可以标准化。
这样做一段时间后，Hermes 不再只是：
“帮我写个策略。”
而会变成：
“按我的量化研发流程执行实验。”
这才是它真正能发挥作用的地方。
二十一、完整流程其实就是这一张图
做到最后，整个策略研发过程基本可以固定下来：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| 策略想法
↓
定义交易假设
↓
选择指标
↓
实现 Baseline
↓
历史回测
↓
记录结果
↓
参数敏感性分析
↓
参数优化
↓
加入交易成本
↓
加入滑点
↓
仓位管理测试
↓
止损/止盈测试
↓
市场环境分析
↓
Walk-Forward
↓
Out-of-Sample 验证
↓
稳健性检查
↓
策略版本固化
↓
模拟盘
↓
实盘
|
Hermes 负责把这些步骤串起来。
人负责决定：
这个实验值不值得做。
二十二、真正值得警惕的是“回测过度优化”
量化里面有一句话我一直觉得特别重要：
回测成绩越漂亮，不代表策略越靠谱。
一个策略：
看起来非常漂亮。
但如果它是经过无数次：
1
2
3
4
5
6
7
8
9
10
11
| 改参数
↓
看结果
↓
再改参数
↓
看结果
↓
继续加条件
↓
再看结果
|
最后得到的。
那这个 +120% 很可能只是：
把历史行情拟合得很好。
尤其是下面这些情况，需要特别小心：
1
2
3
4
5
6
7
| 参数非常敏感
单个参数点收益异常高
换一个时间段马上失效
换一批股票马上失效
加入交易成本以后收益大幅下降
测试区间表现远低于训练区间
收益主要来自少数几笔交易
|
遇到这些情况，第一反应不应该是：
“再优化一下。”
而应该是：
是不是已经过拟合了？
二十三、还有几个回测大坑，Hermes 也不能替你解决
AI Agent 可以减少大量机械工作，但量化最基础的问题还是必须自己把关。
1. 未来函数
不能使用当时根本不知道的数据。
例如今天收盘以后才知道的数据，不能拿来参与今天收盘前的买卖判断。
2. 数据泄露
训练阶段和测试阶段必须严格隔离。
特别是做参数优化的时候。
3. 幸存者偏差
如果股票池只包含今天还活着的股票，那么历史表现很容易被高估。
4. 复权问题
前复权、后复权、真实成交价格之间一定要对应清楚。
5. 成交问题
理论上出现买入信号，不代表现实里一定可以买到。
涨跌停、停牌、成交量不足，都可能影响实际成交。
6. 交易成本
手续费、印花税、滑点不应该在最后才考虑。
二十四、Hermes 最适合扛下来的，到底是什么？
回头看整个过程，其实就很清楚了。
Hermes 最擅长的并不是：
“告诉你下一只牛股是谁。”
而是把这些事情连接起来：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| 读项目
↓
读数据
↓
写策略
↓
跑程序
↓
改 Bug
↓
重新回测
↓
整理结果
↓
做参数实验
↓
分析回撤
↓
做 Walk-Forward
↓
生成报告
|
以前这些事情全部依赖人工。
尤其是参数实验和重复回测，非常耗时间。
现在可以让 Hermes 把大量重复工作接过去。
于是人的精力可以放到更重要的地方：
1
2
3
4
5
6
7
8
9
| 为什么这个策略有效？
为什么会失效？
什么市场环境适合它？
它的风险到底是什么？
这些回测结果是否可信？
|
二十五、一个比较实用的 Hermes 工作模式
我现在更倾向于把量化策略研发分成两层。
第一层：人提出研究问题
例如：
1
2
3
4
5
6
7
| 成交量确认能不能提高均线策略的稳定性？
趋势策略在震荡行情中为什么会频繁止损？
ATR 仓位控制能不能降低最大回撤？
参数变化是否存在稳定区域？
|
第二层：Hermes 执行实验
例如：
1
2
3
4
5
6
7
8
9
10
11
| 建立 Baseline
↓
新增成交量条件
↓
回测
↓
比较
↓
记录
↓
做下一组实验
|
这样做有一个很大的好处：
不会让 Hermes 无目的地“自己优化”。
策略研究还是围绕一个明确的问题展开。
二十六、最后：别把 AI 当成“收益放大器”
这其实是整件事情里最重要的一点。
Hermes 可以让：
变成：
也可以让：
压缩成：
但它不能解决量化交易最核心的问题：
未来是不确定的。
历史数据能告诉你的，是：
在过去这样的行情里，这套规则表现如何。
它不能告诉你：
明天一定还会这样。
所以，Hermes 最合适的定位不是：
自动赚钱机器。
而是：
策略研发自动化工具
这两个定位差别非常大。
二十七、我更看重的是“策略实验能力”
如果把量化交易做成一套长期工程，最终沉淀下来的不应该只有几个策略。
而应该是一套完整的实验体系：
1
2
3
4
5
6
7
8
9
10
| 策略库
数据
回测引擎
参数优化
风险分析
Walk-Forward
实验记录
版本管理
模拟盘
实盘监控
|
Hermes 负责把这些模块串起来。
最终形成一个很简单、但非常实用的循环：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| 提出一个想法
↓
写成规则
↓
跑一次 Baseline
↓
找问题
↓
提出一个优化假设
↓
只改一个关键变量
↓
重新回测
↓
比较结果
↓
做样本外验证
↓
保留 or 淘汰
|
这样做出来的策略，至少是：
有依据、有记录、有对照、有验证。
而不是看着一条漂亮的历史收益曲线，就开始相信它。
写在最后
做量化，最费时间的往往不是写第一版策略。
而是后面的：
反复回测、不断比较、分析问题、修改参数、重新验证。
这恰恰是 Hermes 比较适合介入的地方。
它不负责替你判断市场。
也不应该替你决定把多少钱押上去。
它真正适合做的是：
把策略研发过程中那些重复、机械、需要不断执行的工作接过去。
于是整个流程就变成：
1
2
3
4
5
6
7
8
9
10
11
12
13
| 你提出想法
↓
Hermes 实现
↓
回测程序验证
↓
Hermes 分析
↓
继续实验
↓
样本外验证
↓
人工决定是否进入下一阶段
|
说到底，量化最重要的并不是找到一个“神策略”。
而是建立一套：
能够持续试错、持续验证、持续淘汰错误想法的研发流程。
对我来说，这才是：
【神算量化】指标驱动策略 + 自动回测：让 Hermes 扛下所有
真正值得玩的地方。
不是让 Hermes 帮你猜股票。
而是让它把一条策略从：
“我觉得这个指标有用”
一路推进到：
“我已经用历史数据、交易成本、参数测试和样本外验证，把它完整验证了一遍。”
