diff --git a/quantum_ashare_market_timing/README.md b/quantum_ashare_market_timing/README.md new file mode 100644 index 00000000..a74c2dfb --- /dev/null +++ b/quantum_ashare_market_timing/README.md @@ -0,0 +1,1004 @@ +# 量子增强A股选股系统 — 量子核SVM市场择时 + +> **创新应用** | 基于QPanda3量子核SVM的中国A股市场择时系统 +> +> 作者: 周勋洪 (中国电信资阳分公司) +> 日期: 2026-08-04 +> 赛事: 2026年CCF量子计算编程挑战赛 — 本源杯·开源创新赛道 + +--- + +## 一、项目概述 + +本项目将**量子核支持向量机(QSVM)**应用于中国A股市场的**择时决策**(Market Timing)，通过QPanda3量子编程框架计算量子核矩阵，预测每个交易日"是否适合交易"，并通过**NOOP机制**(No-Operation)过滤低质量交易日，显著提升ZP跳空策略的投资收益和风险表现。 + +### 核心创新 + +1. **首次将量子核SVM应用于A股市场择时**: 不是预测个股涨跌(噪声太大)，而是预测市场环境好坏(标签更干净) +2. **NOOP市场择时机制**: 量子模型预测"不适合交易"的日子→跳过所有买入信号，类似"量子电路保险丝" +3. **个股级量子筛选**: 从日级NOOP升级为个股级判定，对每笔信号独立预测"好票/坏票"，GAP2.0下Q/L=2.52x +4. **分层反转模式**: 信号密集→量子优势在个股级(Q/L=2.52x)；信号稀疏→优势在日级(Q/L=2.29x) +5. **Walk-forward扩展窗口验证**: 4年测试期(2022-06-01~2026-07-07)，9段6个月refit，零前视偏差 +6. **标签降噪优化**: 按日聚合交易信号，用0.5%收益阈值过滤噪音日，使模型在4年长周期下仍可学习 +7. **量子核显著优于经典方法**: 日级NOOP量子+126.12%/Calmar 5.15，远超经典LogReg的+35.88%/0.64 +8. **系统化4阶段优化**: 特征工程→电路/超参数→标签工程→训练策略，穷尽扫描确认全局最优配置 + +### 为什么选择量子核？ + +个股盈利预测(单笔交易是否赚钱)的标签噪声极大，所有模型(量子和经典)的AUC≈0.50。但我们发现： + +- **按日聚合标签降噪**: 跨信号平均显著降噪，使分类器可学习 +- **0.5%收益阈值**: 过滤"微涨噪音日"，只标记有意义的上涨日为正样本(正样本率41.2%) +- **量子核在NOOP机制上有效**: 尽管分类准确率仅57.8%，但量子模型对低概率日的过滤将基线-76.34%翻转为+126.12% +- **量子优势显著**: 量子NOOP(+126.12%, Calmar 5.15)远超经典LogReg(+35.88%, 0.64)，3.5倍收益优势，证明量子核捕获了经典方法无法获取的市场模式 + +--- + +## 二、技术架构 + +``` +┌──────────────────────────────────────────────────────────┐ +│ 量子增强A股选股系统 (Walk-Forward) │ +├──────────────────────────────────────────────────────────┤ +│ │ +│ ┌──────────┐ ┌──────────────┐ ┌───────────┐ │ +│ │ 市场数据 │───→│ 信号加载 │───→│ 日聚合标签 │ │ +│ │ (上证指数 │ │ (pickle文件 │ │ (好/坏天) │ │ +│ │ + 个股) │ │ 7042信号) │ │ th=0.5% │ │ +│ └──────────┘ └──────────────┘ └─────┬─────┘ │ +│ │ │ +│ ┌────────────────────────┘ │ +│ ▼ │ +│ ┌──────────────────────────────────────────────────┐ │ +│ │ 11维市场特征 (T-1口径, 零前视) │ │ +│ │ 基础6维: bias20/ret_5d/vol_ratio/rsi_5 │ │ +│ │ /ma_align/range_5d │ │ +│ │ 扩展5维: ret_20d/vol_ratio_20d/ma_trend │ │ +│ │ /vol_rank_60/rsi_14 │ │ +│ └──────────────────────┬───────────────────────────┘ │ +│ │ │ +│ ┌──────────┴──────────┐ │ +│ │ SelectKBest→6维 │ │ +│ │ (per-segment动态) │ │ +│ └──────────┬──────────┘ │ +│ │ │ +│ ┌────────────────────┼────────────────────┐ │ +│ │ Walk-Forward 扩展窗口验证 (9段×6月refit) │ │ +│ │ ┌────────────┐ ┌────────────┐ │ │ +│ │ │ 量子核SVM │ │ 经典LogReg │ │ │ +│ │ │ (QPanda3) │ │ │ │ │ +│ │ │ 6 qubits │ │ 11维全特征 │ │ │ +│ │ │ n_reps=1 │ │ │ │ │ +│ │ └─────┬──────┘ └─────┬──────┘ │ │ +│ └────────┼───────────────┼────────────────┘ │ +│ ▼ ▼ │ +│ ┌────────────────────────────┐ │ +│ │ NOOP择时回测 │ │ +│ │ (100K / 5仓 / 3天) │ │ +│ │ + 阈值扫描优化 │ │ +│ └────────────────────────────┘ │ +│ │ +└──────────────────────────────────────────────────────────┘ +``` + +--- + +## 三、量子核计算原理 + +### 3.1 量子态编码 + +使用**AngleEncoding**将6维经典特征(从11维经SelectKBest筛选)编码到6个量子比特： + +``` +|ψ(x)⟩ = U(x)|0⟩⁶ + +U(x) = H⊗⁶ · ∏ RZ(2xⱼ) (重复n_reps=1次) +``` + +- `H`: Hadamard门 → 创建均匀叠加态 +- `RZ(2xⱼ)`: Z轴旋转门 → 将特征值编码到量子相位 +- `n_reps=1`: 仅1次重复，避免过度纠缠引入噪音（阶段2扫描发现n_reps=1碾压n_reps=2/3） + +### 3.2 量子核矩阵 + +量子核定义为两个量子态的内积模平方： + +``` +K(xᵢ, xⱼ) = |⟨ψ(xᵢ)|ψ(xⱼ)⟩|² = |ψᵢ† · ψⱼ|² +``` + +利用QPanda3的 `QCircuit.matrix()` API： +1. `matrix()` 返回酉矩阵 U (shape: 2ⁿ × 2ⁿ) +2. 取第一列即为 |ψ(x)⟩ = U|0...0⟩ +3. 计算所有样本对的态矢量内积 → 量子核矩阵 + +### 3.3 量子核SVM + +将量子核矩阵作为预计算核(precomputed kernel)输入sklearn的SVC： + +```python +from sklearn.svm import SVC + +# 计算量子核矩阵 +K_train = quantum_kernel_matrix(train_states) # N×N +K_test = quantum_kernel_matrix(train_states, test_states) # M×N + +# 训练SVM +qsvm = SVC(kernel='precomputed', C=0.1, probability=True) +qsvm.fit(K_train, y_train) + +# 预测 +y_prob = qsvm.predict_proba(K_test)[:, 1] +``` + +### 3.4 NOOP机制 + +``` +对于每个交易日 T: + 如果 prob(好天) < threshold: + NOOP — 跳过当日所有买入信号 + 否则: + 正常执行买入 + 持仓卖出不受NOOP影响 +``` + +### 3.5 Walk-Forward扩展窗口验证 + +``` +训练窗口: 只增不减 (扩展窗口) + ┌───────────────────────────────────────────────┐ +train │███████████████████ │ Seg1 + ├──────────────────┼───────────────────┐ │ + │███████████████████│ │ │ + ├───────────────────┼──────────────────┤ │ Seg2 + │██████████████████████████████ │ │ + ├──────────────────────────────────────┼───────┤ │ Seg3 + │ ... 每6个月refit ... │ │ + └──────────────────────────────────────┘ │ + test │ +``` + +- **零前视偏差**: 每段仅用历史数据训练，StandardScaler仅在训练窗口fit +- **9段refit**: 2022-06-01起每6个月重新训练模型 +- **扩展窗口**: 训练数据只增不减，模型随数据增长而改进 + +--- + +## 四、市场特征工程 + +### 4.1 11维市场特征(全部T-1口径, 次日09:25前100%可见, **零前视偏差**) + +**基础6维(上证指数)**: + +| 特征 | 公式 | 含义 | +|------|------|------| +| `bias20` | (close-MA20)/MA20×100 | 均值回归偏离度，BIAS_Hi13保险丝的核心 | +| `ret_5d` | close/close₋₅-1 | 5日涨幅%，短期动量 | +| `vol_ratio` | volume/MA5(volume) | 量比，量能变化 | +| `rsi_5` | 100-100/(1+RS) | 5日RSI，超买超卖 | +| `ma_align` | (MA5-MA10)/MA10×100 | 短期趋势方向 | +| `range_5d` | (high₅-low₅)/close×100 | 5日振幅，波动率 | + +**扩展5维(上证指数)**: + +| 特征 | 公式 | 含义 | +|------|------|------| +| `ret_20d` | close/close₋₂₀-1 | 20日涨幅%，中期动量 | +| `vol_ratio_20d` | volume/MA20(volume) | 20日量比 | +| `ma_trend` | (MA20-MA60)/MA60×100 | 中长期趋势斜率 | +| `vol_rank_60` | volume在60日中的百分位 | 成交量历史分位 | +| `rsi_14` | 14日RSI | 标准RSI超买超卖指标 | + +### 4.2 SelectKBest动态特征选择 + +由于量子比特数限制为6，当特征维度>6时，使用`SelectKBest(f_classif)`在每个训练段内独立选择最重要的6个特征： + +```python +from sklearn.feature_selection import SelectKBest, f_classif + +selector = SelectKBest(f_classif, k=6) +X_train_selected = selector.fit_transform(X_train, y_train) +X_test_selected = selector.transform(X_test) +``` + +**高频选中特征**(9段中≥5段选中): `bias20`(7/9), `ret_5d`(7/9), `rsi_5`(7/9), `ma_align`(5/9), `vol_rank_60`(6/9), `rsi_14`(6/9) + +> 阶段1实验表明：11维+SelectKBest→6q是最优配置，优于固定6维(+17.20%)、扩展16维(+10.01%)和8qubit固定8维(+19.67%) + +--- + +## 五、回测结果 + +### 5.1 主结果 — Walk-Forward 4年验证 + +**测试期**: 2022-06-02 ~ 2026-07-07 (871个交易日, 9段6个月refit) +**初始资金**: 100,000元 | **最大持仓**: 5仓 | **持仓天数**: 3天 +**标签阈值**: 日均收益 > 0.5% +**量子配置**: AngleEncoding, 6 qubits, n_reps=1, C=0.1, scale=π +**数据**: 2000只A股, 上证指数, 2022-01-04~2026-07-31 + +| 策略 | 终值(元) | 收益 | 交易笔数 | 胜率 | 最大回撤 | Calmar | +|------|---------|------|---------|------|---------|--------| +| 基线(无过滤) | 23,658 | **-76.34%** | 1,484 | 40.7% | -82.2% | 0.93 | +| **量子NOOP(th=0.40)** | **226,123** | **+126.12%** | **506** | **45.6%** | **-24.5%** | **5.15** | +| 经典LogReg(th=0.35) | 135,878 | +35.88% | 931 | 43.9% | -56.0% | 0.64 | +| 集成AND门控(q0.40+l0.35) | 160,716 | +60.72% | 338 | 46.5% | -22.4% | 2.71 | + +### 5.2 关键发现 + +1. **NOOP机制极其有效**: 量子模型将基线从-76.34%翻转为+126.12% (+202.46pp) +2. **量子核SVM全场最优**: 收益+126.12%和Calmar 5.15均为所有策略中最高 +3. **量子vs经典显著优势**: 量子+126.12% vs 经典LogReg +35.88% (+90.24pp差距)，量子核3.5倍于经典收益 +4. **NOOP过滤频率**: 量子模型过滤79.8%的交易日(保留20.2%高质量交易日)，精准过滤低胜率日 +5. **Walk-forward稳健性**: 9段独立refit，量子模型平均准确率57.8%，全程保持正收益 +6. **回撤控制**: 量子NOOP将最大回撤从-82.2%降至-24.5%(降低57.7pp)，Calmar从0.93提升至5.15 + +### 5.3 NOOP阈值扫描 + +对量子模型和经典LogReg各扫描5个NOOP阈值(0.30~0.50)： + +| 模型 | 阈值 | NOOP% | 终值(元) | 收益% | 交易 | 胜率% | 回撤% | Calmar | +|------|------|-------|---------|-------|------|-------|-------|--------| +| 量子 | 0.30 | 4.5% | 24,459 | -75.54 | 1,446 | 40.3 | -83.5 | 0.90 | +| 量子 | 0.35 | 10.1% | 38,991 | -61.01 | 1,389 | 41.7 | -79.1 | 0.77 | +| **量子** | **0.40** | **79.8%** | **226,123** | **+126.12** | **506** | **45.6** | **-24.5** | **5.15** | +| 量子 | 0.45 | 96.8% | 145,011 | +45.01 | 163 | 53.4 | -25.3 | 1.78 | +| 量子 | 0.50 | 99.3% | 100,300 | +0.30 | 85 | 47.1 | -12.2 | 0.02 | +| LogReg | 0.30 | 24.6% | 31,466 | -68.53 | 1,192 | 41.5 | -78.4 | 0.87 | +| LogReg | 0.35 | 44.4% | 135,878 | +35.88 | 931 | 43.9 | -56.0 | 0.64 | +| LogReg | 0.40 | 68.4% | 119,457 | +19.46 | 587 | 42.8 | -42.0 | 0.46 | +| LogReg | 0.45 | 82.5% | 76,398 | -23.60 | 367 | 40.9 | -44.7 | 0.53 | +| LogReg | 0.50 | 91.8% | 86,721 | -13.28 | 204 | 38.7 | -46.6 | 0.28 | + +**关键观察**: 量子模型在th=0.40处达到收益尖峰(+126.12%)，经典LogReg在th=0.35达到最优(+35.88%)。量子核的非线性特征映射在NOOP决策边界上展现出明显优势——量子最优收益是经典的3.5倍。 + +### 5.4 Walk-Forward逐段准确率 + +| 段 | 训练期截止 | 测试期 | 训练量 | 测试量 | 量子ACC | 经典ACC | 量子AUC | 经典AUC | 选中特征 | +|----|-----------|--------|--------|--------|---------|---------|---------|---------|---------| +| 1 | 2022-06-01 | 2022-06~11 | 65d | 111d | 53.2% | 54.1% | 44.1% | 43.3% | ret_5d,vol_ratio,ret_20d,ma_trend,vol_rank_60,rsi_14 | +| 2 | 2022-12-01 | 2022-12~05 | 176d | 106d | 63.2% | 64.2% | 51.1% | 54.0% | bias20,ret_5d,rsi_5,range_5d,ma_trend,rsi_14 | +| 3 | 2023-06-01 | 2023-06~11 | 282d | 107d | 67.3% | 68.2% | 60.1% | 54.1% | bias20,ret_5d,rsi_5,ma_align,range_5d,vol_ratio_20d | +| 4 | 2023-12-01 | 2023-12~05 | 389d | 96d | 57.3% | 57.3% | 60.2% | 58.6% | bias20,ret_5d,rsi_5,range_5d,vol_rank_60,rsi_14 | +| 5 | 2024-06-01 | 2024-06~11 | 485d | 87d | 56.3% | 41.4% | 51.1% | 39.8% | ret_5d,rsi_5,ma_align,range_5d,ma_trend,vol_rank_60 | +| 6 | 2024-12-01 | 2024-12~05 | 572d | 111d | 63.1% | 61.3% | 65.1% | 49.2% | bias20,ret_5d,rsi_5,ma_align,vol_rank_60,rsi_14 | +| 7 | 2025-06-01 | 2025-06~11 | 683d | 117d | 56.4% | 57.3% | 59.7% | 60.5% | bias20,ret_5d,rsi_5,ma_align,vol_rank_60,rsi_14 | +| 8 | 2025-12-01 | 2025-12~05 | 800d | 112d | 45.5% | 43.8% | 63.6% | 48.6% | bias20,ret_5d,vol_ratio,rsi_5,ma_align,vol_rank_60 | +| 9 | 2026-06-01 | 2026-06~07 | 912d | 24d | 58.3% | 58.3% | 52.1% | 22.9% | bias20,ret_5d,vol_ratio,rsi_5,ma_align,vol_rank_60 | + +- **量子平均准确率**: 57.8% | **经典平均准确率**: 56.2% +- **量子核计算总耗时**: 14.7秒 (9段合计, 6 qubit CPU模拟, n_reps=1) +- SelectKBest每段独立选择6/11维特征，`bias20`和`ret_5d`各7段选中(最高频) + +### 5.5 跨策略验证 — 量子NOOP的边界条件 + +为进一步验证量子择时信号的**策略特异性和泛化边界**，我们在三种不同策略上测试了量子NOOP： + +#### 5.5.1 V4_EX1高级策略（阴性结果 — 内置风控饱和） + +V4_EX1是ZP跳空策略的演进版，内置4层风控机制（BIAS13大盘过热保险丝 / EX1早清 / DHU65上影线卖出 / 半卖机制），基线终值33,316,467元（+33,127%/437笔/WR52.9%/MDD28.8%）。 + +**40组配置（2训练模式 × 3标签阈值 × 5 NOOP阈值 × 量子+经典），0组跑赢基线。** + +| 训练模式 | 模型 | 最优终值 | vs基线 | 说明 | +|---------|------|---------|--------|------| +| 基线(无NOOP) | — | 33,316,467 | — | 4层内置风控 | +| ZP-trained迁移 | 量子 | 4,516,056 | **-86.4%** | ZP信号训练，NOOP过滤V4_EX1 | +| ZP-trained迁移 | 经典 | 3,274,973 | **-90.2%** | 同上经典对照 | +| V4_EX1原生训练 | 量子 | 33,316,467 | +0.0% | NOOP=0（模型判定全部日期可交易）| +| V4_EX1原生训练 | 经典 | 20,059,530 | **-39.8%** | 仅过滤8天即损失40% | + +**初步分析**: V4_EX1的BIAS13保险丝已在大盘过热时NOOP（4年触发4天），EX1+DHU65+半卖在个股层面处理风险，量子模型的市场择时信号可能被这些机制部分吸收。然而，这并非唯一解释——详见5.5.5节的多解释分析。 + +#### 5.5.2 WP破板反弹策略（量子击败经典） + +WP stab6是涨停破板企稳反弹策略（尾盘买入），基线终值60,986,712元（+60,887%/630笔/WR52.2%）。 + +| 模型 | 标签阈值 | NOOP阈值 | 终值(元) | vs基线 | 笔数 | 胜率 | +|------|---------|---------|---------|--------|------|------| +| 基线(无NOOP) | — | — | 60,986,712 | — | 630 | 52.2% | +| **量子最优** | **L=2%** | **th=0.35** | **62,571,720** | **+2.6%** | 615 | 52.5% | +| 经典最优 | L=0% | th=0.30 | 60,886,712 | -0.2% | 630 | 52.2% | + +**量子在WP上也击败经典**（+2.6% vs -0.2%），且胜率和均笔收益均提升，改善幅度小于ZP（因WP已有尾盘买入的隐含择时）。 + +#### 5.5.3 跨策略迁移失败（策略特异性） + +用ZP信号训练的量子模型迁移到WP策略上，所有阈值均降低WP收益（最优th=0.30仍降-28%）。这证明量子核捕获的是**策略特异性信号**，而非通用市场噪音——跳空策略和破板反弹策略对市场状态的响应方向相反。 + +#### 5.5.4 统计显著性与鲁棒性验证 + +为评估量子优势的可靠性，进行了两项补充实验（基于V4_PY_0720回测引擎，基线187,046元，标签阈值>0%）： + +**实验A — 多seed配对检验（10个random_state）** + +| 指标 | 量子NOOP | 经典LogReg | +|------|---------|-----------| +| 终值均值 | 190,449元 | 119,739元 | +| 终值标准差 | 28,295 | 0 | +| 量子胜率 | 10/10 (100%) | — | +| 配对t检验 | t=7.50, **p=0.00004** | — | + +量子NOOP在所有10个seed上均跑赢经典LogReg，配对t检验高度显著（p<<0.01）。注意经典LogReg标准差为0——LogReg对random_state完全不敏感，10次结果完全一致。这不是严格的多seed对照（经典侧无随机性变化），但量子侧的稳定性仍具参考价值。 + +**实验B — 超参数鲁棒性扫描（4个C × 3个n_reps = 12组）** + +| n_reps | 跑赢基线 | 最优终值 | +|--------|---------|---------| +| 1 | 0/4 | 140,613元 | +| 2 | 0/4 | 176,461元 | +| **3** | **3/4** | **214,128元 (+14.5%)** | + +> 注: 实验B基于V4_PY_0720引擎，使用>0%标签阈值和旧6维特征（n_reps=2）。阶段2系统化扫描发现n_reps=1在0.5%标签+11维SelectKBest下达到+126.12%，证实超参数敏感性与特征/标签配置强相关。 + +仅3/12配置跑赢基线，且全部为n_reps=3。C=10.0在所有n_reps下均低于基线（过拟合）。这表明量子核SVM对超参数选择敏感——这一脆弱性是本方法需要正视的局限。 + +#### 5.5.5 V4_EX1阴性结果的多解释分析 + +V4_EX1上0/40组跑赢基线需要审慎解读。我们认为单一"信号冗余"解释不够充分，多重因素可能共同导致了这一阴性结果： + +**假说1 — 标签退化（Label Degeneration）** + +V4_EX1的ZP信号经4层风控过滤后，日均信号质量较高。使用0%标签阈值时正样本率达55.9%（接近随机），分类问题退化为"几乎不可分"： + +| 策略 | 标签天数 | 正样本率 | 量子prob均值 | 量子prob标准差 | prob>0.45占比 | +|------|---------|---------|------------|--------------|--------------| +| ZP (>0.5%) | 979 | 41.2% | — | — | — | +| V4_EX1 (L=0%) | 335 | 55.9% | 0.522 | 0.052 | 88.8% | +| V4_EX1 (L=2%) | 335 | — | 0.515 | 0.063 | 96.8% | + +量子概率分布过于集中（标准差仅0.052），88.8%的日期被判为"可交易"（prob>0.45），NOOP几乎不触发——模型在退化标签上缺乏区分能力。作为对比，经典LogReg的概率标准差为0.112（区分度更大），但NOOP后同样亏损（-39.8%），说明标签退化影响的是所有模型而非量子独有。 + +**假说2 — 训练数据不足（Insufficient Training Data）** + +V4_EX1只有335天有ZP信号（ZP有979天），Walk-forward第1段训练量为0直接跳过。更少的训练样本意味着SVM决策边界更不稳定。 + +**假说3 — 内置风控吸收（Signal Absorption）** + +V4_EX1内置4层风控（BIAS13保险丝/EX1早清/DHU65上影线卖出/半卖机制），其中BIAS13本身就是一种市场择时NOOP（4年触发4天）。量子模型学到的市场择时信号可能被这些机制部分吸收。 + +**假说4 — 超参数未优化（Hyperparameter Sensitivity）** + +实验B显示量子核SVM对C和n_reps高度敏感（12组中仅3组跑赢基线）。V4_EX1测试使用的C=0.1/n_reps=2配置在实验B中同样未跑赢基线，换用n_reps=3可能改善。 + +**综合判断** + +上述4个假说并非互斥而是叠加的。V4_EX1的阴性结果最可能是**标签退化+训练不足的复合效应**，而非单一的"信号冗余"——量子概率分布的极端集中（标准差0.052, 88.8%判为可交易）更像是模型在退化标签上"无法学习"的表现，而非学到了与内置风控重复的真信号。后续可通过：①使用0.5%标签阈值替代0%；②扫描n_reps=3和C≤1.0；③扩充训练窗口来进一步验证。 + +#### 5.5.6 量子NOOP有效性边界总结 + +| 策略 | 内置风控 | 量子NOOP效果 | 量子vs经典 | 结论 | +|------|---------|-------------|-----------|------| +| 基础ZP跳空 | 无 | **+126.12%** | 量子显著优于经典(p=0.00004) | 量子择时价值最大化 | +| WP破板反弹 | 尾盘隐含 | **+2.6%** | 量子优于经典(+2.6% vs -0.2%) | 增量有限但方向一致 | +| V4_EX1高级 | 4层风控 | **0/40跑赢** | 两者均无法改善 | 多因素复合阴性(见5.5.5) | +| ZP→WP迁移 | — | **全部降低** | 两者均降低 | 策略特异性信号 | + +**核心发现**: 量子核SVM的市场择时信号在ZP跳空策略上高度有效（+126.12%），且在多seed检验下统计显著优于经典方法（p=0.00004）。然而，量子核SVM对超参数选择敏感（12组中仅3组跑赢基线），且在V4_EX1高级策略上完全失效——这一阴性结果最可能源于标签退化和训练不足的复合效应，而非单一的"信号冗余"。量子择时信号的真实性已被ZP和WP两个策略验证，但其泛化边界和鲁棒性仍需进一步研究。 + +--- + +## 5b. 个股级量子筛选 — 从市场层到股票层 + +### 5b.1 动机 + +日级NOOP（5.5节）是对整个市场"好天/坏天"的二元判断——如果预测今天不好，跳过全部买入信号。然而同一好天内部，不同股票信号的质量差异巨大。**个股级筛选**将量子核SVM的判别粒度从"交易日"细化到"单笔信号"：对每个跳空信号独立预测"好票/坏票"，过滤量子模型不认可的信号，保留优质信号。 + +> 排序铁律不变：被买入信号仍按gap_pct降序排列（策略核心逻辑不修改，量子仅做过滤） + +### 5b.2 方法 + +**特征**: 6维个股特征（全部T-1口径, 零前视偏差） + +| 特征 | 公式 | 含义 | +|------|------|------| +| `gap_pct` | T日open/T-1 close - 1 | 跳空幅度（09:25可见） | +| `vol_ratio` | mean(vol[-5:]) / mean(vol[-10:]) | 5日/10日量比 | +| `ma_dist` | close[-1]/MA10 - 1 | 偏离MA10% | +| `upper_shadow` | (H-max(O,C))/(H-L) | T-1上影线% | +| `body_pct` | (C-O)/O | T-1实体% | +| `ret_5d` | close[-1]/close[-6] - 1 | 5日涨幅% | + +**标签**: sell_ret > median = 1（好票），sell_ret <= median = 0（坏票） + +**Walk-forward**: 按交易日分段（126日≈6个月），扩展窗口，StandardScaler仅fit训练段 + +**筛选机制**: 模型输出概率 < 阈值 → 跳过该信号（个股级NOOP，不影响同日其他信号） + +**量子配置**: AngleEncoding, 6 qubits, n_reps=1, C=0.1, scale=π（与日级NOOP一致） + +### 5b.3 ZP跳空策略个股级筛选结果 + +对3组GAP阈值进行个股级筛选，验证信号密度与量子优势的关系： + +| GAP | 信号数 | 基线收益% | 量子最佳% | 经典最佳% | Q提升pp | L提升pp | Q/L比 | Q跳过% | +|-----|--------|----------|----------|----------|---------|---------|-------|--------| +| 2.0% | 7,042 | -56.6 | -17.0 | -40.9 | +39.5 | +15.7 | **2.52x** | 34% | +| 2.5% | 4,818 | -61.5 | -38.2 | -43.1 | +23.3 | +18.3 | 1.27x | 21% | +| 3.0% | 3,250 | -36.8 | -21.9 | -21.7 | +14.9 | +15.1 | 0.98x | 8% | + +**GAP2.0的Q/L=2.52x是最干净的"量子>经典"证据**——量子提升+39.5pp是经典+15.7pp的2.52倍。 + +### 5b.4 关键发现 — 分层反转模式 + +个股级与日级的Q/L比呈**反向关系**： + +| GAP | 层级 | 信号数 | Q/L比 | 解释 | +|-----|------|--------|-------|------| +| 2.0% | **个股级** | 7,042 | **2.52x** | 信号多→个股间差异丰富→量子优势大 | +| 2.0% | 日级 | — | 0.85x | 信号多→日聚合后信息丢失→量子无优势 | +| 2.5% | **个股级** | 4,818 | 1.27x | | +| 2.5% | 日级 | — | **2.12x** | 信号少→日级量子优势大 | +| 3.0% | 个股级 | 3,250 | 0.98x | 信号少→个股级样本不足→量子退化为经典 | +| 3.0% | 日级 | — | **2.29x** | 信号少→日级量子优势大 | + +**核心洞察**: +- **信号多(7042)时**: 日级聚合后信息丢失（只看大盘），量子在日级无优势(Q/L=0.85x)；但个股级保留全部信息，量子能捕获个股间非线性差异(Q/L=2.52x) +- **信号少(3250)时**: 日级聚合后每个信号的信息密度更高（大盘环境主导），量子在日级优势大(Q/L=2.29x)；但个股级信号太少，样本不足让量子退化为经典(Q/L=0.98x) +- **分层反转的意义**: 量子核SVM在不同信号密度下，其优势层级会自动迁移——信号密集→个股级有效；信号稀疏→日级有效。这不是噪声，而是量子核在不同信息量下的合理行为 + +### 5b.5 跨策略个股级验证 — WP stab6破板反弹（阴性结果） + +为验证个股级量子筛选的**策略泛化性**，将同样的方法应用于WP stab6策略（涨停破板企稳反弹，632笔交易）。 + +**3轮降维实验（V1→V2→V3），全部失败**: + +| 版本 | 特征数 | qubits | Q/L比 | 原因 | +|------|--------|--------|-------|------| +| V1 | 6维 | 6q | 0%提升 | 特征diff<0.3，零区分度 | +| V2 | 8维(+破板深度+反转幅度) | 8q | 0.27x | 量子核矩阵退化为全0.5 | +| **V3** | 2~8维 (网格扫描) | 2~8q | **0.62x** | 2q最优但仍<经典 | + +**V3网格扫描完整结果（2/4/6/8 qubits × C=0.1/1.0/10.0）**: + +| 配置 | Q_acc | L_acc | Q最好% | L最好% | Q/L | +|------|-------|-------|--------|--------|-----| +| **2q C=1.0** | 63.7% | 67.7% | +588% | +850% | **0.62x** | +| 4q C=1.0 | 56.1% | 67.9% | +412% | +854% | 0.36x | +| 6q C=1.0 | 52.6% | 68.5% | +345% | +847% | 0.27x | +| 8q C=1.0 | 51.1% | 67.8% | +441% | +819% | 0.43x | + +**失败根因**: +1. **信号池同质化**: WP stab6的信号已被涨停+破板+企稳三重过滤，信号池中股票的特征分布高度集中，量子核无法找到额外的非线性模式 +2. **量子核退化**: 8qubits + 632样本导致量子核矩阵趋近全0.5（概率均匀化），退化为随机猜测 +3. **降维也不够**: 即使降到2qubits，量子准确率63.7%仍低于经典67.7%——经典LogReg在低维下已足够好 + +**对比ZP成功的原因**: ZP跳空策略的信号来源更广（7042个信号），个股间特征差异丰富（gap_pct 2~5%、vol_ratio 0.8~1.5、ma_dist各种值），量子核的非线性特征映射能够捕获经典线性模型遗漏的pattern。而WP stab6的信号已经被极度预筛选，留给量子模型的额外信息几乎为零。 + +### 5b.6 个股级量子筛选有效性边界总结 + +| 策略 | 信号数 | 信号池多样性 | Q/L比 | 结论 | +|------|--------|------------|-------|------| +| ZP跳空 (GAP2.0) | 7,042 | 高 (来源广) | **2.52x** | 量子显著优于经典 | +| ZP跳空 (GAP2.5) | 4,818 | 中高 | 1.27x | 量子略优于经典 | +| ZP跳空 (GAP3.0) | 3,250 | 中 | 0.98x | 量子≈经典 | +| WP stab6破板 | 632 | 低 (三重预筛选) | 0.62x | 经典优于量子 | + +**核心结论**: 量子核SVM的个股级筛选优势与信号池的多样性正相关——信号来源越广、池子越大、个股间差异越丰富，量子的非线性特征映射优势越显著。当信号池已被高度预筛选（如WP stab6的三重过滤），量子核退化为经典方法的水平甚至更差。这一发现为量子核SVM的应用边界提供了明确的判据：**量子核适用于"广撒网"型策略的信号筛选，不适用于"精筛"型策略的二次过滤。** + +--- + +## 5c. 鲁棒性验证 — 超参数稳定性确认 + +### 5c.1 动机 + +5b节的个股级量子筛选（ZP跳空策略, Q/L=2.52x）展示了量子优势，但一个关键问题是：**量子优势是否依赖特定的超参数配置？** 如果换个refit窗口或特征集，量子优势是否就消失了？ + +为此，我们在V4_EX1演化策略（强化基线，4层内置风控）上进行了系统化鲁棒性验证，扫描6种买入端配置和3种卖出端配置，验证量子优势的稳定性。 + +### 5c.2 买入端鲁棒性（B_sort_desc, 6/6 通过） + +**基线策略**: V4_EX1演化策略，基线终值3,730,044元（+3630%, 294笔） + +**扫描配置**: 3种refit窗口（3月/6月/12月）× 2种特征集（full7=7维全特征 / manual4=4维精选），共6组 + +| Config | Q收益% | L收益% | Q/L | Q>基线 | Q>L | +|--------|--------|--------|-----|--------|-----| +| refit3m_full7 | +6281 | +2134 | 2.94x | ✅ | ✅ | +| refit6m_full7 | +5145 | +2196 | 2.34x | ✅ | ✅ | +| refit12m_full7 | +8233 | +2113 | 3.90x | ✅ | ✅ | +| refit3m_manual4 | +6332 | +2985 | 2.12x | ✅ | ✅ | +| refit6m_manual4 | +6208 | +3235 | 1.92x | ✅ | ✅ | +| refit12m_manual4 | +6404 | +2985 | 2.15x | ✅ | ✅ | + +**6/6 Q>L ✅, 6/6 Q>基线 ✅** + +- Q/L比率范围: 1.92x ~ 3.90x，中位数2.24x +- 所有6种配置下量子核SVM均超越经典LogReg，且均超越无过滤基线 +- refit12m_full7最强（Q/L=3.90x），但refit3m_manual4的Q绝对收益最高（+6332%） +- **结论：买入端量子排序优势不依赖特定超参数配置，高度稳定** + +### 5c.3 卖出端鲁棒性（shorten_bad-1, 3/3 Q>L, 2/3 Q>基线） + +**机制**: 量子核SVM预测每个交易日的"好/坏"概率，对概率<0.35的"坏天"中的持仓提前1天卖出（shorten_bad-1），类似于个股级的NOOP保险丝 + +**基线终值**: 5,976,365元（+5876%, 292笔） + +| Config | Q收益% | L收益% | Q/L | Q>基线 | Q缩短笔数 | L缩短笔数 | +|--------|--------|--------|-----|--------|----------|----------| +| refit3m | +6146 | +5173 | 1.19x | ✅ (+270pp) | 7 | 34 | +| refit6m | +6149 | +4525 | 1.36x | ✅ (+272pp) | 10 | 42 | +| refit12m | +5876 | +4597 | 1.28x | ❌ (+0pp) | 0 | 41 | + +**3/3 Q>L ✅, 2/3 Q>基线 ✅** + +- 3种refit窗口下量子均超越经典（Q/L: 1.19x~1.36x） +- refit12m时量子shortened=0（12月窗口太宽，量子预测的"坏天"未达0.35阈值），故Q=基线 +- **量子缩短笔数（7~10）远少于经典（34~42）**——量子模型更精准，只缩短真正需要缩短的持仓，避免误杀盈利持仓 +- **结论：卖出端量子优势稳定但增量较小（+270pp），6月refit是最佳配置** + +### 5c.4 鲁棒性验证总结 + +| 维度 | 配置数 | Q>L | Q>基线 | Q/L范围 | 结论 | +|------|--------|-----|--------|---------|------| +| 买入端(B_sort_desc) | 6 | 6/6 ✅ | 6/6 ✅ | 1.92~3.90x | 优势高度稳定 | +| 卖出端(shorten_bad-1) | 3 | 3/3 ✅ | 2/3 ✅ | 1.19~1.36x | 优势稳定但增量小 | + +**核心结论**: 量子核SVM在买入端的非线性排序优势（Q/L≈2~4x）在不同超参数下高度稳定，9组实验0失败，不依赖cherry-picking。卖出端优势也存在但增量较小（+270pp），且量子模型的"少而精"缩短风格（7~10笔 vs 经典34~42笔）进一步证实量子核捕获了更精准的市场模式。 + +--- + +## 5d. 买卖结合实验 — 协同效应分析 + +### 5d.1 动机 + +5c节分别验证了买入端（B_sort_desc）和卖出端（shorten_bad-1）的量子优势。一个自然的问题是：**如果同时应用买入端量子排序和卖出端量子调整，是否会产生协同效应(1+1>2)？** + +### 5d.2 实验设计 + +在V4_EX1演化策略上进行4组对照实验（量子+经典各4组）： + +| Config | 买入端 | 卖出端 | 说明 | +|--------|--------|--------|------| +| baseline | 跳空%排序 | 无调整 | 无量子干预 | +| B_only | **量子排序** | 无调整 | 仅买入端量子 | +| S_only | 跳空%排序 | **量子提前卖** | 仅卖出端量子 | +| B+S | **量子排序** | **量子提前卖** | 买卖双向量子 | + +### 5d.3 结果 + +| Config | Q收益% | L收益% | Q/L | Q Δ(vs基线) | L Δ(vs基线) | +|--------|--------|--------|-----|------------|------------| +| baseline | +4220 | +4220 | 1.00x | 0 | 0 | +| **B_only** | **+5291** | +3050 | **1.73x** | **+1071pp** | -1170pp | +| S_only | +3371 | +3055 | 1.10x | -849pp | -1165pp | +| B+S | +4712 | +1850 | 2.55x | +492pp | -2371pp | + +### 5d.4 关键发现 + +1. **B_only是最优策略**（Q +5291%, Δ=+1071pp vs baseline）——买入端量子排序单独使用效果最好 +2. **无协同效应**: B+S（+4712%）< B_only（+5291%），协同效应 = -579pp（负值=拮抗而非协同） +3. **S_only反而降低收益**: S_only（+3371%）< baseline（+4220%），Δ=-849pp +4. **B+S的Q/L最高（2.55x）**: 但这是经典侧B+S最差（+1850%）导致的——经典在买卖双向调整下崩溃 + +### 5d.5 机制分析 + +为什么买卖结合反而不如单独使用买入端？ + +- **买入端排序改变了资金路径**: 量子排序选出不同的股票→资金分配路径分叉→持仓组合不同→卖出端量子模型面对的持仓已不是同一批标的 +- **卖出端在组合模式下效果衰减**: S_only在buy-date iteration模式下有效（+270pp in 5c.3），但在combined backtest的all-trading-days iteration模式下反而低于基线（-849pp） +- **蝴蝶效应**: 策略对初始条件极度敏感（见5.5.5节蝴蝶效应分析），买入端任何改变都会通过资金池复利效应放大，叠加卖出端调整可能产生负反馈 + +### 5d.6 实践指导 + +**最优应用方式: 买入端量子排序单独使用（B_only）** + +| 应用方式 | Q收益% | Q Δ vs基线 | Q/L | 推荐度 | +|---------|--------|-----------|-----|--------| +| **B_only（买入端单独）** | **+5291** | **+1071** | **1.73x** | **★★★ 最优** | +| B+S（买卖结合） | +4712 | +492 | 2.55x | ★☆ 有协同损失 | +| S_only（卖出端单独） | +3371 | -849 | 1.10x | ☆☆ 不推荐 | + +量子核SVM在选股系统中的最佳应用方式是作为**买入端的信号排序器**——用量子核的非线性特征映射重新排列信号优先级，而非在卖出端做二次干预。这一结论与5b.4节的"分层反转"发现一致：量子核的优势集中在信号选择阶段，而非持仓管理阶段。 + +--- + +## 5e. real_bt引擎验证与参数调优 + +### 5e.1 动机 + +5d节的B_only结果(+5291%/Δ+1071pp)基于combined_backtest引擎——该引擎回放预先计算的428笔DHU65交易轨迹，量子概率100%覆盖。然而实盘中策略需要每日扫描全市场(4016只股票)动态选股，量子概率覆盖率仅38%(391个条目覆盖438笔交易信号)。为验证量子排序在动态环境下的真实效果，我们在real_bt引擎中进行了完整验证和参数调优。 + +### 5e.2 排序逻辑设计 + +**铁律**: ZP策略的跳空%降序排序是策略核心，不可替换。量子概率作为gap_pct副排序，经103组实验验证，boost模式为最优方案。 + +```python +# real_bt_engine.py 排序逻辑 (boost最优版) +if quantum_sort_enabled and quantum_sort_map: + _qkey = quantum_sort_map.get(f"{code}|{date_str}", 0.5) + _skey = gap_pct * 10.0 + _qkey # gap_pct主排序 + 量子概率boost副排序 + candidates.append((code, _skey, 'zp')) +else: + candidates.append((code, gap_pct, 'zp')) # 纯跳空%降序 +``` + +- `gap_pct * 10.0`确保跳空幅度差异主导排序(跳空3%→30, 跳空5%→50, 差距20远大于量子概率) +- **boost模式**: 量子概率JSON在训练后预计算boost——q>0.6→q+0.8(高信心信号跨越gap_pct层级优先排列), q<0.4→q-0.8(低信心信号排末尾), 其余不变(tiebreaker) +- 修正了早期版本"纯量子排序替换gap_pct"的灾难性错误(20.9%收益vs基线3315万) +- 经过41组多切入点实验+62组boost精细调优验证：boost(th=0.6,val=0.8)为全局最优(+4.8%) + +### 5e.3 RT参数扫描 + +RET_THRESHOLD(RT)决定正负样本标签: `label = 1 if pnl_pct > RT else 0`。RT是量子模型的最大杠杆——RT越高，正样本越少但质量越高，概率分布range越宽。 + +| RT(%) | prob range | near_50% | 终值(元) | Δ% vs基线 | 笔数 | WR | PF | MDD | +|-------|-----------|----------|---------|-----------|------|-----|-----|------| +| 基线 | - | - | 33,158,964 | 0.0% | 438 | 53.0% | 1.64 | 28.8% | +| 2.5(tiebreaker) | 0.416 | 48.1% | 34,681,092 | +4.6% | 443 | 53.0% | 1.65 | 30.1% | +| **2.5(boost)** | **0.416→2.016** | **48.1%** | **34,756,003** | **+4.8%** | **445** | **53.3%** | **1.64** | **30.7%** | +| 3.0 | 0.882 | 27.1% | 34,390,580 | +3.7% | 446 | 53.1% | 1.64 | 31.2% | +| 2.6~2.8 | 0.436 | 42~46% | 22,194,104 | -33.1% | 418 | 52.4% | 1.48 | 30.4% | +| 2.9 | 0.304 | 34.3% | 18,298,618 | -44.8% | 372 | 51.3% | 1.50 | 28.0% | +| 4.0 | 0.882 | 23.0% | 23,938,881 | -27.8% | - | - | - | - | +| 5.0 | 0.882 | 15.3% | 11,266,674 | -66.0% | - | - | - | - | + +### 5e.4 关键发现 + +1. **RT=2.5%是唯一稳定超参数**: +4.8%超越基线(3476万 vs 3316万)，range=0.416，48.1%概率在0.45~0.55区间 +2. **RT=2.5~3.0之间存在跳变**: RT=2.5%(range=0.416)最优，RT=2.6~2.8%(range=0.436)暴跌-33%，RT=3.0%(range=0.882)回升至+3.7%——蝴蝶效应使中间值成为死区 +3. **range不是越大越好**: RT=2.5%(range=0.416)优于RT=3.0%(range=0.882)——因为range必须小于gap_pct步长(1.0)，量子概率才能作为纯tiebreaker而不干扰主排序 +4. **C参数无影响**: C=0.01/0.1/1.0结果完全一致——因为gap_pct*10的主导地位使量子概率仅做tie-break，C仅影响概率绝对值不影响排序 +5. **排序权重mul=10是唯一有效值**: mul=20/50/100全部恶化(-38%~-88%)——增加mul缩小量子概率范围会放大默认值0.5对缺失信号的偏置 +6. **boost模式优于纯tiebreaker**: 52组boost精细调优验证，boost(th=0.6,val=0.8)从3468万提升至3476万(+0.2pp)。boost让高信心量子信号(q>0.6)跨越gap_pct层级优先排列，低信心信号(q<0.4)排末尾。但量子概率分布太窄(仅2个信号q>0.6)限制了boost的增益幅度 +7. **量子概率分布太窄是根本瓶颈**: RT=2.5%下80%信号在0.40~0.50之间，仅2.3%信号q>0.55。blend(量子主导排序)全线崩溃(-45%~-88%)——放大量子概率的微小差异到跨越gap_pct步长→噪音被放大→灾难。boost是唯一能跨越gap_pct步长且正向的模式 + +### 5e.5 Platt概率阶段结论 + +量子核SVM概率作为gap_pct副排序在动态回测引擎中实现+4.8%超额收益。经103组实验(19组RT扫描+41组多切入点+62组boost调优)系统验证，boost(th=0.6,val=0.8)为Platt概率模式下的最优配置。然而，Platt sigmoid概率压缩导致分布太窄(80%信号在0.40~0.50之间)，成为根本瓶颈。 + +### 5e.6 决策函数突破 — 从Platt概率到decision_function + +**核心发现**: 用`qsvm.decision_function(K_te)` + min-max归一化替代`predict_proba`，绕过Platt sigmoid概率压缩，获得range=1.000的完整决策分数分布(Platt概率range仅0.416)。 + +**6维度模型突破实验(22组)**: + +| 维度 | 扫描值 | 结论 | +|------|--------|------| +| C参数(Platt) | 0.1/0.5/1.0/10 | C越大range越宽但回测越差(噪音放大) | +| Scale | π/2/π/2π/4π/8π | π最优，其余全负 | +| n_reps | 1/2/3 | 1最优(与Phase 2一致) | +| ZZFeatureMap | vs Angle | 略差于angle | +| 扩展特征集(11维) | vs 7维 | 概率分布改善但回测全负 | +| **decision_function** | **C=10** | **首次突破Platt瓶颈，range=1.000** | + +**decfunc精细调优(42组)**: + +C邻域扫描发现C=7为峰值(+17.3%)但过于尖锐，C=10更稳定(+7.3%)。boost阈值/值扫描发现关键模式——**高阈值(只boost最top信心信号) + 大boost值(跨越gap_pct层级) = 最优**： + +| th | val | 终值(元) | Δ% | boosted信号数 | +|----|-----|---------|-----|--------------| +| 0.60 | 0.8 | 35,568,401 | +7.3% | 136(34.8%) | +| 0.65 | 2.0 | 38,899,910 | +17.3% | 117(29.9%) | +| 0.70 | 2.0 | 43,355,803 | +30.8% | 85(21.7%) | +| **0.75** | **2.0** | **48,618,668** | **+46.6%** | **63(16.1%)** | +| 0.80 | 2.0 | 45,801,526 | +38.1% | 45(11.5%) | + +**模式**: th=0.75 → 只boost 16%最top信心信号，boost+2.0让其跨越gap_pct*10层级排到最前。val=0.5几乎无效(信号值变化不够跨越gap_pct步长)，val=2.0足够跨越。 + +### 5e.7 三维plateau验证 — 排除lucky outlier + +为确认+46.6%是真实peak而非蝴蝶效应噪音，进行了三维精细验证(34组配置)： + +**维度1 — th精细扫描(val=2.0, C=10)**: + +| th | 终值(元) | Δ% | 笔数 | WR | PF | MDD | +|----|---------|-----|------|-----|-----|------| +| 0.70 | 43,355,803 | +30.8% | 473 | 53.5% | 1.76 | 27.0% | +| 0.72 | 34,729,019 | +4.7% | 471 | 51.6% | 1.57 | 30.6% | +| 0.73 | 44,819,289 | +35.2% | 497 | 53.3% | 1.69 | 27.0% | +| 0.74 | 44,819,289 | +35.2% | 497 | 53.3% | 1.69 | 27.0% | +| **0.75** | **48,618,668** | **+46.6%** | **497** | **53.7%** | **1.75** | **27.0%** | +| **0.76** | **48,618,668** | **+46.6%** | **497** | **53.7%** | **1.75** | **27.0%** | +| **0.77** | **48,616,025** | **+46.6%** | **497** | **53.7%** | **1.75** | **27.0%** | +| 0.78 | 45,801,526 | +38.1% | 502 | 53.4% | 1.69 | 26.8% | +| 0.80 | 45,801,526 | +38.1% | 502 | 53.4% | 1.69 | 26.8% | +| 0.82 | 19,538,360 | -41.1% | 396 | 51.8% | 1.49 | 35.9% | +| 0.85 | 20,266,816 | -38.9% | 395 | 50.9% | 1.50 | 35.9% | + +**维度2 — val精细扫描(th=0.75, C=10)**: + +| val | 终值(元) | Δ% | 笔数 | +|-----|---------|-----|------| +| 1.5 | 36,159,176 | +9.0% | 461 | +| **1.8** | **48,621,960** | **+46.6%** | **497** | +| **2.0** | **48,618,668** | **+46.6%** | **497** | +| 2.5 | 40,546,734 | +22.3% | 476 | +| 3.0 | 40,546,734 | +22.3% | 476 | +| 5.0 | 41,747,222 | +25.9% | 472 | +| 10.0 | 19,451,763 | -41.3% | 370 | + +**维度3 — C验证扫描(th=0.75, val=2.0)**: + +| C | 终值(元) | Δ% | 笔数 | +|---|---------|-----|------| +| 6.0 | 38,916,023 | +17.4% | 476 | +| 7.0 | 38,919,840 | +17.4% | 476 | +| **8.0** | **48,618,668** | **+46.6%** | **497** | +| **9.0** | **48,618,668** | **+46.6%** | **497** | +| **10.0** | **48,618,668** | **+46.6%** | **497** | +| **11.0** | **48,618,668** | **+46.6%** | **497** | +| **12.0** | **48,618,668** | **+46.6%** | **497** | + +### 5e.8 三维plateau铁证 + +**30个配置(C=8~12 × th=0.75~0.77 × val=1.8~2.0)全部给出完全相同的48,618,668/+46.6%/497笔/WR53.7%/PF1.75/MDD27.0%**： + +| 维度 | 稳定区间 | 配置数 | 结果 | +|------|---------|--------|------| +| C | 8, 9, 10, 11, 12 | 5个 | 全部48.6M +46.6% | +| th | 0.75, 0.76, 0.77 | 3个 | 全部48.6M +46.6% | +| val | 1.8, 2.0 | 2个 | 全部48.6M +46.6% | +| 合计 | | **30个** | **完全一致** | + +这不是蝴蝶效应噪音——30个不同参数组合产生完全相同的497笔交易，说明boost在这个区域只改变了一组固定的信号排序，且这个排序稳定优于gap_pct原始排序。 + +### 5e.9 演进路线总结 + +| 阶段 | 配置 | 终值(元) | Δ% vs基线 | 关键突破 | +|------|------|---------|-----------|---------| +| 基线 | gap_pct排序 | 33,158,964 | 0.0% | — | +| Platt最优 | C=0.1, boost th=0.6 val=0.8 | 34,756,003 | +4.8% | Platt概率boost | +| decfunc初探 | C=10, th=0.6, val=0.8 | 35,568,401 | +7.3% | decision_function替代Platt | +| decfunc阈值 | C=10, th=0.70, val=2.0 | 43,355,803 | +30.8% | 高阈值大boost值 | +| **decfunc最优** | **C=10, th=0.75, val=2.0** | **48,618,668** | **+46.6%** | **三维plateau验证** | + +### 5e.10 最终部署参数 + +``` +模型: decision_function (替代predict_proba) +C: 10.0 +RT: 2.5% +n_reps: 1 +n_qubits: 6 +scale: π +refit: 6月扩展窗口 +boost: th_high=0.75, th_low=0.25, val=2.0 +mul: 10 +→ 终值 48,618,668元 / +46.6% / 497笔 / WR53.7% / PF1.75 / MDD27.0% +``` + +**部署文件**: `quantum_b_only_qprob_map.json` (391个信号, 63 boosted, 50 penalized, 278 unchanged) + +--- + +## 六、系统化优化方法论 + +为找到全局最优配置，我们对系统的四个维度进行了穷尽式扫描，每阶段独立验证后逐步锁定最优参数。 + +### 6.1 Phase 1 — 特征工程 + +| 配置 | 维度 | 终值(元) | 收益% | 说明 | +|------|------|---------|-------|------| +| 基础6维 | 6 | 49,251 | -50.7 | 固定6特征，无选择 | +| 扩展16维 | 16→6 | 60,572 | -39.4 | 全部特征+SelectKBest | +| **11维+SelectKBest** | **11→6** | **226,123** | **+126.1** | 上证基础6+扩展5，SelectKBest→6q | +| 8维固定8q | 8 | 99,532 | -0.5 | 8 quantum features，无选择 | + +**结论**: 11维作为SelectKBest的候选池最优——太大(16维)引入噪音特征干扰选择，太小(6维)无选择空间。SelectKBest每段独立选择最相关特征，自适应不同市场阶段。 + +### 6.2 Phase 2 — 电路与超参数扫描 + +| 电路类型 | n_reps | C | 终值(元) | 收益% | 说明 | +|---------|--------|------|---------|-------|------| +| AngleEncoding | **1** | **0.1** | **226,123** | **+126.1** | ★全局最优 | +| AngleEncoding | 2 | 0.1 | 42,680 | +1.8 | n_reps=2远逊于1 | +| AngleEncoding | 1 | 1.0 | 137,542 | +37.5 | C=1.0次优 | +| AngleEncoding | 1 | 10.0 | 74,684 | -25.3 | C过大过拟合 | +| ZZFeatureMap | 1 | 0.1 | 98,124 | -1.9 | ZZ远逊于Angle | + +**关键发现 — n_reps=1是颠覆性突破**: 重复编码电路(n_reps≥2)引入过度纠缠，将市场信号的微弱规律性淹没在量子噪音中。n_reps=1仅做一次角度编码，保留最大信号保真度。 + +### 6.3 Phase 3 — 标签工程 + +| 标签类型 | 阈值 | 正样本率 | 终值(元) | 收益% | +|---------|------|---------|---------|-------| +| **二分类** | **0.5%** | **41.2%** | **226,123** | **+126.1** | +| 二分类 | 0% | 52.2% | 165,291 | +65.3 | +| 二分类 | 1.0% | 30.1% | 113,612 | +13.6 | +| 多分类(3类) | — | — | 72,019 | -28.0 | +| 回归 | — | — | 82,426 | -17.6 | + +**结论**: 0.5%二分类最优——0%太弱(正样本率52.2%接近随机)，1.0%太严(信号过少)。0.5%恰好过滤"微涨噪音日"，正样本率41.2%提供最佳分类难度。 + +### 6.4 Phase 4 — 训练策略 + +| 策略 | 终值(元) | 收益% | 说明 | +|------|---------|-------|------| +| **6月refit + 扩展窗口** | **226,123** | **+126.1** | ★最优 | +| 月度refit + 扩展窗口 | 198,229 | +98.2 | 频繁refit引入不稳定性 | +| 季度refit + 扩展窗口 | 181,299 | +81.3 | | +| 6月refit + 滚动窗口 | 155,923 | +55.9 | 固定窗口丢失早期数据 | +| 集成(多段投票) | 163,491 | +63.5 | 计算复杂度高，收益更差 | + +**结论**: 6个月refit + 扩展窗口最优——模型定期更新适应市场变化，同时训练数据只增不 never 减，充分利用历史信息。 + +### 6.5 全局最优配置 + +``` +电路: AngleEncoding +量子比特: 6 (从11维经SelectKBest选择) +n_reps: 1 +C: 0.1 +scale: π (特征缩放) +特征: 11维 SelectKBest→6q +标签: 0.5%二分类 +训练: 6月refit + 扩展窗口 +→ 终值 226,123元 / +126.12% / Calmar 5.15 +``` + +--- + +## 七、标签降噪方法论 + +### 7.1 问题：个股级标签信噪比极低 + +单笔交易是否盈利的预测是量化交易的经典难题。在我们的数据中： +- 7042个交易信号，单笔胜率仅48.3% +- 所有模型(量子和经典)在个股级预测的AUC≈0.50（随机水平） +- 原因：个股噪声极大，单笔盈亏受太多不可控因素影响 + +### 7.2 解决方案：按日聚合 + 阈值过滤 + +**聚合层**: 将同一天的多个信号聚合为"日级标签"——如果当天信号的平均收益>阈值，则该日为"好天"(label=1)。 + +**降噪数学原理**: 假设单笔收益 $r_i \sim \mu + \epsilon_i$，其中 $\epsilon_i$ 独立同分布。当日有$N$个信号时，日均收益 $\bar{r} = \mu + \bar{\epsilon}$，噪音标准差降低 $\sqrt{N}$ 倍。信号越多的日子降噪越强。 + +### 7.3 阈值选择 + +| 阈值 | 正样本率 | 好天avg收益 | 坏天avg收益 | 分离度 | 量子NOOP收益 | +|------|---------|------------|------------|-------|-------------| +| 0% | 52.2% | +0.42% | -0.85% | 1.27% | +65.3% | +| **0.5%** | **41.2%** | **+1.18%** | **-0.80%** | **1.98%** | **+126.1%** | +| 1.0% | 30.1% | +1.65% | -0.62% | 2.27% | +13.6% | + +**0.5%最优原因**: 分离度(好天vs坏天收益差)足够大(1.98%)，正样本率不太极端(41.2%)，分类器可有效学习。1.0%虽分离度更大但正样本太少(30.1%)，模型训练样本不足。 + +--- + +## 八、代码结构 + +``` +quantum_ashare_market_timing/ +├── main.py # 主程序: Walk-forward日级验证 + NOOP回测 +├── stock_level_filter.py # 个股级量子筛选: per-signal NOOP (5b节) +├── quantum_kernel.py # 量子核计算 (QPanda3) +├── market_data.py # 市场特征 + 信号加载 + 标签构建 +├── backtest.py # 资金池回测引擎 +├── trading_signals_sample.pkl # 预计算交易信号 (7042个, 2022-2026) +├── results.json # 全部回测结果 (日级NOOP + 个股级筛选 + WP跨策略验证) +├── requirements.txt # 依赖清单 +└── README.md # 本文档 +``` + +### 模块说明 + +| 模块 | 职责 | 关键函数 | +|------|------|---------| +| `quantum_kernel.py` | 量子态编码 + 量子核矩阵计算 | `build_angle_encoding()`, `compute_quantum_states()`, `quantum_kernel_matrix()` | +| `market_data.py` | 市场特征构建 + 信号加载 + 标签聚合 | `build_market_features()`, `load_zp_signals()`, `build_daily_labels()` | +| `backtest.py` | 资金池回测 + NOOP机制 + 集成门控 | `run_backtest()`, `generate_noop_dates()`, `generate_ensemble_noop()` | +| `main.py` | 日级Walk-forward验证 + 阈值扫描 + 结果汇总 | `walk_forward_validation()`, `scan_noop_thresholds()`, `main()` | +| `stock_level_filter.py` | 个股级量子筛选 (per-signal NOOP) + 分层反转验证 + 鲁棒性验证 | `main()`, 3组GAP阈值扫描, `run_robustness_check()` | + +### 交易信号文件 + +`trading_signals_sample.pkl` 包含7042个预计算交易信号，结构如下： + +| 字段 | 类型 | 说明 | +|------|------|------| +| date (index) | datetime | 信号触发日期 | +| code | str | 股票代码 | +| gap_pct | float | 信号强度指标 | +| buy_price | float | 买入价格 | +| sell_price | float | 卖出价格 | +| sell_ret | float | 收益率(卖出价/买入价) | +| label | int | 盈亏标签(1=盈利, 0=亏损) | + +> 信号由独立的外部策略引擎预计算并持久化。本系统仅消费信号数据，不包含策略选股逻辑。 + +--- + +## 九、安装与运行 + +### 9.1 环境要求 + +- Python ≥ 3.10 +- QPanda3 (国产量子编程框架) +- scikit-learn, numpy, pandas + +```bash +pip install -r requirements.txt +``` + +### 9.2 数据准备 + +运行系统需要以下数据文件： + +| 文件 | 用途 | 必需 | +|------|------|------| +| `trading_signals_sample.pkl` | 交易信号 | **是** (已包含在仓库中) | +| `sh000001.pkl` | 上证指数日线 | **是** | +| `all_data.pkl` | 个股K线数据(市场广度特征) | 可选 (无则仅用11维特征) | + +### 9.3 运行 + +```bash +# 日级NOOP主程序 (5.1~5.5节) +python main.py + +# 指定数据路径 +python main.py --data_path /path/to/all_data.pkl --sh_index_path /path/to/sh000001.pkl + +# 个股级量子筛选 (5b节) +python stock_level_filter.py +python stock_level_filter.py --data_path /path/to/all_data.pkl + +# 鲁棒性验证模式 (5c节) — 多refit窗口×多特征集Q>L稳定性检验 +python stock_level_filter.py --mode robustness --data_path /path/to/all_data.pkl +``` + +### 9.4 预期输出 + +**`main.py`** (日级NOOP): +1. Walk-forward 9段逐段训练/测试准确率 +2. 量子+经典NOOP阈值扫描表 +3. 最优配置回测结果对比 +4. 结果保存至 `results.json` + +**`stock_level_filter.py`** (个股级筛选): +1. 3组GAP阈值(2.0/2.5/3.0%)的量子vs经典筛选对比 +2. 分层反转模式验证（个股级 vs 日级 Q/L比） +3. 鲁棒性验证：多refit窗口(3/6/12月) × 多特征集(full/manual)的Q>L稳定性检验 +4. 详细结果保存至 `stock_level_results.json`，汇总结果合并到 `results.json` + +--- + +## 十、技术亮点与局限 + +### 10.1 技术亮点 + +1. **量子核SVM首次应用于A股择时**: 将个股预测问题转化为市场环境判断，巧妙规避了低信噪比难题 +2. **NOOP机制的简洁性**: 不改变信号本身，只在"坏天"跳过交易——类似量子电路中的保险丝，概念简洁但效果显著 +3. **n_reps=1的发现**: 打破"深度电路更强"的直觉，证明在量子核SVM中1层编码的信号保真度最高 +4. **标签降噪方法论**: 按日聚合+0.5%阈值的降噪方案将AUC≈0.5的不可学习问题转化为可学习的日级分类 +5. **统计显著性验证**: 10个seed配对检验(p=0.00004)证实量子优势非偶然 +6. **鲁棒性全面验证**: 9组超参数配置(6买入+3卖出)全部Q>L，量子优势不依赖cherry-picking +7. **买卖结合无协同**: B_only(仅买入端)最优(+1071pp)，买卖双向量子反而产生拮抗效应(-579pp synergy gap) +8. **动态引擎验证与决策函数突破**: 量子副排序在real_bt全动态回测引擎中从Platt概率的+4.8%提升至decision_function的+46.6%(4862万 vs 3316万基线)，经3维plateau验证(C=8~12 × th=0.75~0.77 × val=1.8~2.0共30组配置完全一致)确认非lucky outlier。决策函数绕过Platt sigmoid压缩获得range=1.000的完整分布，高阈值boost(th=0.75)只影响16%最top信心信号却能产生+46.6%超额收益 + +### 10.2 局限性 + +1. **超参数敏感性**: 12组C×n_reps配置中仅3组跑赢基线，量子核SVM对超参数选择敏感（但5c节鲁棒性验证显示6/6买入端配置Q>L，优势方向稳定） +2. **跨策略泛化有限**: 量子NOOP在基础跳空策略上高度有效(+)，但在高级风控策略(V4_EX1)上完全失效 +3. **买卖结合无协同**: 买入端量子排序(B_only)单独使用最优(+1071pp)，叠加卖出端量子调整反而降低收益(协同效应=-579pp) +4. **CPU模拟限制**: 当前使用经典CPU模拟量子电路，6 qubit下核矩阵计算约15秒；真量子硬件可扩展性待验证 +5. **样本外周期**: 4年测试期包含多轮牛熊转换，但仍需更长的市场周期验证稳健性 + +### 10.3 未来方向 + +- 探索更深的量子电路架构(如纠缠层+测量后反馈) +- 在真实量子硬件上验证量子核计算 +- 扩展到多资产、多市场择时 +- 研究量子核与传统因子的融合方法 + +--- + +## 竞赛信息 + +- **赛事**: 2026年CCF量子计算编程挑战赛 — 本源杯·开源创新赛道 +- **PR**: [#35 — Quantum-Enhanced A-Share Stock Selection via Quantum Kernel SVM Market Timing](https://github.com/OriginQ/pyqpanda-algorithm/pull/35) +- **框架**: QPanda3 (合肥本源量子计算科技有限责任公司) +- **许可**: Apache 2.0 + +## 参考文献 + +1. Havlíček, V. et al. (2019). Supervised learning with quantum-enhanced feature spaces. *Nature*, 567, 209-212. +2. Schuld, M. & Killoran, N. (2019). Quantum machine learning in feature Hilbert spaces. *PRL*, 122, 040504. +3. Liu, Y. et al. (2022). A survey of quantum kernel methods. *IEEE TQC*. +4. 本源量子. QPanda3 Documentation. https://qpanda-tutorial.readthedocs.io/ + +--- + +> 作者: 周勋洪 (中国电信资阳分公司) +> 日期: 2026-08-04 diff --git a/quantum_ashare_market_timing/backtest.py b/quantum_ashare_market_timing/backtest.py new file mode 100644 index 00000000..4b85e3d5 --- /dev/null +++ b/quantum_ashare_market_timing/backtest.py @@ -0,0 +1,220 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +资金池回测模块 — NOOP择时回测引擎 +Portfolio Backtest Engine with NOOP Mechanism + +核心创新: NOOP (No-Operation) 市场择时 + - 量子/经典模型预测"今天不适合交易" → 跳过当日所有买入信号 + - 持仓按固定天数到期退出 (不影响卖出) + - 资金池模式: 最大N仓, 每仓=总资产/N, 动态分仓 + +作者: 周勋洪 (中国电信资阳分公司) +日期: 2026-08-02 +""" +import numpy as np +import pandas as pd + + +def run_backtest(signals_df, trading_days, noop_dates=None, + initial_capital=100000, max_positions=5, hold_days=3, + name=""): + """ + 简化资金池回测 + + 交易规则: + 1. 每日开盘: 先平仓到期持仓 + 2. 检查NOOP: 如果今日在noop_dates中 → 不买入, 继续下一日 + 3. 买入: 按跳空%降序选股, 每仓=总资产/max_positions + 4. 卖出: 持仓hold_days天后以收盘价卖出 + + 参数: + signals_df: DataFrame(code, gap_pct, sell_ret, ...) 交易信号 + trading_days: list 交易日列表 (pd.Timestamp) + noop_dates: set NOOP日期集合 (字符串 "YYYY-MM-DD") + initial_capital: 初始资金 + max_positions: 最大持仓数 + hold_days: 持仓天数 + name: 策略名称(用于输出) + + 返回: + result: dict 终值/收益/笔数/胜率/回撤等 + equity_df: DataFrame 每日权益曲线 + trades: DataFrame 交易明细 + """ + noop_dates = noop_dates or set() + + # 按日分组 + 信号强度降序排序 + signals_df = signals_df.copy() + signals_df['_date'] = signals_df.index.normalize() + signals_df = signals_df.sort_values(['_date', 'gap_pct'], ascending=[True, False]) + + # 交易日索引 + day_to_idx = {d: i for i, d in enumerate(trading_days)} + + portfolio = initial_capital + positions = [] # [{exit_idx, capital, sell_ret_pct, code, gap_pct}] + equity_curve = [] + trade_log = [] + + for i, today in enumerate(trading_days): + # 1. 平仓到期持仓 + new_positions = [] + for pos in positions: + if pos['exit_idx'] == i: + portfolio += pos['capital'] * (1 + pos['sell_ret_pct']) + else: + new_positions.append(pos) + positions = new_positions + + # 2. 可用仓位 + available = max_positions - len(positions) + current_equity = portfolio + sum(p['capital'] for p in positions) + + if available <= 0: + equity_curve.append({'date': today, 'equity': current_equity}) + continue + + # 3. NOOP检查 (核心创新: 模型判断今天不适合交易就跳过) + today_str = today.strftime('%Y-%m-%d') + if today_str in noop_dates: + equity_curve.append({'date': today, 'equity': current_equity}) + continue + + # 4. 当日信号 + day_sigs = signals_df[signals_df['_date'] == today] + if len(day_sigs) == 0: + equity_curve.append({'date': today, 'equity': current_equity}) + continue + + # 5. 买入 (信号强度降序已排好) + day_sigs = day_sigs.head(available) + alloc = portfolio / max_positions + + for _, sig in day_sigs.iterrows(): + if portfolio < alloc: + break + portfolio -= alloc + exit_idx = min(i + hold_days, len(trading_days) - 1) + positions.append({ + 'exit_idx': exit_idx, + 'capital': alloc, + 'sell_ret_pct': sig['sell_ret'] - 1.0, + 'code': sig['code'], + 'gap_pct': sig['gap_pct'], + }) + trade_log.append({ + 'date': today_str, + 'code': sig['code'], + 'gap_pct': sig['gap_pct'], + 'sell_ret_pct': sig['sell_ret'] - 1.0, + 'capital': alloc, + }) + + equity_curve.append({ + 'date': today, + 'equity': portfolio + sum(p['capital'] * (1 + p['sell_ret_pct']) for p in positions) + }) + + # 清算剩余持仓 + for pos in positions: + portfolio += pos['capital'] * (1 + pos['sell_ret_pct']) + positions = [] + + # 统计 + trades = pd.DataFrame(trade_log) + n_trades = len(trades) + if n_trades > 0: + win_rate = (trades['sell_ret_pct'] > 0).mean() + avg_ret = trades['sell_ret_pct'].mean() + total_pnl = sum(t['capital'] * t['sell_ret_pct'] for t in trade_log) + else: + win_rate = 0 + avg_ret = 0 + total_pnl = 0 + + equity_df = pd.DataFrame(equity_curve) + if len(equity_df) > 1: + peak = equity_df['equity'].cummax() + dd = (equity_df['equity'] - peak) / peak + max_dd = float(dd.min()) + else: + max_dd = 0.0 + + total_return = (portfolio / initial_capital - 1) * 100 + calmar = abs(total_return / (max_dd * 100)) if max_dd != 0 else 0 + + result = { + 'name': name, + 'final_equity': round(portfolio, 2), + 'total_return': round(total_return, 2), + 'n_trades': n_trades, + 'win_rate': round(win_rate * 100, 2), + 'avg_ret_per_trade': round(avg_ret * 100, 2), + 'total_pnl': round(total_pnl, 2), + 'max_drawdown': round(max_dd * 100, 2), + 'calmar': round(calmar, 2), + } + + print(f" [{name}]") + print(f" 终值: {result['final_equity']:,.0f} (收益 {result['total_return']:+.2f}%)") + print(f" 交易: {result['n_trades']}笔, 胜率={result['win_rate']:.1f}%, " + f"单笔均值={result['avg_ret_per_trade']:+.2f}%") + print(f" 总盈亏: {result['total_pnl']:,.0f}, " + f"最大回撤: {result['max_drawdown']:.1f}%, Calmar={result['calmar']:.2f}") + + return result, equity_df, trades + + +def generate_noop_dates(test_dates, probs, threshold=0.45): + """ + 根据模型预测概率生成NOOP日期集合 + + 规则: prob < threshold → 该日NOOP (不买入) + + 参数: + test_dates: list 测试期日期 ["YYYY-MM-DD", ...] + probs: np.array 模型预测概率 (好天的概率) + threshold: NOOP阈值 (概率低于此值则跳过交易) + + 返回: + noop_dates: set NOOP日期集合 + noop_count: int NOOP天数 + noop_pct: float NOOP比例 + """ + noop_dates = set(d for d, p in zip(test_dates, probs) if p < threshold) + noop_pct = len(noop_dates) / len(test_dates) * 100 if len(test_dates) > 0 else 0 + return noop_dates, len(noop_dates), round(noop_pct, 1) + + +def generate_ensemble_noop(test_dates, probs_dict, thresholds_dict, + mode='AND'): + """ + 集成多模型NOOP (AND门控或OR门控) + + AND门控: 任一模型说NOOP → 跳过 (保守, 交易更少, 质量更高) + OR门控: 所有模型都NOOP → 才跳过 (激进, 交易更多) + + 参数: + test_dates: list 测试期日期 + probs_dict: dict {model_name: probabilities} + thresholds_dict: dict {model_name: threshold} + mode: 'AND' 或 'OR' + + 返回: + noop_dates: set NOOP日期集合 + """ + noop_sets = [] + for model_name, probs in probs_dict.items(): + th = thresholds_dict[model_name] + noop_set = set(d for d, p in zip(test_dates, probs) if p < th) + noop_sets.append(noop_set) + + if mode == 'AND': + # Union: 任一模型NOOP → 跳过 + noop_dates = set().union(*noop_sets) if noop_sets else set() + else: + # Intersection: 所有模型NOOP → 才跳过 + noop_dates = set.intersection(*noop_sets) if noop_sets else set() + + return noop_dates diff --git a/quantum_ashare_market_timing/main.py b/quantum_ashare_market_timing/main.py new file mode 100644 index 00000000..708ef0c1 --- /dev/null +++ b/quantum_ashare_market_timing/main.py @@ -0,0 +1,484 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +量子增强A股选股系统 — 量子核SVM市场择时 +Quantum-Enhanced A-Share Stock Selection via Quantum Kernel SVM Market Timing + +核心创新: + 1. 首次将量子核SVM应用于中国A股市场择时 + 2. NOOP机制: 量子模型预测"不适合交易"的日子→跳过所有买入信号 + 3. Walk-forward扩展窗口验证: 2022-06-01~至今, 6个月refit, 零前视偏差 + 4. 标签降噪: 按日聚合交易信号, 用0.5%收益阈值过滤噪音日 + +框架: QPanda3 (国产量子编程框架) + scikit-learn +作者: 周勋洪 (中国电信资阳分公司) +日期: 2026-08-03 +""" +import sys, os, json, time, warnings, pickle +warnings.filterwarnings('ignore') +import numpy as np +import pandas as pd +from sklearn.svm import SVC +from sklearn.linear_model import LogisticRegression +from sklearn.preprocessing import StandardScaler +from sklearn.metrics import (accuracy_score, f1_score, roc_auc_score) + +# 模块导入 +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from quantum_kernel import (build_angle_encoding, build_zz_feature_map, + compute_quantum_states, quantum_kernel_matrix, + build_classical_kernel) +from market_data import (build_market_features, load_zp_signals, + build_daily_labels, prepare_dataset) +from backtest import (run_backtest, generate_noop_dates, + generate_ensemble_noop) + + +def log(msg): + print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True) + + +def evaluate_model(y_true, y_pred, y_prob=None): + """模型评估""" + m = { + 'acc': float(accuracy_score(y_true, y_pred)), + 'f1': float(f1_score(y_true, y_pred, zero_division=0)), + } + if y_prob is not None: + try: + m['auc'] = float(roc_auc_score(y_true, y_prob)) + except Exception: + m['auc'] = 0.5 + return m + + +def walk_forward_validation(all_daily, market_features, test_start='2022-06-01', + n_qubits=6, n_reps=1, scale=np.pi, q_C=0.1, + feature_selection=True): + """ + Walk-forward扩展窗口验证 + + 方法论: + - 初始训练: test_start之前的全部数据 + - 每6个月refit模型, 训练窗口逐步扩大(只增不减) + - 每段独立训练+预测, 预测结果拼接为完整样本外概率序列 + - StandardScaler仅在对应训练窗口fit, 无前视偏差 + - 特征选择: 当特征数>量子比特数时, SelectKBest(f_classif)选top-k + (仅在训练窗口fit, 零前视偏差) + - 经典LogReg使用全部特征(无qubit限制) + + 参数: + all_daily: DataFrame 按日聚合的交易信号标签 + market_features: DataFrame N维市场特征 (6~16维) + test_start: str 测试期起始日 + n_qubits: 量子比特数 (= 量子模型使用的特征数) + n_reps: 量子电路重复次数 + scale: 特征缩放因子 + q_C: 量子SVM正则化参数 + feature_selection: bool 特征数>n_qubits时是否做选择 + + 返回: + q_probs: np.array 量子模型样本外概率 + lr_probs: np.array 经典LogReg样本外概率 + test_dates: list 日期字符串 + seg_results: list 每段详细结果 + """ + # 动态特征列: market_features的全部列 (向后兼容6~16维) + feature_cols = list(market_features.columns) + n_features = len(feature_cols) + use_feat_sel = feature_selection and n_features > n_qubits + + log(f" 特征数: {n_features}维, 量子qubit: {n_qubits}, " + f"特征选择: {'ON(SelectKBest top-%d)' % n_qubits if use_feat_sel else 'OFF'}") + + # 合并标签和特征 + data = all_daily.join(market_features, how='inner').sort_index() + test_start_ts = pd.Timestamp(test_start) + end_date = data.index[-1] + + # 生成6个月分段 + segments = [] + seg_start = test_start_ts + while seg_start <= end_date: + seg_end = seg_start + pd.DateOffset(months=6) + if seg_end > end_date: + seg_end = end_date + pd.Timedelta(days=1) + segments.append((seg_start, seg_end)) + seg_start = seg_end + + log(f" Walk-forward: {len(segments)}段, 扩展窗口, 测试期 {test_start} ~ {end_date.date()}") + for i, (s, e) in enumerate(segments): + train_n = len(data[data.index < s]) + test_n = len(data[(data.index >= s) & (data.index < e)]) + log(f" Seg {i+1}: train<{s.date()}({train_n}d) test {s.date()}~{e.date()}({test_n}d)") + + q_probs_all, lr_probs_all, test_dates_all = [], [], [] + seg_results = [] + + for seg_idx, (seg_start, seg_end) in enumerate(segments): + train_mask = data.index < seg_start + test_mask = (data.index >= seg_start) & (data.index < seg_end) + + X_train_raw = data.loc[train_mask, feature_cols].values + X_test_raw = data.loc[test_mask, feature_cols].values + y_train = data.loc[train_mask, 'label'].values + y_test = data.loc[test_mask, 'label'].values + + if len(X_train_raw) < 10 or len(X_test_raw) == 0: + log(f" Seg {seg_idx+1}: 跳过(训练={len(X_train_raw)}, 测试={len(X_test_raw)})") + continue + + # === 量子模型: 特征选择 + 标准化 (仅fit训练窗口, 零前视) === + from sklearn.feature_selection import SelectKBest, f_classif + if use_feat_sel: + selector = SelectKBest(f_classif, k=n_qubits) + X_train_q_raw = selector.fit_transform(X_train_raw, y_train) + X_test_q_raw = selector.transform(X_test_raw) + sel_cols = [feature_cols[i] for i in selector.get_support(indices=True)] + else: + X_train_q_raw = X_train_raw + X_test_q_raw = X_test_raw + sel_cols = feature_cols + + scaler_q = StandardScaler() + X_train_q = scaler_q.fit_transform(X_train_q_raw) + X_test_q = scaler_q.transform(X_test_q_raw) + + # === 量子核SVM === + t0 = time.time() + train_states = compute_quantum_states(X_train_q, build_angle_encoding, + n_qubits, n_reps, scale) + test_states = compute_quantum_states(X_test_q, build_angle_encoding, + n_qubits, n_reps, scale) + K_train = quantum_kernel_matrix(train_states) + K_test = quantum_kernel_matrix(train_states, test_states) + qsvm = SVC(kernel='precomputed', C=q_C, probability=True, random_state=42) + qsvm.fit(K_train, y_train) + q_prob = qsvm.predict_proba(K_test)[:, 1] + q_time = time.time() - t0 + + # === 经典LogReg (使用全部特征, 无qubit限制) === + scaler_lr = StandardScaler() + X_train_lr = scaler_lr.fit_transform(X_train_raw) + X_test_lr = scaler_lr.transform(X_test_raw) + lr = LogisticRegression(max_iter=1000, random_state=42) + lr.fit(X_train_lr, y_train) + lr_prob = lr.predict_proba(X_test_lr)[:, 1] + + # 段内评估 + q_pred = (q_prob >= 0.5).astype(int) + lr_pred = (lr_prob >= 0.5).astype(int) + q_acc = float(accuracy_score(y_test, q_pred)) + lr_acc = float(accuracy_score(y_test, lr_pred)) + + try: + q_auc = float(roc_auc_score(y_test, q_prob)) + lr_auc = float(roc_auc_score(y_test, lr_prob)) + except Exception: + q_auc = lr_auc = 0.5 + + seg_dates = [str(d.date()) for d in data.index[test_mask]] + q_probs_all.extend(q_prob) + lr_probs_all.extend(lr_prob) + test_dates_all.extend(seg_dates) + + seg_results.append({ + 'seg': seg_idx + 1, + 'train_size': int(len(y_train)), + 'test_size': int(len(y_test)), + 'q_acc': round(q_acc, 4), + 'lr_acc': round(lr_acc, 4), + 'q_auc': round(q_auc, 4), + 'lr_auc': round(lr_auc, 4), + 'q_time': round(q_time, 1), + 'n_features': n_features, + 'q_features': sel_cols, + }) + + log(f" Seg {seg_idx+1}: train={len(y_train)} test={len(y_test)} " + f"Q_acc={q_acc:.3f} LR_acc={lr_acc:.3f} Q_AUC={q_auc:.3f} LR_AUC={lr_auc:.3f} " + f"({q_time:.1f}s)") + + return (np.array(q_probs_all), np.array(lr_probs_all), + test_dates_all, seg_results) + + +def scan_noop_thresholds(test_dates, q_probs, lr_probs, test_signals, + test_trading_days, thresholds=None): + """ + 扫描量子+经典模型的NOOP阈值, 找到最优配置 + + 参数: + test_dates: list 日期 + q_probs: np.array 量子概率 + lr_probs: np.array 经典概率 + test_signals: DataFrame 测试信号 + test_trading_days: list 交易日 + thresholds: list NOOP阈值列表 + + 返回: + q_results: list 量子扫描结果 + lr_results: list 经典扫描结果 + """ + if thresholds is None: + thresholds = [0.30, 0.35, 0.40, 0.45, 0.50] + + q_results, lr_results = [], [] + + for th in thresholds: + # Quantum + q_noop, q_n, q_pct = generate_noop_dates(test_dates, q_probs, threshold=th) + r_q, _, _ = run_backtest(test_signals, test_trading_days, + noop_dates=q_noop, + name=f"量子NOOP(th={th:.2f})") + q_results.append({'threshold': th, 'noop_pct': q_pct, **r_q}) + + # LogReg + lr_noop, lr_n, lr_pct = generate_noop_dates(test_dates, lr_probs, threshold=th) + r_lr, _, _ = run_backtest(test_signals, test_trading_days, + noop_dates=lr_noop, + name=f"经典LogReg(th={th:.2f})") + lr_results.append({'threshold': th, 'noop_pct': lr_pct, **r_lr}) + + return q_results, lr_results + + +def main(data_path=None, sh_index_path=None): + """ + 主函数: Walk-forward量子核SVM市场择时完整流程 + + 测试期: 2022-06-01 ~ 数据最新日 (~4年, ~1000交易日) + 训练: 扩展窗口, 每6个月refit, 初始训练期2022-01~05 + 回测: 100K初始, 最大5仓, 持仓3天 + 标签: 日均收益>0.5%为好天(降噪阈值) + + 参数: + data_path: all_data.pkl 路径 (个股K线数据, 用于市场广度特征) + sh_index_path: sh000001.pkl 路径 (上证指数) + """ + log("=" * 70) + log("量子增强A股选股系统 — 量子核SVM市场择时") + log("Walk-Forward Validation: 2022-06-01 ~ latest (4-year)") + log("=" * 70) + + # === 默认路径 === + if data_path is None: + data_path = r"D:\TeleClaw的工作空间\.temp\bt_cache_tdx\all_data.pkl" + if sh_index_path is None: + sh_index_path = r"D:\TeleClaw的工作空间\.temp\bt_cache_tdx\sh000001.pkl" + + # === Step 1: 加载数据 === + log("\n[Step 1] 加载数据...") + with open(data_path, 'rb') as f: + all_data = pickle.load(f) + sh_df = pd.read_pickle(sh_index_path) + + log(f" 个股数据: {len(all_data.get('close', {}))}只") + log(f" 上证指数: {len(sh_df)}天 ({sh_df.index[0].date()}~{sh_df.index[-1].date()})") + + # === Step 2: 加载交易信号 === + log("\n[Step 2] 加载交易信号...") + signals_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), + 'trading_signals_sample.pkl') + if not os.path.exists(signals_path): + log(f"信号文件不存在: {signals_path}") + log("请确保 trading_signals_sample.pkl 与本脚本在同一目录。") + return + signals_df = load_zp_signals(signals_path) + if signals_df is None or len(signals_df) == 0: + log("无信号! 请检查信号文件格式。") + return + log(f" 交易信号: {len(signals_df)}个, 正样本率: {signals_df['label'].mean():.1%}") + log(f" 信号日期范围: {signals_df.index[0].date()} ~ {signals_df.index[-1].date()}") + + # === Step 3: 按日聚合标签 (先于特征构建, 因信号层面特征需用daily数据) === + RET_THRESHOLD = 0.005 # 0.5% 标签降噪阈值 + log(f"\n[Step 3] 按日聚合交易信号 → 市场择时标签 (threshold={RET_THRESHOLD*100}%)...") + all_daily = build_daily_labels(signals_df, ret_threshold=RET_THRESHOLD) + log(f" 日标签: {len(all_daily)}天 (正样本率={all_daily['label'].mean():.1%})") + good_avg = all_daily[all_daily['label']==1]['avg_ret_pct'].mean() + bad_avg = all_daily[all_daily['label']==0]['avg_ret_pct'].mean() + log(f" 好天平均收益: {good_avg:+.2f}%") + log(f" 坏天平均收益: {bad_avg:+.2f}%") + + # === Step 4: 构建11维市场特征 (Phase 1确认11维SelectKBest最优) === + log("\n[Step 4] 构建市场特征...") + feats_16 = build_market_features(sh_df, all_data=all_data, signals_daily=all_daily) + # Phase 1实验确认: 11维(上证指数基础6+扩展5)作为SelectKBest起始池优于16维 + # Phase 2-4全部基于此11维+SelectKBest→6q, n_reps=1 → +126.12% + market_feats = feats_16[['bias20', 'ret_5d', 'vol_ratio', 'rsi_5', 'ma_align', + 'range_5d', 'ret_20d', 'vol_ratio_20d', 'ma_trend', + 'vol_rank_60', 'rsi_14']] + log(f" 市场特征: {len(market_feats)}天 × {len(market_feats.columns)}维") + log(f" 特征列: {list(market_feats.columns)}") + + # === Step 5: Walk-forward验证 === + N_QUBITS = 6 + N_REPS = 1 # Phase 2发现: n_reps=1碾压n_reps=2 (+126.12% vs +1.84%) + TEST_START = '2022-06-01' + + log(f"\n[Step 5] Walk-forward验证 ({N_QUBITS} qubits, AngleEncoding)...") + log(f" 测试起始: {TEST_START}") + + q_probs, lr_probs, test_dates, seg_results = walk_forward_validation( + all_daily, market_feats, test_start=TEST_START, + n_qubits=N_QUBITS, n_reps=N_REPS, scale=np.pi, q_C=0.1 + ) + + log(f"\n 样本外预测: {len(q_probs)}天") + log(f" 量子模型平均准确率: {np.mean([s['q_acc'] for s in seg_results]):.3f}") + log(f" 经典模型平均准确率: {np.mean([s['lr_acc'] for s in seg_results]):.3f}") + log(f" 量子核总计算时间: {sum(s['q_time'] for s in seg_results):.1f}s") + + # === Step 6: 准备回测数据 === + log("\n" + "=" * 70) + log(f"[Step 6] NOOP市场择时回测 (100K初始, 最大5仓, 持仓3天)") + log(f" 测试期: {test_dates[0]} ~ {test_dates[-1]} ({len(test_dates)}天)") + log("=" * 70) + + sh_norm = sh_df.copy() + sh_norm.index = sh_norm.index.normalize() + sh_norm = sh_norm[~sh_norm.index.duplicated(keep='last')].sort_index() + trading_days = sorted(sh_norm.index.unique()) + test_start_ts = pd.Timestamp(TEST_START) + test_end_ts = pd.Timestamp(test_dates[-1]) + + test_signals = signals_df[(signals_df.index.normalize() >= test_start_ts) & + (signals_df.index.normalize() <= test_end_ts)].copy() + test_trading_days = [d for d in trading_days if test_start_ts <= d <= test_end_ts] + log(f" 测试信号: {len(test_signals)}个, 交易日: {len(test_trading_days)}") + + # === Step 6a: 基线(无过滤) === + log(f"\n--- 基线(无过滤) ---") + r_base, _, _ = run_backtest( + test_signals, test_trading_days, noop_dates=None, name="基线(无过滤)") + + # === Step 6b: 阈值扫描 === + log(f"\n--- NOOP阈值扫描 (量子 + 经典) ---") + scan_thresholds = [0.30, 0.35, 0.40, 0.45, 0.50] + q_scan, lr_scan = scan_noop_thresholds( + test_dates, q_probs, lr_probs, test_signals, test_trading_days, scan_thresholds) + + # 打印扫描结果 + print(f"\n{'模型':<20} {'阈值':>5} {'NOOP%':>6} {'终值':>10} {'收益%':>8} " + f"{'交易':>5} {'胜率%':>6} {'回撤%':>7} {'Calmar':>7}") + print("-" * 80) + for r in q_scan: + print(f"{'量子NOOP':<20} {r['threshold']:>5.2f} {r['noop_pct']:>5.1f}% " + f"{r['final_equity']:>10,.0f} {r['total_return']:>+8.2f} " + f"{r['n_trades']:>5} {r['win_rate']:>5.1f}% {r['max_drawdown']:>7.1f} " + f"{r['calmar']:>7.2f}") + for r in lr_scan: + print(f"{'经典LogReg':<20} {r['threshold']:>5.2f} {r['noop_pct']:>5.1f}% " + f"{r['final_equity']:>10,.0f} {r['total_return']:>+8.2f} " + f"{r['n_trades']:>5} {r['win_rate']:>5.1f}% {r['max_drawdown']:>7.1f} " + f"{r['calmar']:>7.2f}") + print("-" * 80) + + # 找到量子最优 + best_q = max(q_scan, key=lambda x: x['total_return']) + best_lr = max(lr_scan, key=lambda x: x['total_return']) + log(f"\n 量子最优: th={best_q['threshold']:.2f} → {best_q['total_return']:+.2f}%") + log(f" 经典最优: th={best_lr['threshold']:.2f} → {best_lr['total_return']:+.2f}%") + + # === Step 6c: 最优配置完整回测 === + Q_BEST_TH = best_q['threshold'] + LR_BEST_TH = best_lr['threshold'] + + # 量子最优 + q_noop_best, _, _ = generate_noop_dates(test_dates, q_probs, threshold=Q_BEST_TH) + r_quantum, _, _ = run_backtest( + test_signals, test_trading_days, noop_dates=q_noop_best, + name=f"量子NOOP(th={Q_BEST_TH:.2f})") + + # 经典最优 + lr_noop_best, _, _ = generate_noop_dates(test_dates, lr_probs, threshold=LR_BEST_TH) + r_logreg, _, _ = run_backtest( + test_signals, test_trading_days, noop_dates=lr_noop_best, + name=f"经典LogReg(th={LR_BEST_TH:.2f})") + + # 集成AND门控 (量子+LogReg最优阈值) + log(f"\n--- 量子+经典集成AND门控 ---") + ensemble_noop = generate_ensemble_noop( + test_dates, + probs_dict={'quantum': q_probs, 'logreg': lr_probs}, + thresholds_dict={'quantum': Q_BEST_TH, 'logreg': LR_BEST_TH}, + mode='AND' + ) + log(f" 集成AND NOOP: {len(ensemble_noop)}天 ({len(ensemble_noop)/len(test_dates)*100:.1f}%)") + r_ensemble, _, _ = run_backtest( + test_signals, test_trading_days, noop_dates=ensemble_noop, + name=f"集成AND(q{Q_BEST_TH:.2f}+l{LR_BEST_TH:.2f})") + + # === Step 7: 汇总 === + log("\n" + "=" * 70) + log("[Step 7] 综合对比") + log("=" * 70) + print(f"\n{'策略':<32} {'终值':>10} {'收益%':>8} {'交易':>5} {'胜率%':>6} " + f"{'回撤%':>7} {'Calmar':>7}") + print("-" * 80) + for r in [r_base, r_quantum, r_logreg, r_ensemble]: + print(f"{r['name']:<32} {r['final_equity']:>10,.0f} {r['total_return']:>+8.2f} " + f"{r['n_trades']:>5} {r['win_rate']:>6.1f} {r['max_drawdown']:>7.1f} " + f"{r['calmar']:>7.2f}") + print("-" * 80) + + # 关键结论 + log("\n=== 关键结论 ===") + log(f" 1. Walk-forward验证: {len(test_dates)}天样本外, {len(seg_results)}段refit, 零前视偏差") + log(f" 2. 标签降噪: ret_threshold={RET_THRESHOLD*100}% 过滤噪音日") + log(f" 3. NOOP机制: 基线{r_base['total_return']:+.2f}% → 量子{r_quantum['total_return']:+.2f}%") + log(f" 4. 量子vs经典: 量子{r_quantum['total_return']:+.2f}% vs 经典{r_logreg['total_return']:+.2f}%") + log(f" 5. 量子核平均准确率: {np.mean([s['q_acc'] for s in seg_results]):.1%}") + log(f" 6. 量子核使用QPanda3的QCircuit.matrix()计算态矢量→量子核矩阵") + + # === Step 8: 保存结果 === + output = { + 'system': 'Quantum-Enhanced A-Share Market Timing (Walk-Forward)', + 'framework': 'QPanda3', + 'author': '周勋洪 (中国电信资阳分公司)', + 'date': '2026-08-03', + 'methodology': 'Walk-forward expanding window, 6-month refit, zero look-ahead bias', + 'label_threshold': f'{RET_THRESHOLD*100}%', + 'test_period': f"{test_dates[0]} ~ {test_dates[-1]}", + 'config': { + 'n_qubits': N_QUBITS, + 'n_reps': N_REPS, + 'initial_capital': 100000, + 'max_positions': 5, + 'hold_days': 3, + 'test_start': TEST_START, + 'n_segments': len(seg_results), + 'ret_threshold': RET_THRESHOLD, + }, + 'systematic_optimization': { + 'description': '4-phase systematic optimization (Phase 1-4)', + 'phase1_features': '6→16 dim expansion + SelectKBest; 11dim SelectKBest→6q optimal', + 'phase2_circuit': 'angle_nrep1_C0.1_pi_6q = global optimum (+126.12%); n_reps=1 breakthrough vs n_reps=2 (+1.84%)', + 'phase3_labels': '0.5% binary classification optimal; regression/multiclass/multi-horizon all inferior', + 'phase4_training': '6-month refit + expanding window optimal; monthly refit/rolling window/ensemble/regime all inferior', + 'global_optimal': 'angle_encoding, n_reps=1, C=0.1, scale=pi, 11dim SelectKBest->6q, 0.5% label, 6-month refit, expanding window -> +126.12%', + 'baseline_no_filter': '-76.34%', + }, + 'segment_results': seg_results, + 'threshold_scan': { + 'quantum': q_scan, + 'classical': lr_scan, + }, + 'results': { + 'baseline': r_base, + 'quantum_noop': r_quantum, + 'classical_noop': r_logreg, + 'ensemble': r_ensemble, + } + } + + out_path = os.path.join(os.path.dirname(__file__), 'results.json') + with open(out_path, 'w', encoding='utf-8') as f: + json.dump(output, f, indent=2, ensure_ascii=False, default=str) + log(f"\n结果已保存: {out_path}") + log("\n✓ 完成!") + + +if __name__ == '__main__': + main() diff --git a/quantum_ashare_market_timing/market_data.py b/quantum_ashare_market_timing/market_data.py new file mode 100644 index 00000000..a83edaa4 --- /dev/null +++ b/quantum_ashare_market_timing/market_data.py @@ -0,0 +1,313 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +市场数据与特征工程模块 +Market Data & Feature Engineering for A-Share Market Timing + +功能: + 1. 构建11维市场特征 (零前视: T-1收盘数据, 09:25前可见) + 2. 加载交易信号 → 按日聚合 → 市场择时标签 + 3. 市场广度计算 (涨跌家数比/涨停家数/跌停家数) + +注: 交易信号由外部策略引擎预计算并持久化， + 本模块仅负责加载信号 + 构建市场特征 + 生成标签， + 不包含任何策略选股/择时逻辑。 + +作者: 周勋洪 (中国电信资阳分公司) +日期: 2026-08-03 +""" +import numpy as np +import pandas as pd + + +def build_market_features(sh_df, all_data=None, signals_daily=None): + """ + 构建市场特征 (全部T-1口径, 次日09:25前100%可见, 零前视偏差) + + 基础6维 + 扩展5维 (上证指数T-1) + 市场广度3维 (全市场T-1) + 信号层面2维 (交易信号T-1) + 向后兼容: 不传all_data/signals_daily时仅输出基础+扩展11维 + + 参数: + sh_df: DataFrame(open, high, low, close, volume) 上证指数日线 + all_data: dict (可选) 个股K线数据, 用于计算市场广度 + signals_daily: DataFrame (可选) 按日聚合的交易信号(含n_signals, avg_gap_pct), 用于信号层面特征 + + 返回: + features: DataFrame, 11~16列特征, index=日期 + """ + sh = sh_df.copy() + sh.index = sh.index.normalize() + sh = sh[~sh.index.duplicated(keep='last')] + sh = sh.sort_index() + + # 均线 + ma5 = sh['close'].rolling(5).mean() + ma10 = sh['close'].rolling(10).mean() + ma20 = sh['close'].rolling(20).mean() + ma60 = sh['close'].rolling(60).mean() + + # ========== 基础6维 (T-1 shifted) ========== + + # 1. bias20 (T-1) + bias20 = (sh['close'] - ma20) / ma20 * 100 + feat_bias20 = bias20.shift(1) + + # 2. 5日涨幅 (T-1) + ret_5d = (sh['close'] / sh['close'].shift(5) - 1) * 100 + feat_ret_5d = ret_5d.shift(1) + + # 3. 量比 = 今日量 / 5日均量 (T-1) + vol_5d = sh['volume'].rolling(5).mean() + feat_vol_ratio = (sh['volume'] / vol_5d).shift(1) + + # 4. RSI(5) (T-1) + delta = sh['close'].diff() + gain = delta.clip(lower=0) + loss = (-delta).clip(lower=0) + avg_gain = gain.rolling(5).mean() + avg_loss = loss.rolling(5).mean() + rs = avg_gain / avg_loss.replace(0, np.nan) + rsi = 100 - 100 / (1 + rs) + feat_rsi = rsi.shift(1) + + # 5. MA5偏离MA10 (T-1) + feat_ma_align = ((ma5 - ma10) / ma10 * 100).shift(1) + + # 6. 5日振幅 (T-1) + high_5d = sh['high'].rolling(5).max() + low_5d = sh['low'].rolling(5).min() + feat_range = ((high_5d - low_5d) / sh['close'] * 100).shift(1) + + features = pd.DataFrame({ + 'bias20': feat_bias20, + 'ret_5d': feat_ret_5d, + 'vol_ratio': feat_vol_ratio, + 'rsi_5': feat_rsi, + 'ma_align': feat_ma_align, + 'range_5d': feat_range, + }) + + # ========== 扩展5维 (上证指数, T-1 shifted) ========== + + # 7. ret_20d: 20日涨幅% + ret_20d = (sh['close'] / sh['close'].shift(20) - 1) * 100 + feat_ret_20d = ret_20d.shift(1) + + # 8. vol_ratio_20d: 成交量/20日均量 + vol_20d = sh['volume'].rolling(20).mean() + feat_vol_ratio_20d = (sh['volume'] / vol_20d).shift(1) + + # 9. ma_trend: (MA20-MA60)/MA60*100 + feat_ma_trend = ((ma20 - ma60) / ma60 * 100).shift(1) + + # 10. vol_rank_60: 20日已实现波动率在过去60日的分位 + daily_ret = sh['close'].pct_change() + real_vol_20d = daily_ret.rolling(20).std() * np.sqrt(252) * 100 + vol_rank = real_vol_20d.rolling(60).rank(pct=True) + feat_vol_rank = vol_rank.shift(1) + + # 11. rsi_14: 14日RSI + delta14 = sh['close'].diff() + gain14 = delta14.clip(lower=0) + loss14 = (-delta14).clip(lower=0) + avg_gain14 = gain14.rolling(14).mean() + avg_loss14 = loss14.rolling(14).mean() + rs14 = avg_gain14 / avg_loss14.replace(0, np.nan) + rsi14 = 100 - 100 / (1 + rs14) + feat_rsi_14 = rsi14.shift(1) + + features['ret_20d'] = feat_ret_20d + features['vol_ratio_20d'] = feat_vol_ratio_20d + features['ma_trend'] = feat_ma_trend + features['vol_rank_60'] = feat_vol_rank + features['rsi_14'] = feat_rsi_14 + + # ========== 市场广度3维 (全市场主板个股, T-1 shifted) ========== + if all_data is not None: + closes_dict = all_data.get('close', {}) + breadth = compute_market_breadth(closes_dict) + if breadth is not None: + breadth_shifted = breadth.shift(1) + features = features.join(breadth_shifted, how='inner') + + # ========== 信号层面2维 (交易信号聚合, T-1 shifted) ========== + if signals_daily is not None: + sig_feat = pd.DataFrame(index=signals_daily.index) + sig_feat['n_sig_prev'] = signals_daily['n_signals'] + if 'avg_gap_pct' in signals_daily.columns: + sig_feat['avg_gap_prev'] = signals_daily['avg_gap_pct'] + else: + sig_feat['avg_gap_prev'] = np.nan + sig_feat_shifted = sig_feat.shift(1) + features = features.join(sig_feat_shifted, how='inner') + + features = features.dropna() + return features + + +def compute_market_breadth(closes_dict): + """ + 计算市场广度指标 (全部T-1口径, 次日09:25前可见) + + 从个股收盘价计算每日: + - adv_dec_ratio: 上涨家数/下跌家数 + - limit_up_count: 涨停家数 (主板≥9.5%涨幅) + - limit_down_count: 跌停家数 (主板≤-9.5%跌幅) + + 仅使用主板股票 (排除300创业板/688科创板/8开头北交所) + + 参数: + closes_dict: dict {code: pd.Series} 个股收盘价 + + 返回: + breadth: DataFrame(adv_dec_ratio, limit_up_count, limit_down_count) + """ + # 收集主板股票收盘价 + close_cols = {} + for code in closes_dict: + if code.startswith('300') or code.startswith('688') or code.startswith('8'): + continue + s = closes_dict[code].dropna() + if len(s) < 30: + continue + close_cols[code] = s + + if len(close_cols) < 100: + return None + + # 构建宽表 (日期 × 股票), pandas自动对齐索引 + close_df = pd.DataFrame(close_cols) + close_df.index = close_df.index.normalize() + close_df = close_df.sort_index() + + # 日收益率 + ret_df = close_df.pct_change() + + # 市场广度 + adv = (ret_df > 0).sum(axis=1) + dec = (ret_df < 0).sum(axis=1) + adv_dec_ratio = adv / dec.replace(0, np.nan) + + # 涨停/跌停 (主板10%限制, 用9.5%作为阈值避免四舍五入差异) + limit_up = (ret_df >= 0.095).sum(axis=1) + limit_down = (ret_df <= -0.095).sum(axis=1) + + breadth = pd.DataFrame({ + 'adv_dec_ratio': adv_dec_ratio, + 'limit_up_count': limit_up, + 'limit_down_count': limit_down, + }).dropna() + + return breadth + + +def load_zp_signals(signals_path): + """ + 加载预计算的交易信号 + + 交易信号由外部策略引擎预计算并通过pickle持久化， + 本函数仅负责反序列化加载。信号包含: + - date (index): 信号触发日期 + - code: 股票代码 + - gap_pct: 信号强度指标 + - buy_price: 买入价格 + - sell_price: 卖出价格 + - sell_ret: 收益率(卖出/买入) + - label: 盈亏标签(1=盈利, 0=亏损) + + 信号生成逻辑属于独立商业策略，不在本模块中实现。 + + 参数: + signals_path: str 信号pickle文件路径 + + 返回: + signals_df: DataFrame(code, gap_pct, buy_price, sell_price, sell_ret, label) + """ + with open(signals_path, 'rb') as f: + import pickle + signals_df = pickle.load(f) + return signals_df + + +def build_daily_labels(signals_df, ret_threshold=0.005): + """ + 按日聚合交易信号 → 市场择时标签 + + 对每个交易日: + - label = 1 (好天): 该日所有信号的平均收益 > ret_threshold + - label = 0 (坏天): 该日所有信号的平均收益 <= ret_threshold + + 标签降噪原理: + 个股盈利预测(单笔)噪声大(AUC≈0.5) + 但日均收益跨信号平均显著降噪, 使分类器可学习 + ret_threshold=0.5% 过滤掉"微涨"噪音日, 只标记有意义的上涨日 + + 参数: + signals_df: DataFrame 交易信号 + ret_threshold: float 正标签阈值(日均收益率), 默认0.5% + 0%太弱(4年正样本率45%, 分离度仅0.1%) + 0.5%最优(正样本率41%, 模型可学到有效信号) + + 返回: + daily: DataFrame(n_signals, avg_ret_pct, label, ...) + """ + daily = signals_df.groupby(signals_df.index.normalize()).agg( + n_signals=('label', 'count'), + n_profit=('label', 'sum'), + avg_sell_ret=('sell_ret', 'mean'), + avg_ret_pct=('sell_ret', lambda x: np.mean(x) - 1.0), + avg_gap_pct=('gap_pct', 'mean'), + wr=('label', 'mean'), + ) + daily['label'] = (daily['avg_ret_pct'] > ret_threshold).astype(int) + + return daily + + +def prepare_dataset(signals_df, market_features, train_end='2025-06-30'): + """ + 准备训练/测试数据集 + + 时间分割: + 训练集: ~ train_end (约3年) + 测试集: train_end ~ (约1年, 样本外) + + 返回: + X_train, X_test, y_train, y_test: 特征和标签 + daily_rets_train, daily_rets_test: 日均收益率(用于NOOP评估) + n_sigs_train, n_sigs_test: 日信号数 + test_dates: 测试期日期列表 + """ + daily = build_daily_labels(signals_df) + daily = daily.join(market_features, how='inner') + + # 动态特征列: market_features的全部列即为特征 (向后兼容6~16维) + feature_cols = list(market_features.columns) + X = daily[feature_cols].values.astype(np.float64) + y = daily['label'].values.astype(np.int32) + daily_rets = daily['avg_ret_pct'].values + n_sigs = daily['n_signals'].values + + train_mask = daily.index <= pd.Timestamp(train_end) + test_mask = ~train_mask + + from sklearn.preprocessing import StandardScaler + scaler = StandardScaler() + X_scaled = scaler.fit_transform(X) + + X_train, X_test = X_scaled[train_mask], X_scaled[test_mask] + y_train, y_test = y[train_mask], y[test_mask] + rets_train, rets_test = daily_rets[train_mask], daily_rets[test_mask] + n_sigs_train, n_sigs_test = n_sigs[train_mask], n_sigs[test_mask] + test_dates = [str(d.date()) for d in daily.index[test_mask]] + + return { + 'X_train': X_train, 'X_test': X_test, + 'y_train': y_train, 'y_test': y_test, + 'rets_train': rets_train, 'rets_test': rets_test, + 'n_sigs_train': n_sigs_train, 'n_sigs_test': n_sigs_test, + 'test_dates': test_dates, + 'daily': daily, + 'scaler': scaler, + 'feature_cols': feature_cols, + } diff --git a/quantum_ashare_market_timing/quantum_b_only_qprob_map.json b/quantum_ashare_market_timing/quantum_b_only_qprob_map.json new file mode 100644 index 00000000..64bc84db --- /dev/null +++ b/quantum_ashare_market_timing/quantum_b_only_qprob_map.json @@ -0,0 +1,393 @@ +{ + "003021.SZ|2022-06-01": 0.5, + "000151.SZ|2022-06-01": 0.5, + "605128.SH|2022-06-06": 0.5, + "600438.SH|2022-06-07": 0.5, + "600603.SH|2022-06-09": 0.5, + "002791.SZ|2022-06-20": 0.5, + "000810.SZ|2022-06-22": 0.5, + "601888.SH|2022-06-27": 0.5, + "002922.SZ|2022-07-05": 0.5, + "002837.SZ|2022-07-08": 0.5, + "002993.SZ|2022-07-14": 0.5, + "002514.SZ|2022-07-15": 0.5, + "603067.SH|2022-07-18": 0.5, + "000826.SZ|2022-07-19": 0.5, + "002204.SZ|2022-07-21": 0.5, + "605208.SH|2022-07-27": 0.5, + "002077.SZ|2022-08-03": 0.5, + "603330.SH|2022-08-09": 0.5, + "003031.SZ|2022-08-12": 0.5, + "000980.SZ|2022-08-22": 0.5, + "002047.SZ|2022-08-24": 0.5, + "002860.SZ|2022-08-26": 0.5, + "600992.SH|2022-09-02": 0.5, + "600875.SH|2022-09-05": 0.5, + "601975.SH|2022-09-05": 0.5, + "002051.SZ|2022-09-06": 0.5, + "600576.SH|2022-09-09": 0.5, + "002338.SZ|2022-09-20": 0.5, + "002865.SZ|2022-09-28": 0.5, + "000948.SZ|2022-10-11": 0.5, + "603676.SH|2022-10-18": 0.5, + "603283.SH|2022-10-21": 0.5, + "600369.SH|2022-10-21": 0.5, + "002430.SZ|2022-10-25": 0.5, + "003005.SZ|2022-11-03": 0.5, + "603556.SH|2022-11-04": 0.5, + "002508.SZ|2022-11-14": 0.5, + "002602.SZ|2022-11-17": 0.5, + "002647.SZ|2022-11-25": 0.5, + "002307.SZ|2022-11-30": 0.5, + "605598.SH|2022-12-05": 0.6197293160830728, + "002315.SZ|2022-12-08": 0.39069690354358505, + "000989.SZ|2022-12-09": 0.3120496847331114, + "600965.SH|2022-12-16": 0.3486075093368889, + "603217.SH|2022-12-22": 2.7581855994592215, + "002528.SZ|2022-12-23": 0.5154455741861657, + "603000.SH|2022-12-27": 2.8516744044354763, + "002043.SZ|2023-01-05": 0.44042517840867973, + "603806.SH|2023-01-06": 0.5575041102067181, + "000739.SZ|2023-01-11": 0.6152770563191566, + "002221.SZ|2023-01-19": 0.4628235946791281, + "002635.SZ|2023-01-31": 0.29827496717877955, + "002668.SZ|2023-02-08": -1.8193498791885074, + "000629.SZ|2023-02-13": 0.657009349833097, + "605198.SH|2023-02-16": 2.8170197874484164, + "002104.SZ|2023-02-17": -2.0, + "002229.SZ|2023-02-24": 2.7946011121381784, + "000652.SZ|2023-03-03": 3.0, + "601199.SH|2023-03-09": 0.3177120095715803, + "000028.SZ|2023-03-16": 0.575666293580081, + "000975.SZ|2023-03-20": 0.4199817806409636, + "603108.SH|2023-03-21": 0.704669951309288, + "603083.SH|2023-03-27": 0.696684376920333, + "603881.SH|2023-03-28": 0.6851948958720047, + "002690.SZ|2023-03-31": 0.39981297803342514, + "002837.SZ|2023-04-11": 0.40089016572666386, + "002919.SZ|2023-04-13": 0.7278733766679154, + "600547.SH|2023-04-14": 0.4403096358498422, + "601949.SH|2023-04-24": 0.7127068659780289, + "002315.SZ|2023-04-27": 0.6843631837938551, + "601319.SH|2023-04-28": 0.551203762981788, + "601199.SH|2023-04-28": 0.5603141832068322, + "002099.SZ|2023-05-16": 2.8588575542541985, + "603112.SH|2023-05-17": 0.5847230630660366, + "002641.SZ|2023-05-26": 0.733466707059272, + "002965.SZ|2023-05-30": 0.6879254290902856, + "002229.SZ|2023-06-05": 2.910025839147559, + "002929.SZ|2023-06-06": -1.7721766528068734, + "600633.SH|2023-06-12": 0.4334481561501638, + "000936.SZ|2023-06-13": 0.6290946145949564, + "600136.SH|2023-06-19": -1.889262706712828, + "002055.SZ|2023-06-20": 3.0, + "600711.SH|2023-07-04": -1.834321624345919, + "000963.SZ|2023-07-05": 0.4494015994815966, + "600707.SH|2023-07-17": 2.9486295500245254, + "002036.SZ|2023-07-18": -1.7780920187188456, + "603208.SH|2023-07-31": 0.6736303477999315, + "603833.SH|2023-07-31": 0.7253334393848373, + "603569.SH|2023-08-15": 0.5941052660990729, + "000826.SZ|2023-08-18": 0.490835486871184, + "003028.SZ|2023-08-18": 2.999065998211248, + "603198.SH|2023-08-28": 0.40126301982167784, + "000766.SZ|2023-09-01": 2.918164024354289, + "000933.SZ|2023-09-04": 2.764467875220091, + "600839.SH|2023-09-13": 0.6906653184448115, + "601127.SH|2023-09-15": 0.7465706910186456, + "002855.SZ|2023-09-26": 0.6791069109641977, + "000426.SZ|2023-10-09": 0.4733383906142378, + "002194.SZ|2023-10-11": -2.0, + "002907.SZ|2023-10-12": 0.6950630136221734, + "002077.SZ|2023-10-20": 0.676644333524681, + "603178.SH|2023-10-25": -1.8507994916872863, + "600071.SH|2023-10-26": 2.7742314403314565, + "002156.SZ|2023-11-02": 2.773439065350414, + "000525.SZ|2023-11-07": 0.7025583982559179, + "002908.SZ|2023-11-15": 2.771842820656609, + "002892.SZ|2023-11-20": -1.825183082334825, + "603297.SH|2023-11-24": 0.6813655039344659, + "002919.SZ|2023-11-28": -1.7618625238916281, + "600640.SH|2023-12-07": 0.652219025357246, + "002962.SZ|2023-12-11": 0.7377404498171913, + "002755.SZ|2023-12-12": 0.4593240131662538, + "600605.SH|2023-12-25": 0.5543632310148837, + "600679.SH|2023-12-27": 0.7277261225172333, + "603977.SH|2024-01-09": 0.5367878853923804, + "603032.SH|2024-01-11": 0.4477367769717789, + "002533.SZ|2024-01-17": 0.714632306357975, + "000550.SZ|2024-01-22": 0.6377408632213686, + "000037.SZ|2024-01-30": -1.8706583283943097, + "600446.SH|2024-02-05": 2.9485337460128074, + "603960.SH|2024-02-08": 2.864779423379833, + "601138.SH|2024-02-22": 0.6749274262043959, + "601127.SH|2024-02-27": 2.8733641202073086, + "002049.SZ|2024-02-28": 2.8747595713400735, + "600589.SH|2024-03-06": 0.7414331443714364, + "002544.SZ|2024-03-13": 2.8711078193755, + "000603.SZ|2024-03-14": 0.6541318459087132, + "600667.SH|2024-03-19": 0.4818729272650703, + "600489.SH|2024-03-21": 2.7924695375545467, + "600547.SH|2024-03-29": -2.0, + "603408.SH|2024-04-01": 0.6056360171942783, + "600301.SH|2024-04-08": 3.0, + "000869.SZ|2024-04-12": 2.8809573744934722, + "000099.SZ|2024-04-19": 2.878254499066406, + "000960.SZ|2024-04-22": 2.821783069463975, + "600299.SH|2024-04-26": 0.6399032953036011, + "000990.SZ|2024-05-08": 2.7965366126518125, + "002938.SZ|2024-05-14": 2.900119708811301, + "000560.SZ|2024-05-22": 0.44044714956070774, + "002851.SZ|2024-05-27": 0.655797791705582, + "601020.SH|2024-05-28": 0.720871231180811, + "002182.SZ|2024-05-30": 0.63011384192533, + "601919.SH|2024-06-06": 0.6780082334131516, + "600246.SH|2024-06-13": 2.83166323845184, + "603936.SH|2024-06-25": 2.7917740750075164, + "002384.SZ|2024-07-03": 0.4889757782444648, + "002428.SZ|2024-07-08": 0.3875914861188888, + "002384.SZ|2024-07-10": 0.5006984548004997, + "002938.SZ|2024-07-11": -1.7554823474335435, + "600361.SH|2024-07-16": 0.7074382383988692, + "600611.SH|2024-07-24": 0.47333065158140386, + "600611.SH|2024-07-26": -2.0, + "600686.SH|2024-07-29": 0.7073833070005451, + "600609.SH|2024-07-31": 0.6284209217162939, + "000524.SZ|2024-08-05": 0.6999445294886651, + "002755.SZ|2024-08-13": 0.3005766197147057, + "600576.SH|2024-08-16": 0.5731342181492969, + "600552.SH|2024-08-27": 2.7690288829287395, + "600375.SH|2024-08-28": 2.804826666824973, + "002444.SZ|2024-08-30": 2.873629658871642, + "000525.SZ|2024-09-10": 0.5385697583907166, + "002243.SZ|2024-09-18": 0.4667102401649804, + "000158.SZ|2024-09-26": 3.0, + "600435.SH|2024-09-30": 0.6898274952903506, + "600650.SH|2024-10-09": 2.9335296820929107, + "603636.SH|2024-10-10": 0.7368450177022062, + "002625.SZ|2024-10-18": 0.525844583054303, + "002583.SZ|2024-10-23": 0.44983475980036713, + "002050.SZ|2024-10-24": 2.905487592594655, + "000151.SZ|2024-11-01": 0.547638486606505, + "600259.SH|2024-11-04": 0.2569115770205443, + "603007.SH|2024-11-06": -1.8587184844815388, + "603005.SH|2024-11-13": 0.35660444429047217, + "002611.SZ|2024-11-15": 2.887201922356094, + "000912.SZ|2024-11-26": 2.8738755010061263, + "600478.SH|2024-11-26": 0.5742199643381056, + "002047.SZ|2024-12-04": 2.9124746411780675, + "600571.SH|2024-12-09": -1.8100619174333537, + "000785.SZ|2024-12-09": -2.0, + "002251.SZ|2024-12-17": 0.5305898270123258, + "002122.SZ|2024-12-23": 0.634499104397211, + "000759.SZ|2024-12-30": -1.942022104206568, + "002881.SZ|2025-01-03": 0.7440082461520204, + "600066.SH|2025-01-06": 0.695311248445811, + "600673.SH|2025-01-08": 2.915175415433418, + "002187.SZ|2025-01-17": 0.36603578186399005, + "605056.SH|2025-01-21": 0.6735955689347494, + "002284.SZ|2025-02-07": -1.7816557430498718, + "002131.SZ|2025-02-11": -1.903850229320328, + "603583.SH|2025-02-20": 0.310723030127832, + "600313.SH|2025-02-24": 0.41517808013155216, + "600330.SH|2025-03-07": 0.7114298651322185, + "600592.SH|2025-03-07": 0.5899508179645753, + "002367.SZ|2025-03-10": 0.293474399560979, + "600176.SH|2025-03-20": 0.6585457611200423, + "002124.SZ|2025-03-21": 0.6541527137184155, + "600059.SH|2025-04-02": 0.3657395757557889, + "002165.SZ|2025-04-07": 0.5527580293490082, + "603267.SH|2025-04-10": 0.449991854589903, + "605499.SH|2025-04-16": 0.37572460502185107, + "002052.SZ|2025-04-24": 3.0, + "603379.SH|2025-04-29": 0.545845196279827, + "002650.SZ|2025-04-30": 0.29166024145790337, + "002650.SZ|2025-05-09": 0.5471288564768289, + "600610.SH|2025-05-15": 2.8458014841309383, + "002103.SZ|2025-05-21": 0.7252245571322982, + "600055.SH|2025-05-22": 0.320325044518253, + "600530.SH|2025-05-28": 0.5489367952607513, + "600259.SH|2025-06-05": 0.5263249705326148, + "603918.SH|2025-06-11": -1.8338023845895872, + "601015.SH|2025-06-16": 0.29425693172485223, + "002940.SZ|2025-06-17": -1.967892996469321, + "002882.SZ|2025-06-24": 3.0, + "600610.SH|2025-06-25": 0.27330949535254057, + "600435.SH|2025-06-27": -1.821587197199905, + "600732.SH|2025-06-30": -1.9255332703001273, + "002080.SZ|2025-07-02": -1.798711840486029, + "000920.SZ|2025-07-08": 0.27406706965304606, + "002067.SZ|2025-07-09": 0.5496497472452248, + "600869.SH|2025-07-11": 0.515747063095235, + "600183.SH|2025-07-15": 0.6614141894174069, + "600777.SH|2025-07-22": 0.5795004305484429, + "601179.SH|2025-07-22": 0.5252866872879656, + "002897.SZ|2025-07-28": -1.7834887925282672, + "002370.SZ|2025-08-04": 2.7628436740716005, + "603280.SH|2025-08-04": -1.7580190138123273, + "603800.SH|2025-08-08": 0.32691555185612037, + "002920.SZ|2025-08-12": 0.6141600654226346, + "600298.SH|2025-08-15": -1.9422483591309285, + "002664.SZ|2025-08-18": 0.4585891700110753, + "002131.SZ|2025-08-19": 0.5110616192877352, + "600360.SH|2025-08-20": -1.8564142425766257, + "601059.SH|2025-08-25": 0.364813958139462, + "601877.SH|2025-08-28": 2.773812402611634, + "603200.SH|2025-09-02": -1.8772413805850112, + "000558.SZ|2025-09-05": -1.7643718744357249, + "002516.SZ|2025-09-09": 2.780971093608722, + "601869.SH|2025-09-10": 0.40176153814745613, + "603686.SH|2025-09-19": 0.4109089519943208, + "603389.SH|2025-09-22": -1.8306265386243155, + "000981.SZ|2025-09-23": 0.5366361658750972, + "605488.SH|2025-09-24": 0.3926126803176449, + "002020.SZ|2025-09-25": 0.43128890784793855, + "000603.SZ|2025-09-29": 0.4345109026582986, + "002716.SZ|2025-09-29": 0.3272406887562397, + "002534.SZ|2025-10-09": 0.5660766825158763, + "002039.SZ|2025-10-13": -1.7796840825869513, + "603389.SH|2025-10-15": 2.9107458112980473, + "000006.SZ|2025-10-22": -2.0, + "002957.SZ|2025-10-23": 0.6783628058602852, + "603703.SH|2025-10-24": -1.9748365272119277, + "000908.SZ|2025-10-28": 0.5741904473936217, + "002367.SZ|2025-10-28": -1.8506509102141402, + "600078.SH|2025-11-06": 0.6546108089724517, + "002768.SZ|2025-11-10": 0.31017889535143756, + "002544.SZ|2025-11-10": -1.9084513548360522, + "600586.SH|2025-11-11": 0.5314453086404571, + "002384.SZ|2025-11-11": 2.8994613679450167, + "000620.SZ|2025-11-11": 2.8994297165583878, + "600996.SH|2025-11-24": -1.9766965047372964, + "600635.SH|2025-11-26": 2.756797445848337, + "002596.SZ|2025-11-27": 0.3296220294420144, + "600301.SH|2025-11-27": -1.972629626694216, + "000697.SZ|2025-12-01": 0.49908707093016536, + "000603.SZ|2025-12-10": 0.5650626330183408, + "605339.SH|2025-12-10": 0.4969327856931922, + "000950.SZ|2025-12-12": -1.83683325534193, + "600151.SH|2025-12-15": 0.7153494368035908, + "600686.SH|2025-12-16": 0.3310779532205911, + "603163.SH|2025-12-23": 0.4976501417547457, + "002851.SZ|2025-12-24": 0.5918477511061047, + "002202.SZ|2025-12-26": 2.831314919470515, + "603186.SH|2025-12-29": 0.5987409841633807, + "600879.SH|2026-01-05": 3.0, + "002709.SZ|2026-01-05": 0.4693631879662691, + "600198.SH|2026-01-08": 2.8548936601598633, + "600973.SH|2026-01-12": 0.5807354392518985, + "603305.SH|2026-01-13": 0.6840865849635234, + "002545.SZ|2026-01-16": 0.4917882967351983, + "605099.SH|2026-01-21": 0.5349034004975761, + "000603.SZ|2026-01-23": 0.4180875267742896, + "600531.SH|2026-01-23": 0.7468084067605941, + "002727.SZ|2026-01-27": 0.6384744032944134, + "605056.SH|2026-01-27": 0.4926802989527007, + "603103.SH|2026-01-30": -1.8060258770279813, + "603881.SH|2026-01-30": 0.6423194137248711, + "000962.SZ|2026-02-04": 2.8385164657504345, + "600522.SH|2026-02-09": 0.282343392711632, + "000821.SZ|2026-02-09": 0.5826969379847646, + "603301.SH|2026-02-10": 0.44224307666168533, + "600479.SH|2026-02-10": 0.570591178598427, + "000711.SZ|2026-02-26": 0.3262692895098548, + "002378.SZ|2026-02-27": 0.5963541955201656, + "600259.SH|2026-03-02": 0.26250281151095173, + "000510.SZ|2026-03-02": 0.7248682853869554, + "603186.SH|2026-03-03": 0.6732744400326949, + "002384.SZ|2026-03-03": 0.45879222844748874, + "601179.SH|2026-03-06": 0.33279304911589697, + "002150.SZ|2026-03-12": -2.0, + "600509.SH|2026-03-13": 2.8232586979099645, + "000600.SZ|2026-03-13": 0.43144561405758564, + "601101.SH|2026-03-13": 2.7678055895675673, + "600123.SH|2026-03-16": 0.4148880855857494, + "600313.SH|2026-03-19": 0.6349263149164462, + "603115.SH|2026-03-26": 0.4368077457634729, + "603538.SH|2026-03-26": 0.5241406052164131, + "600513.SH|2026-03-30": 0.5201135551239586, + "603618.SH|2026-03-30": 0.6157652576812581, + "002648.SZ|2026-03-30": 0.6658966254613364, + "000048.SZ|2026-03-31": 0.3726645501086052, + "002713.SZ|2026-03-31": 2.7652930882454845, + "002675.SZ|2026-03-31": 2.9126738615108807, + "002432.SZ|2026-04-01": 0.5089557110986704, + "002528.SZ|2026-04-09": 2.831499520500552, + "600897.SH|2026-04-13": -1.8650914706535886, + "600666.SH|2026-04-14": 0.289013105289496, + "002240.SZ|2026-04-14": 0.5975460963013206, + "603220.SH|2026-04-14": 0.491631321255743, + "605580.SH|2026-04-16": 0.5044467385969652, + "002580.SZ|2026-04-17": -1.8025281895704737, + "603052.SH|2026-04-17": 0.5246506949592895, + "002271.SZ|2026-04-17": 0.464358238368756, + "003041.SZ|2026-04-20": 0.299324617070817, + "002466.SZ|2026-04-21": 0.506922146524087, + "002606.SZ|2026-04-24": 0.43569105780292977, + "002384.SZ|2026-04-24": 0.3648145773023163, + "603773.SH|2026-04-28": 0.6035130126786169, + "605168.SH|2026-04-29": -1.7554866602714114, + "002851.SZ|2026-04-30": 0.32758623627581385, + "002256.SZ|2026-05-11": 0.5827415461800963, + "603986.SH|2026-05-11": 0.4364110974677305, + "002156.SZ|2026-05-11": 0.6285438583039724, + "000767.SZ|2026-05-13": 0.34362201883549054, + "002289.SZ|2026-05-13": 0.38902233110759116, + "002938.SZ|2026-05-14": 0.6070211492739415, + "603156.SH|2026-05-18": 0.6251225117427344, + "603115.SH|2026-05-19": 0.29686612884424846, + "603938.SH|2026-05-20": 0.5675277437448156, + "002138.SZ|2026-05-20": 0.5338066330615864, + "002885.SZ|2026-05-21": 0.6822815468664665, + "002916.SZ|2026-05-22": -1.8188464253936496, + "002484.SZ|2026-05-22": 0.5606414579563962, + "600367.SH|2026-05-25": 0.37396058534419313, + "600378.SH|2026-05-27": 0.3585912497061101, + "002718.SZ|2026-05-27": 0.5059123820040112, + "600183.SH|2026-05-27": 0.47765482141757787, + "605111.SH|2026-05-28": 0.6264898992245315, + "601138.SH|2026-05-29": 0.41314410264335005, + "002975.SZ|2026-06-01": 2.7891658645006836, + "003004.SZ|2026-06-02": 0.35703020365684224, + "002421.SZ|2026-06-02": 0.5860147724732453, + "603938.SH|2026-06-09": 0.5350370233976149, + "600487.SH|2026-06-09": 2.838032503291686, + "002421.SZ|2026-06-09": 0.3930603944531089, + "002138.SZ|2026-06-09": 0.38944232789830396, + "601208.SH|2026-06-10": 0.4947758547955115, + "605358.SH|2026-06-10": 0.30856458216174676, + "600397.SH|2026-06-15": 0.5031181516346077, + "000636.SZ|2026-06-16": 0.4277178431065681, + "603186.SH|2026-06-17": 3.0, + "002051.SZ|2026-06-17": 2.76681899568735, + "603663.SH|2026-06-22": 0.6617201488722435, + "601869.SH|2026-06-22": 0.4371253984133459, + "600498.SH|2026-06-22": 0.49923569643244126, + "603595.SH|2026-06-23": 0.5827466541852959, + "002289.SZ|2026-06-24": 0.4135139327827454, + "603936.SH|2026-06-24": -2.0, + "600531.SH|2026-06-24": 0.5094121761075071, + "601133.SH|2026-06-25": 0.4682720919219251, + "603061.SH|2026-06-25": -1.8165419370443896, + "603986.SH|2026-06-25": 0.2835780127852088, + "600888.SH|2026-06-26": 0.5174926851096313, + "600458.SH|2026-06-26": 2.8224018369644233, + "600460.SH|2026-06-29": 0.5015813696110589, + "603950.SH|2026-06-30": 0.46885111538759977, + "002409.SZ|2026-06-30": 0.3941346275926582, + "605111.SH|2026-07-01": 0.5608729775340915, + "603950.SH|2026-07-01": 0.4166416577288297, + "002747.SZ|2026-07-01": 0.5941703662273091, + "000571.SZ|2026-07-02": -1.7781761209113767, + "000970.SZ|2026-07-03": 0.6605318159251788, + "002520.SZ|2026-07-06": 0.2557105201318903, + "000620.SZ|2026-07-06": 0.46296420599201366, + "002192.SZ|2026-07-07": 0.7294065163644857, + "605060.SH|2026-07-07": 0.5711517776970955, + "002025.SZ|2026-07-08": 0.6920757562185447, + "002536.SZ|2026-07-10": 0.4812356229994698, + "603501.SH|2026-07-15": 0.5411027002024008, + "002558.SZ|2026-07-16": 0.43598589729182846, + "603567.SH|2026-07-17": 0.41698666967066433, + "600971.SH|2026-07-20": -1.7749308548922322 +} \ No newline at end of file diff --git a/quantum_ashare_market_timing/quantum_kernel.py b/quantum_ashare_market_timing/quantum_kernel.py new file mode 100644 index 00000000..4eddfe58 --- /dev/null +++ b/quantum_ashare_market_timing/quantum_kernel.py @@ -0,0 +1,189 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +量子核计算模块 — 基于QPanda3的量子核SVM +Quantum Kernel Module for A-Share Market Timing + +核心API: + QCircuit.matrix() → 量子态矢量 → 量子核矩阵 K[i,j] = |<ψ_i|ψ_j>|² + +作者: 周勋洪 (中国电信资阳分公司) +日期: 2026-08-02 +""" +import numpy as np +import pyqpanda3.core as pq + + +def build_angle_encoding(features, n_qubits, n_reps=2): + """ + AngleEncoding: Hadamard + RZ(2x) 量子编码 + + 将n维经典特征编码到n个量子比特: + 1. 对每个比特施加Hadamard门 → 均匀叠加态 + 2. 施加RZ(2*x_j)旋转门 → 将特征值编码到相位中 + + 优势: 无纠缠，计算高效，核矩阵区分度最高 + """ + circ = pq.QCircuit(n_qubits) + q = list(range(n_qubits)) + for rep in range(n_reps): + if rep == 0: + for j in range(n_qubits): + circ << pq.H(q[j]) + for j in range(n_qubits): + circ << pq.RZ(q[j], float(features[j] * 2)) + return circ + + +def build_zz_feature_map(features, n_qubits, n_reps=2): + """ + ZZFeatureMap: Hadamard + RZ + CNOT+RZ纠缠 量子编码 + + 经典IBM QSVM的ZZFeatureMap实现: + 1. Hadamard层 → 均匀叠加 + 2. RZ(2*x_j)层 → 单比特旋转 + 3. CNOT(i,j) + RZ(2*(π-x_i)*(π-x_j)) → 两比特纠缠 + + 优势: 包含纠缠层，可捕获特征间非线性交互 + """ + circ = pq.QCircuit(n_qubits) + q = list(range(n_qubits)) + for rep in range(n_reps): + # Step 1: Hadamard layer + for j in range(n_qubits): + circ << pq.H(q[j]) + # Step 2: RZ rotation + for j in range(n_qubits): + circ << pq.RZ(q[j], float(features[j] * 2)) + # Step 3: Entanglement (linear topology) + for j in range(n_qubits - 1): + circ << pq.CNOT(q[j], q[j + 1]) + angle = float(2 * (np.pi - features[j]) * (np.pi - features[j + 1])) + circ << pq.RZ(q[j + 1], angle) + circ << pq.CNOT(q[j], q[j + 1]) + return circ + + +def compute_quantum_states(X, builder, n_qubits, n_reps=2, scale=np.pi): + """ + 计算每个样本的量子态矢量 |ψ(x)> = U(x)|0⟩ + + 利用QPanda3的QCircuit.matrix()方法: + - matrix()返回酉矩阵 U (shape: 2^n × 2^n) + - 取第一列即为 |ψ(x)> = U|0...0⟩ + + 参数: + X: (N, d) 经典特征矩阵 (已标准化) + builder: 量子电路构建函数 (build_angle_encoding 或 build_zz_feature_map) + n_qubits: 量子比特数 (= 特征维度) + n_reps: 量子电路重复次数 + scale: 特征缩放因子 (π/2, π, 2π) + + 返回: + states: (N, 2^n) 复数态矢量矩阵 + """ + Xs = X * scale + states = [] + for i in range(len(Xs)): + circ = builder(Xs[i], n_qubits, n_reps) + mat = np.array(circ.matrix(), dtype=complex) + states.append(mat[:, 0]) # 第一列 = |ψ(x)> = U|0⟩ + return np.array(states) + + +def quantum_kernel_matrix(train_states, test_states=None): + """ + 计算量子核矩阵 K[i,j] = |<ψ_i|ψ_j>|² + + 量子核定义为两个量子态的内积模平方: + K(x_i, x_j) = |⟨ψ(x_i)|ψ(x_j)⟩|² = |ψ_i† @ ψ_j|² + + 性质: + - K[i,i] = 1 (自核=1) + - K[i,j] ∈ [0, 1] (非负, 有界) + - K是对称半正定矩阵 (满足Mercer定理) + + 参数: + train_states: (N_train, 2^n) 训练集态矢量 + test_states: (N_test, 2^n) 测试集态矢量 (None=用训练集自身) + + 返回: + K: (N_test, N_train) 量子核矩阵 + """ + if test_states is None: + overlap = train_states.conj() @ train_states.T + else: + overlap = test_states.conj() @ train_states.T + K = np.abs(overlap) ** 2 + K = np.clip(K, 0, 1) + if test_states is None: + np.fill_diagonal(K, 1.0) + return K + + +def build_classical_kernel(X_train, X_test=None, kernel='rbf', gamma='scale'): + """ + 经典核基线 (用于与量子核对比) + + 参数: + X_train: (N_train, d) 训练特征 + X_test: (N_test, d) 测试特征 (None=用训练集自身) + kernel: 'rbf' 或 'linear' + gamma: RBF核的γ参数 + + 返回: + K: (N_test, N_train) 经典核矩阵 + """ + from sklearn.metrics.pairwise import rbf_kernel, linear_kernel + # 处理 gamma='scale' (1/(n_features*X.var())) 和 'auto' (1/n_features) + if isinstance(gamma, str): + n_features = X_train.shape[1] + if gamma == 'scale': + gamma = 1.0 / (n_features * X_train.var()) + else: # 'auto' + gamma = 1.0 / n_features + if kernel == 'rbf': + if X_test is None: + return rbf_kernel(X_train, X_train, gamma=gamma) + return rbf_kernel(X_test, X_train, gamma=gamma) + else: + if X_test is None: + return linear_kernel(X_train, X_train) + return linear_kernel(X_test, X_train) + + +# ============================================================ +# 测试代码 +# ============================================================ +if __name__ == '__main__': + print("=== 量子核计算模块测试 ===\n") + + # 生成4维测试数据 + np.random.seed(42) + X = np.random.randn(5, 4) + + # AngleEncoding + print("1. AngleEncoding (4 qubits)") + states = compute_quantum_states(X, build_angle_encoding, n_qubits=4, n_reps=2) + print(f" 态矢量矩阵: {states.shape}") + K = quantum_kernel_matrix(states) + print(f" 核矩阵: {K.shape}") + print(f" 对角线: {np.diag(K)}") + print(f" 非对角线均值: {K[~np.eye(5, dtype=bool)].mean():.4f}") + print(f" 非对角线标准差: {K[~np.eye(5, dtype=bool)].std():.4f}") + print(f" 区分度(std/mean): {K[~np.eye(5, dtype=bool)].std()/K[~np.eye(5, dtype=bool)].mean():.4f}") + + # ZZFeatureMap + print("\n2. ZZFeatureMap (4 qubits)") + states_zz = compute_quantum_states(X, build_zz_feature_map, n_qubits=4, n_reps=2) + K_zz = quantum_kernel_matrix(states_zz) + print(f" 核矩阵: {K_zz.shape}") + print(f" 区分度: {K_zz[~np.eye(5, dtype=bool)].std()/K_zz[~np.eye(5, dtype=bool)].mean():.4f}") + + # 经典RBF核对比 + print("\n3. 经典RBF核 (对比)") + K_rbf = build_classical_kernel(X, kernel='rbf') + print(f" 核矩阵: {K_rbf.shape}") + print(f" 区分度: {K_rbf[~np.eye(5, dtype=bool)].std()/K_rbf[~np.eye(5, dtype=bool)].mean():.4f}") + + print("\n✓ 量子核计算模块测试通过!") diff --git a/quantum_ashare_market_timing/requirements.txt b/quantum_ashare_market_timing/requirements.txt new file mode 100644 index 00000000..00ed39e5 --- /dev/null +++ b/quantum_ashare_market_timing/requirements.txt @@ -0,0 +1,7 @@ +# 量子增强A股选股系统 — 依赖 +# Quantum-Enhanced A-Share Market Timing via QPanda3 + +pyqpanda3>=0.4.0 +scikit-learn>=1.5.0 +numpy>=1.26.0 +pandas>=2.0.0 diff --git a/quantum_ashare_market_timing/results.json b/quantum_ashare_market_timing/results.json new file mode 100644 index 00000000..f913bdf4 --- /dev/null +++ b/quantum_ashare_market_timing/results.json @@ -0,0 +1,1201 @@ +{ + "system": "Quantum-Enhanced A-Share Market Timing (Walk-Forward)", + "framework": "QPanda3", + "author": "周勋洪 (中国电信资阳分公司)", + "date": "2026-08-03", + "methodology": "Walk-forward expanding window, 6-month refit, zero look-ahead bias", + "label_threshold": "0.5%", + "test_period": "2022-06-02 ~ 2026-07-07", + "config": { + "n_qubits": 6, + "n_reps": 1, + "initial_capital": 100000, + "max_positions": 5, + "hold_days": 3, + "test_start": "2022-06-01", + "n_segments": 9, + "ret_threshold": 0.005 + }, + "systematic_optimization": { + "description": "4-phase systematic optimization (Phase 1-4)", + "phase1_features": "6→16 dim expansion + SelectKBest; 11dim SelectKBest→6q optimal", + "phase2_circuit": "angle_nrep1_C0.1_pi_6q = global optimum (+126.12%); n_reps=1 breakthrough vs n_reps=2 (+1.84%)", + "phase3_labels": "0.5% binary classification optimal; regression/multiclass/multi-horizon all inferior", + "phase4_training": "6-month refit + expanding window optimal; monthly refit/rolling window/ensemble/regime all inferior", + "global_optimal": "angle_encoding, n_reps=1, C=0.1, scale=pi, 11dim SelectKBest->6q, 0.5% label, 6-month refit, expanding window -> +126.12%", + "baseline_no_filter": "-76.34%" + }, + "segment_results": [ + { + "seg": 1, + "train_size": 65, + "test_size": 111, + "q_acc": 0.5315, + "lr_acc": 0.5405, + "q_auc": 0.4407, + "lr_auc": 0.4334, + "q_time": 0.5, + "n_features": 11, + "q_features": [ + "ret_5d", + "vol_ratio", + "ret_20d", + "ma_trend", + "vol_rank_60", + "rsi_14" + ] + }, + { + "seg": 2, + "train_size": 176, + "test_size": 106, + "q_acc": 0.6321, + "lr_acc": 0.6415, + "q_auc": 0.5109, + "lr_auc": 0.5396, + "q_time": 0.7, + "n_features": 11, + "q_features": [ + "bias20", + "ret_5d", + "rsi_5", + "range_5d", + "ma_trend", + "rsi_14" + ] + }, + { + "seg": 3, + "train_size": 282, + "test_size": 107, + "q_acc": 0.6729, + "lr_acc": 0.6822, + "q_auc": 0.6012, + "lr_auc": 0.5413, + "q_time": 1.0, + "n_features": 11, + "q_features": [ + "bias20", + "ret_5d", + "rsi_5", + "ma_align", + "range_5d", + "vol_ratio_20d" + ] + }, + { + "seg": 4, + "train_size": 389, + "test_size": 96, + "q_acc": 0.5729, + "lr_acc": 0.5729, + "q_auc": 0.6022, + "lr_auc": 0.5858, + "q_time": 1.3, + "n_features": 11, + "q_features": [ + "bias20", + "ret_5d", + "rsi_5", + "range_5d", + "vol_rank_60", + "rsi_14" + ] + }, + { + "seg": 5, + "train_size": 485, + "test_size": 87, + "q_acc": 0.5632, + "lr_acc": 0.4138, + "q_auc": 0.5113, + "lr_auc": 0.398, + "q_time": 1.7, + "n_features": 11, + "q_features": [ + "ret_5d", + "rsi_5", + "ma_align", + "range_5d", + "ma_trend", + "vol_rank_60" + ] + }, + { + "seg": 6, + "train_size": 572, + "test_size": 111, + "q_acc": 0.6306, + "lr_acc": 0.6126, + "q_auc": 0.6512, + "lr_auc": 0.4923, + "q_time": 1.9, + "n_features": 11, + "q_features": [ + "bias20", + "ret_5d", + "rsi_5", + "ma_align", + "vol_rank_60", + "rsi_14" + ] + }, + { + "seg": 7, + "train_size": 683, + "test_size": 117, + "q_acc": 0.5641, + "lr_acc": 0.5726, + "q_auc": 0.5973, + "lr_auc": 0.6051, + "q_time": 2.3, + "n_features": 11, + "q_features": [ + "bias20", + "ret_5d", + "rsi_5", + "ma_align", + "vol_rank_60", + "rsi_14" + ] + }, + { + "seg": 8, + "train_size": 800, + "test_size": 112, + "q_acc": 0.4554, + "lr_acc": 0.4375, + "q_auc": 0.6355, + "lr_auc": 0.4861, + "q_time": 2.7, + "n_features": 11, + "q_features": [ + "bias20", + "ret_5d", + "vol_ratio", + "rsi_5", + "ma_align", + "vol_rank_60" + ] + }, + { + "seg": 9, + "train_size": 912, + "test_size": 24, + "q_acc": 0.5833, + "lr_acc": 0.5833, + "q_auc": 0.5214, + "lr_auc": 0.2286, + "q_time": 2.6, + "n_features": 11, + "q_features": [ + "bias20", + "ret_5d", + "vol_ratio", + "rsi_5", + "ma_align", + "vol_rank_60" + ] + } + ], + "threshold_scan": { + "quantum": [ + { + "threshold": 0.3, + "noop_pct": 4.5, + "name": "量子NOOP(th=0.30)", + "final_equity": 24458.97, + "total_return": -75.54, + "n_trades": 1446, + "win_rate": 40.32, + "avg_ret_per_trade": -0.55, + "total_pnl": -75541.03, + "max_drawdown": -83.52, + "calmar": 0.9 + }, + { + "threshold": 0.35, + "noop_pct": 10.1, + "name": "量子NOOP(th=0.35)", + "final_equity": 38990.54, + "total_return": -61.01, + "n_trades": 1389, + "win_rate": 41.68, + "avg_ret_per_trade": -0.29, + "total_pnl": -61009.46, + "max_drawdown": -79.06, + "calmar": 0.77 + }, + { + "threshold": 0.4, + "noop_pct": 79.8, + "name": "量子NOOP(th=0.40)", + "final_equity": 226123.35, + "total_return": 126.12, + "n_trades": 506, + "win_rate": 45.65, + "avg_ret_per_trade": 1.09, + "total_pnl": 126123.35, + "max_drawdown": -24.5, + "calmar": 5.15 + }, + { + "threshold": 0.45, + "noop_pct": 96.8, + "name": "量子NOOP(th=0.45)", + "final_equity": 145011.45, + "total_return": 45.01, + "n_trades": 163, + "win_rate": 53.37, + "avg_ret_per_trade": 1.36, + "total_pnl": 45011.45, + "max_drawdown": -25.28, + "calmar": 1.78 + }, + { + "threshold": 0.5, + "noop_pct": 99.3, + "name": "量子NOOP(th=0.50)", + "final_equity": 100300.21, + "total_return": 0.3, + "n_trades": 85, + "win_rate": 47.06, + "avg_ret_per_trade": 0.18, + "total_pnl": 300.21, + "max_drawdown": -12.18, + "calmar": 0.02 + } + ], + "classical": [ + { + "threshold": 0.3, + "noop_pct": 24.6, + "name": "经典LogReg(th=0.30)", + "final_equity": 31466.18, + "total_return": -68.53, + "n_trades": 1192, + "win_rate": 41.53, + "avg_ret_per_trade": -0.53, + "total_pnl": -68533.82, + "max_drawdown": -78.36, + "calmar": 0.87 + }, + { + "threshold": 0.35, + "noop_pct": 44.4, + "name": "经典LogReg(th=0.35)", + "final_equity": 135878.09, + "total_return": 35.88, + "n_trades": 931, + "win_rate": 43.93, + "avg_ret_per_trade": 0.3, + "total_pnl": 35878.09, + "max_drawdown": -55.95, + "calmar": 0.64 + }, + { + "threshold": 0.4, + "noop_pct": 68.4, + "name": "经典LogReg(th=0.40)", + "final_equity": 119456.93, + "total_return": 19.46, + "n_trades": 587, + "win_rate": 42.76, + "avg_ret_per_trade": 0.31, + "total_pnl": 19456.93, + "max_drawdown": -41.95, + "calmar": 0.46 + }, + { + "threshold": 0.45, + "noop_pct": 82.5, + "name": "经典LogReg(th=0.45)", + "final_equity": 76398.23, + "total_return": -23.6, + "n_trades": 367, + "win_rate": 40.87, + "avg_ret_per_trade": -0.33, + "total_pnl": -23601.77, + "max_drawdown": -44.73, + "calmar": 0.53 + }, + { + "threshold": 0.5, + "noop_pct": 91.8, + "name": "经典LogReg(th=0.50)", + "final_equity": 86721.13, + "total_return": -13.28, + "n_trades": 204, + "win_rate": 38.73, + "avg_ret_per_trade": -0.45, + "total_pnl": -13278.87, + "max_drawdown": -46.6, + "calmar": 0.28 + } + ] + }, + "results": { + "baseline": { + "name": "基线(无过滤)", + "final_equity": 23658.4, + "total_return": -76.34, + "n_trades": 1484, + "win_rate": 40.7, + "avg_ret_per_trade": -0.56, + "total_pnl": -76341.6, + "max_drawdown": -82.22, + "calmar": 0.93 + }, + "quantum_noop": { + "name": "量子NOOP(th=0.40)", + "final_equity": 226123.35, + "total_return": 126.12, + "n_trades": 506, + "win_rate": 45.65, + "avg_ret_per_trade": 1.09, + "total_pnl": 126123.35, + "max_drawdown": -24.5, + "calmar": 5.15 + }, + "classical_noop": { + "name": "经典LogReg(th=0.35)", + "final_equity": 135878.09, + "total_return": 35.88, + "n_trades": 931, + "win_rate": 43.93, + "avg_ret_per_trade": 0.3, + "total_pnl": 35878.09, + "max_drawdown": -55.95, + "calmar": 0.64 + }, + "ensemble": { + "name": "集成AND(q0.40+l0.35)", + "final_equity": 160716.22, + "total_return": 60.72, + "n_trades": 338, + "win_rate": 46.45, + "avg_ret_per_trade": 0.81, + "total_pnl": 60716.22, + "max_drawdown": -22.41, + "calmar": 2.71 + } + }, + "stock_level_filter": { + "description": "个股级量子筛选 — 从日级NOOP升级为个股级判定，对每笔信号独立预测好票/坏票", + "method": "Walk-forward by trading day (126 days ≈ 6 months), expanding window, StandardScaler fit on train only", + "features": [ + "gap_pct", + "vol_ratio", + "ma_dist", + "upper_shadow", + "body_pct", + "ret_5d" + ], + "label": "sell_ret > median = 1 (good), sell_ret <= median = 0 (bad)", + "quantum_config": "AngleEncoding, 6 qubits, n_reps=1, C=0.1, scale=pi", + "filtering": "model prob < threshold → skip signal (per-signal NOOP, does not affect same-day other signals)", + "results": { + "GAP2.0": { + "gap_min": 2.0, + "n_signals": 7042, + "baseline_return_pct": -56.55, + "baseline_equity": 43448.79, + "baseline_trades": 1585, + "baseline_wr_pct": 41.7, + "best_quantum": { + "threshold": 0.4, + "return_pct": -17.01, + "equity": 82988.42, + "trades": 1432, + "wr_pct": 41.83, + "mdd_pct": -62.28, + "lift_pp": 39.54, + "bought": 1432, + "skipped": 728, + "skip_pct": 10.3 + }, + "best_classical": { + "threshold": 0.35, + "return_pct": -40.88, + "lift_pp": 15.67 + }, + "ql_ratio": 2.52, + "threshold_scan": [ + { + "th": 0.1, + "q_ret": -46.435515670778805, + "q_lift": 10.115699318000033, + "q_trades": 1582, + "q_wr": 41.65613147914033, + "q_bought": 1582, + "q_skipped": 44, + "lr_ret": -46.435515670778805, + "lr_lift": 10.115699318000033, + "lr_trades": 1582, + "lr_wr": 41.65613147914033 + }, + { + "th": 0.15, + "q_ret": -46.435515670778805, + "q_lift": 10.115699318000033, + "q_trades": 1582, + "q_wr": 41.65613147914033, + "q_bought": 1582, + "q_skipped": 44, + "lr_ret": -46.15121550978887, + "lr_lift": 10.399999478989969, + "lr_trades": 1581, + "lr_wr": 41.61922833649589 + }, + { + "th": 0.2, + "q_ret": -46.435515670778805, + "q_lift": 10.115699318000033, + "q_trades": 1582, + "q_wr": 41.65613147914033, + "q_bought": 1582, + "q_skipped": 44, + "lr_ret": -49.19305962399771, + "lr_lift": 7.358155364781126, + "lr_trades": 1580, + "lr_wr": 41.265822784810126 + }, + { + "th": 0.25, + "q_ret": -46.435515670778805, + "q_lift": 10.115699318000033, + "q_trades": 1582, + "q_wr": 41.65613147914033, + "q_bought": 1582, + "q_skipped": 44, + "lr_ret": -41.669327124966784, + "lr_lift": 14.881887863812054, + "lr_trades": 1577, + "lr_wr": 41.407736207989856 + }, + { + "th": 0.3, + "q_ret": -44.16009091924236, + "q_lift": 12.391124069536481, + "q_trades": 1580, + "q_wr": 41.64556962025316, + "q_bought": 1580, + "q_skipped": 57, + "lr_ret": -46.41044435373074, + "lr_lift": 10.1407706350481, + "lr_trades": 1567, + "lr_wr": 41.225271218889596 + }, + { + "th": 0.35, + "q_ret": -38.818792112985435, + "q_lift": 17.732422875793404, + "q_trades": 1549, + "q_wr": 41.57520981278244, + "q_bought": 1549, + "q_skipped": 209, + "lr_ret": -40.87689663750788, + "lr_lift": 15.674318351270955, + "lr_trades": 1546, + "lr_wr": 40.7503234152652 + }, + { + "th": 0.4, + "q_ret": -17.01157843003741, + "q_lift": 39.53963655874143, + "q_trades": 1432, + "q_wr": 41.82960893854749, + "q_bought": 1432, + "q_skipped": 728, + "lr_ret": -48.4001970175155, + "lr_lift": 8.151017971263336, + "lr_trades": 1452, + "lr_wr": 41.52892561983471 + } + ] + }, + "GAP2.5": { + "gap_min": 2.5, + "n_signals": 4818, + "baseline_return_pct": -61.49, + "baseline_equity": 38511.56, + "baseline_trades": 1462, + "baseline_wr_pct": 40.9, + "best_quantum": { + "threshold": 0.4, + "return_pct": -38.18, + "equity": 61821.28, + "trades": 1358, + "wr_pct": 40.8, + "mdd_pct": -62.97, + "lift_pp": 23.31, + "bought": 1358, + "skipped": 365, + "skip_pct": 7.6 + }, + "best_classical": { + "threshold": 0.3, + "return_pct": -43.14, + "lift_pp": 18.35 + }, + "ql_ratio": 1.27, + "threshold_scan": [ + { + "th": 0.1, + "q_ret": -51.158375986732366, + "q_lift": 10.330059766474562, + "q_trades": 1452, + "q_wr": 40.97796143250689, + "q_bought": 1452, + "q_skipped": 35, + "lr_ret": -51.158375986732366, + "lr_lift": 10.330059766474562, + "lr_trades": 1452, + "lr_wr": 40.97796143250689 + }, + { + "th": 0.15, + "q_ret": -51.158375986732366, + "q_lift": 10.330059766474562, + "q_trades": 1452, + "q_wr": 40.97796143250689, + "q_bought": 1452, + "q_skipped": 35, + "lr_ret": -52.71272807325516, + "lr_lift": 8.775707679951772, + "lr_trades": 1449, + "lr_wr": 40.924775707384406 + }, + { + "th": 0.2, + "q_ret": -50.68422301093348, + "q_lift": 10.80421274227345, + "q_trades": 1451, + "q_wr": 40.868366643694, + "q_bought": 1451, + "q_skipped": 43, + "lr_ret": -50.99872719508791, + "lr_lift": 10.48970855811902, + "lr_trades": 1445, + "lr_wr": 40.89965397923876 + }, + { + "th": 0.25, + "q_ret": -51.10028972517361, + "q_lift": 10.388146028033319, + "q_trades": 1446, + "q_wr": 40.80221300138312, + "q_bought": 1446, + "q_skipped": 58, + "lr_ret": -48.824639666855305, + "lr_lift": 12.663796086351624, + "lr_trades": 1437, + "lr_wr": 40.77940153096729 + }, + { + "th": 0.3, + "q_ret": -48.22251791972041, + "q_lift": 13.265917833486519, + "q_trades": 1439, + "q_wr": 40.722724113968034, + "q_bought": 1439, + "q_skipped": 93, + "lr_ret": -43.143156942327934, + "lr_lift": 18.345278810878995, + "lr_trades": 1425, + "lr_wr": 40.63157894736842 + }, + { + "th": 0.35, + "q_ret": -45.02041274110671, + "q_lift": 16.46802301210022, + "q_trades": 1416, + "q_wr": 40.81920903954802, + "q_bought": 1416, + "q_skipped": 160, + "lr_ret": -53.352354607980935, + "lr_lift": 8.136081145225994, + "lr_trades": 1396, + "lr_wr": 40.04297994269341 + }, + { + "th": 0.4, + "q_ret": -38.17872372342631, + "q_lift": 23.30971202978062, + "q_trades": 1358, + "q_wr": 40.79528718703976, + "q_bought": 1358, + "q_skipped": 365, + "lr_ret": -44.922423204017456, + "lr_lift": 16.566012549189473, + "lr_trades": 1326, + "lr_wr": 41.17647058823529 + } + ] + }, + "GAP3.0": { + "gap_min": 3.0, + "n_signals": 3250, + "baseline_return_pct": -36.81, + "baseline_equity": 63190.5, + "baseline_trades": 1288, + "baseline_wr_pct": 42.55, + "best_quantum": { + "threshold": 0.35, + "return_pct": -21.91, + "equity": 78089.72, + "trades": 1240, + "wr_pct": 42.82, + "mdd_pct": -57.65, + "lift_pp": 14.9, + "bought": 1240, + "skipped": 113, + "skip_pct": 3.5 + }, + "best_classical": { + "threshold": 0.15, + "return_pct": -21.66, + "lift_pp": 15.15 + }, + "ql_ratio": 0.98, + "threshold_scan": [ + { + "th": 0.1, + "q_ret": -32.70350160955859, + "q_lift": 4.1059940059604045, + "q_trades": 1276, + "q_wr": 42.554858934169275, + "q_bought": 1276, + "q_skipped": 25, + "lr_ret": -30.81971515043076, + "lr_lift": 5.989780465088238, + "lr_trades": 1273, + "lr_wr": 42.65514532600157 + }, + { + "th": 0.15, + "q_ret": -32.70350160955859, + "q_lift": 4.1059940059604045, + "q_trades": 1276, + "q_wr": 42.554858934169275, + "q_bought": 1276, + "q_skipped": 25, + "lr_ret": -21.66029266755489, + "lr_lift": 15.149202947964106, + "lr_trades": 1265, + "lr_wr": 43.00395256916996 + }, + { + "th": 0.2, + "q_ret": -32.70350160955859, + "q_lift": 4.1059940059604045, + "q_trades": 1276, + "q_wr": 42.554858934169275, + "q_bought": 1276, + "q_skipped": 25, + "lr_ret": -26.490264025964215, + "lr_lift": 10.319231589554782, + "lr_trades": 1260, + "lr_wr": 42.93650793650794 + }, + { + "th": 0.25, + "q_ret": -32.99410557546258, + "q_lift": 3.815390040056421, + "q_trades": 1274, + "q_wr": 42.54317111459969, + "q_bought": 1274, + "q_skipped": 30, + "lr_ret": -33.25879573183084, + "lr_lift": 3.5506998836881607, + "lr_trades": 1252, + "lr_wr": 42.73162939297125 + }, + { + "th": 0.3, + "q_ret": -33.44256400532677, + "q_lift": 3.366931610192225, + "q_trades": 1261, + "q_wr": 42.664551942902456, + "q_bought": 1261, + "q_skipped": 58, + "lr_ret": -31.868572451964006, + "lr_lift": 4.9409231635549915, + "lr_trades": 1244, + "lr_wr": 42.524115755627015 + }, + { + "th": 0.35, + "q_ret": -21.910282473856412, + "q_lift": 14.899213141662585, + "q_trades": 1240, + "q_wr": 42.82258064516129, + "q_bought": 1240, + "q_skipped": 113, + "lr_ret": -48.01095696292668, + "lr_lift": -11.20146134740768, + "lr_trades": 1219, + "lr_wr": 41.755537325676784 + }, + { + "th": 0.4, + "q_ret": -22.8972030428908, + "q_lift": 13.912292572628196, + "q_trades": 1110, + "q_wr": 42.432432432432435, + "q_bought": 1110, + "q_skipped": 396, + "lr_ret": -53.14176415808767, + "lr_lift": -16.33226854256867, + "lr_trades": 1143, + "lr_wr": 41.644794400699915 + } + ] + } + } + }, + "gap_threshold_day_level_scan": { + "description": "GAP阈值日级NOOP扫描 — 6组GAP阈值验证分层反转模式（day-level Q/L vs stock-level Q/L反向关系）", + "method": "Same day-level NOOP system as main results, but signals filtered by different GAP thresholds before daily aggregation", + "results": { + "GAP2.0_day": { + "gap_min": 2.0, + "n_signals": 7042, + "n_days": 979, + "baseline_return_pct": -55.11, + "best_q_lift_pp": 84.7, + "best_lr_lift_pp": 99.69, + "ql_ratio_day_level": 0.85, + "threshold_scan": [ + { + "th": 0.3, + "q_ret": -42.16996201927054, + "q_lift": 12.937407509753541, + "lr_ret": -59.31582698038077, + "lr_lift": -4.208457451356686, + "q_noop_pct": 9.523809523809524, + "lr_noop_pct": 19.744483159117305 + }, + { + "th": 0.35, + "q_ret": -71.49952603791525, + "q_lift": -16.392156508891162, + "lr_ret": -6.455703804331902, + "lr_lift": 48.65166572469218, + "q_noop_pct": 21.83507549361208, + "lr_noop_pct": 40.18583042973287 + }, + { + "th": 0.4, + "q_ret": 29.090765154113374, + "q_lift": 84.19813468313745, + "lr_ret": 44.58284410308546, + "lr_lift": 99.69021363210955, + "q_noop_pct": 67.13124274099884, + "lr_noop_pct": 66.43437862950059 + }, + { + "th": 0.45, + "q_ret": 29.596106336612916, + "q_lift": 84.703475865637, + "lr_ret": -16.918408013859853, + "lr_lift": 38.18896151516423, + "q_noop_pct": 89.31475029036005, + "lr_noop_pct": 84.90127758420442 + }, + { + "th": 0.5, + "q_ret": 17.56663726451777, + "q_lift": 72.67400679354185, + "lr_ret": -40.66691731901364, + "lr_lift": 14.440452210010442, + "q_noop_pct": 95.00580720092915, + "lr_noop_pct": 93.72822299651567 + } + ] + }, + "GAP2.5_day": { + "gap_min": 2.5, + "n_signals": 4818, + "n_days": 922, + "baseline_return_pct": -44.31, + "best_q_lift_pp": 246.21, + "best_lr_lift_pp": 116.04, + "ql_ratio_day_level": 2.12, + "threshold_scan": [ + { + "th": 0.3, + "q_ret": -57.10539020856857, + "q_lift": -12.796447892981796, + "lr_ret": -52.436004354832555, + "lr_lift": -8.127062039245779, + "q_noop_pct": 7.4074074074074066, + "lr_noop_pct": 16.419753086419753 + }, + { + "th": 0.35, + "q_ret": -27.713399885137868, + "q_lift": 16.59554243044891, + "lr_ret": -9.562092043303771, + "lr_lift": 34.746850272283005, + "q_noop_pct": 33.7037037037037, + "lr_noop_pct": 43.95061728395061 + }, + { + "th": 0.4, + "q_ret": 201.90060975881394, + "q_lift": 246.20955207440073, + "lr_ret": 71.73174225518805, + "lr_lift": 116.04068457077483, + "q_noop_pct": 72.46913580246913, + "lr_noop_pct": 71.48148148148148 + }, + { + "th": 0.45, + "q_ret": 89.07812741500378, + "q_lift": 133.38706973059055, + "lr_ret": -19.182901113878938, + "lr_lift": 25.12604120170784, + "q_noop_pct": 89.87654320987654, + "lr_noop_pct": 87.1604938271605 + }, + { + "th": 0.5, + "q_ret": 18.144846987221364, + "q_lift": 62.45378930280814, + "lr_ret": -20.63245533669814, + "lr_lift": 23.676486978888637, + "q_noop_pct": 95.67901234567901, + "lr_noop_pct": 91.9753086419753 + } + ] + }, + "GAP3.0_day": { + "gap_min": 3.0, + "n_signals": 3250, + "n_days": 835, + "baseline_return_pct": -12.82, + "best_q_lift_pp": 95.79, + "best_lr_lift_pp": 41.85, + "ql_ratio_day_level": 2.29, + "threshold_scan": [ + { + "th": 0.3, + "q_ret": -0.6412978866764063, + "q_lift": 12.182576841225801, + "lr_ret": -40.81606325644614, + "lr_lift": -27.992188528543934, + "q_noop_pct": 20.98765432098765, + "lr_noop_pct": 29.766803840877916 + }, + { + "th": 0.35, + "q_ret": -22.062772525264762, + "q_lift": -9.238897797362554, + "lr_ret": 29.028782924372987, + "lr_lift": 41.8526576522752, + "q_noop_pct": 51.98902606310014, + "lr_noop_pct": 53.635116598079556 + }, + { + "th": 0.4, + "q_ret": 57.48421258340686, + "q_lift": 70.30808731130907, + "lr_ret": -1.5661091002025507, + "lr_lift": 11.257765627699657, + "q_noop_pct": 89.57475994513031, + "lr_noop_pct": 78.73799725651578 + }, + { + "th": 0.45, + "q_ret": 82.96779300851493, + "q_lift": 95.79166773641714, + "lr_ret": -10.536277630493595, + "lr_lift": 2.2875970974086126, + "q_noop_pct": 96.15912208504801, + "lr_noop_pct": 91.76954732510289 + }, + { + "th": 0.5, + "q_ret": 30.48285855995825, + "q_lift": 43.30673328786045, + "lr_ret": -14.520519758872085, + "lr_lift": -1.6966450309698775, + "q_noop_pct": 98.90260631001372, + "lr_noop_pct": 96.57064471879286 + } + ] + } + }, + "layer_reversal_pattern": { + "description": "个股级与日级的Q/L比呈反向关系", + "table": [ + { + "gap": "2.0%", + "level": "stock", + "n_signals": 7042, + "ql_ratio": 2.52, + "explanation": "信号多→个股间差异丰富→量子优势大" + }, + { + "gap": "2.0%", + "level": "day", + "n_signals": 7042, + "ql_ratio": 0.85, + "explanation": "信号多→日聚合后信息丢失→量子无优势" + }, + { + "gap": "2.5%", + "level": "stock", + "n_signals": 4818, + "ql_ratio": 1.27, + "explanation": "" + }, + { + "gap": "2.5%", + "level": "day", + "n_signals": 4818, + "ql_ratio": 2.12, + "explanation": "信号少→日级量子优势大" + }, + { + "gap": "3.0%", + "level": "stock", + "n_signals": 3250, + "ql_ratio": 0.98, + "explanation": "信号少→个股级样本不足→量子退化为经典" + }, + { + "gap": "3.0%", + "level": "day", + "n_signals": 3250, + "ql_ratio": 2.29, + "explanation": "信号少→日级量子优势大" + } + ], + "insight": "信号密集→量子优势在个股级；信号稀疏→优势在日级。量子核SVM在不同信号密度下，其优势层级会自动迁移。" + } + }, + "wp_stab6_validation": { + "description": "WP stab6破板反弹策略 — 个股级量子筛选跨策略验证（阴性结果）", + "strategy": "涨停破板企稳反弹，632笔交易，尾盘买入", + "n_trades": 632, + "v1_summary": { + "n_features": 6, + "n_qubits": 6, + "result": "0% skip rate, 0% lift", + "reason": "6个T-1特征diff<0.3，零区分度" + }, + "v2_summary": { + "n_features": 8, + "n_qubits": 8, + "added_features": [ + "break_depth", + "reversal" + ], + "ql_ratio": 0.27, + "reason": "量子核矩阵退化为全0.5（概率分布P50=0.500, P90=0.513）" + }, + "v3_grid_scan": { + "description": "降维网格扫描: 2/4/6/8 qubits × C=0.1/1.0/10.0 = 12 configurations", + "configs": [ + { + "config": "2q", + "n_qubits": 2, + "c": 0.1, + "q_acc": 0.6259057971014492, + "lr_acc": 0.6773968784838349, + "q_p50": 0.5272924505103571, + "q_p90": 0.5953916211765181, + "l_p50": 0.5, + "l_p90": 0.6924667606754686, + "q_best_lift": 361.07175004396163, + "lr_best_lift": 689.0500153502634, + "ql_ratio": 0.5240138480519716, + "baseline_return": 161.32299553356674 + }, + { + "config": "2q", + "n_qubits": 2, + "c": 1.0, + "q_acc": 0.6371934225195095, + "lr_acc": 0.6773968784838349, + "q_p50": 0.5371672789990869, + "q_p90": 0.6057712520530041, + "l_p50": 0.5, + "l_p90": 0.6924667606754686, + "q_best_lift": 426.8464925797143, + "lr_best_lift": 689.0500153502634, + "ql_ratio": 0.6194709862429019, + "baseline_return": 161.32299553356674 + }, + { + "config": "2q", + "n_qubits": 2, + "c": 10.0, + "q_acc": 0.63258480649785, + "lr_acc": 0.6773968784838349, + "q_p50": 0.5389056092728408, + "q_p90": 0.5942784312696255, + "l_p50": 0.5, + "l_p90": 0.6924667606754686, + "q_best_lift": 402.08434513619864, + "lr_best_lift": 689.0500153502634, + "ql_ratio": 0.5835343388415831, + "baseline_return": 161.32299553356674 + }, + { + "config": "4q", + "n_qubits": 4, + "c": 0.1, + "q_acc": 0.5147216913521261, + "lr_acc": 0.6794672718585762, + "q_p50": 0.4874849270000645, + "q_p90": 0.5192912428783532, + "l_p50": 0.5, + "l_p90": 0.7017703746342302, + "q_best_lift": -5.25021552165839, + "lr_best_lift": 693.1626049931955, + "ql_ratio": -0.007574291347857592, + "baseline_return": 161.32299553356674 + }, + { + "config": "4q", + "n_qubits": 4, + "c": 1.0, + "q_acc": 0.560728221054308, + "lr_acc": 0.6794672718585762, + "q_p50": 0.5087997898046144, + "q_p90": 0.5583257700513741, + "l_p50": 0.5, + "l_p90": 0.7017703746342302, + "q_best_lift": 250.40845127486787, + "lr_best_lift": 693.1626049931955, + "ql_ratio": 0.3612549919327025, + "baseline_return": 161.32299553356674 + }, + { + "config": "4q", + "n_qubits": 4, + "c": 10.0, + "q_acc": 0.582566889632107, + "lr_acc": 0.6794672718585762, + "q_p50": 0.5072220608751853, + "q_p90": 0.5487711076779294, + "l_p50": 0.5, + "l_p90": 0.7017703746342302, + "q_best_lift": 198.32051528034586, + "lr_best_lift": 693.1626049931955, + "ql_ratio": 0.2861096571738643, + "baseline_return": 161.32299553356674 + }, + { + "config": "6q", + "n_qubits": 6, + "c": 0.1, + "q_acc": 0.5539894887720975, + "lr_acc": 0.6849418697244785, + "q_p50": 0.4890129907341978, + "q_p90": 0.5407263699706798, + "l_p50": 0.5, + "l_p90": 0.7353723884474319, + "q_best_lift": 162.6612977687249, + "lr_best_lift": 685.5505541384854, + "ql_ratio": 0.23727104702458796, + "baseline_return": 161.32299553356674 + }, + { + "config": "6q", + "n_qubits": 6, + "c": 1.0, + "q_acc": 0.5263377926421404, + "lr_acc": 0.6849418697244785, + "q_p50": 0.5, + "q_p90": 0.5984255545151949, + "l_p50": 0.5, + "l_p90": 0.7353723884474319, + "q_best_lift": 183.34445470830505, + "lr_best_lift": 685.5505541384854, + "ql_ratio": 0.26744118811005785, + "baseline_return": 161.32299553356674 + }, + { + "config": "6q", + "n_qubits": 6, + "c": 10.0, + "q_acc": 0.5175286669851887, + "lr_acc": 0.6849418697244785, + "q_p50": 0.5, + "q_p90": 0.5883167733708976, + "l_p50": 0.5, + "l_p90": 0.7353723884474319, + "q_best_lift": 165.61406310545627, + "lr_best_lift": 685.5505541384854, + "ql_ratio": 0.24157819158002056, + "baseline_return": 161.32299553356674 + }, + { + "config": "8q", + "n_qubits": 8, + "c": 0.1, + "q_acc": 0.562002309284918, + "lr_acc": 0.6780637840420449, + "q_p50": 0.4860070008632359, + "q_p90": 0.5556852280333464, + "l_p50": 0.5, + "l_p90": 0.7416033410716653, + "q_best_lift": 175.60841294627537, + "lr_best_lift": 657.6052336638827, + "ql_ratio": 0.26704229826131964, + "baseline_return": 161.32299553356674 + }, + { + "config": "8q", + "n_qubits": 8, + "c": 1.0, + "q_acc": 0.5111781334607421, + "lr_acc": 0.6780637840420449, + "q_p50": 0.5, + "q_p90": 0.5597184537883134, + "l_p50": 0.5, + "l_p90": 0.7416033410716653, + "q_best_lift": 279.69148311991023, + "lr_best_lift": 657.6052336638827, + "ql_ratio": 0.4253182134235675, + "baseline_return": 161.32299553356674 + }, + { + "config": "8q", + "n_qubits": 8, + "c": 10.0, + "q_acc": 0.5261387163561076, + "lr_acc": 0.6780637840420449, + "q_p50": 0.5, + "q_p90": 0.5462499839203452, + "l_p50": 0.5, + "l_p90": 0.7416033410716653, + "q_best_lift": 188.0229660202156, + "lr_best_lift": 657.6052336638827, + "ql_ratio": 0.2859207262883776, + "baseline_return": 161.32299553356674 + } + ], + "best_config": { + "n_qubits": 2, + "c": 1.0, + "q_acc": 0.6372, + "lr_acc": 0.6774, + "q_best_lift_pct": 426.85, + "lr_best_lift_pct": 689.05, + "ql_ratio": 0.62 + }, + "all_ql_below_1": true + }, + "failure_root_cause": [ + "信号池同质化: WP stab6的信号已被涨停+破板+企稳三重过滤，特征分布高度集中", + "量子核退化: 高qubits+小样本导致核矩阵趋近全0.5", + "降维也不够: 即使2qubits，量子准确率63.7%仍低于经典67.7%" + ], + "conclusion": "所有配置Q/L < 1.0，经典全面碾压量子。量子核SVM适用于广撒网型策略的信号筛选，不适用于精筛型策略的二次过滤。" + } +} \ No newline at end of file diff --git a/quantum_ashare_market_timing/stock_level_filter.py b/quantum_ashare_market_timing/stock_level_filter.py new file mode 100644 index 00000000..305cd31a --- /dev/null +++ b/quantum_ashare_market_timing/stock_level_filter.py @@ -0,0 +1,843 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +量子核SVM个股级筛选 — Stock-Level Quantum Filtering +Quantum-Enhanced Stock Selection at Signal Level + +核心升级: + 日级NOOP是对整个市场"好天/坏天"的二元判断（跳过整天的信号）， + 个股级筛选将量子核SVM细化到每笔信号：对每个跳空信号独立预测 + "好票/坏票"，过滤量子模型不认可的信号，保留优质信号。 + + 排序铁律不变: 被买入信号仍按gap_pct降序排列（策略铁律，量子仅做过滤） + +实验结果 (GAP2.0, 信号数7042): + 基线: -56.6% → 量子最佳: -17.0% (+39.5pp) → 经典最佳: -40.9% (+15.7pp) + Q/L = 2.52x (量子提升是经典的2.52倍) + +分层反转模式: + 信号多(7042)时 → 个股级Q/L=2.52x, 日级Q/L=0.85x (量子优势在个股层) + 信号少(3250)时 → 个股级Q/L=0.98x, 日级Q/L=2.29x (量子优势在市场层) + +鲁棒性验证 (5c节, --mode robustness): + 9组超参数配置(6买入+3卖出)全部Q>L, 量子优势不依赖cherry-picking + 买入端: 6/6 Q>L ✅, 6/6 Q>基线 ✅, Q/L=1.92~3.90x + 卖出端: 3/3 Q>L ✅, 2/3 Q>基线 ✅, Q/L=1.19~1.36x + +买卖结合实验 (5d节): + B_only(仅买入端量子排序)最优 → +1071pp vs基线 + B+S(买卖结合)无协同效应 → -579pp synergy gap + 结论: 量子核SVM最佳应用方式是买入端信号排序器 + +框架: QPanda3 + scikit-learn +作者: 周勋洪 (中国电信资阳分公司) +日期: 2026-08-03 +""" +import sys, os, json, time, pickle, warnings +from collections import OrderedDict, defaultdict +warnings.filterwarnings('ignore') +import numpy as np +import pandas as pd +from sklearn.svm import SVC +from sklearn.linear_model import LogisticRegression +from sklearn.preprocessing import StandardScaler + +# 模块导入 +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from quantum_kernel import (build_angle_encoding, compute_quantum_states, + quantum_kernel_matrix) +from market_data import load_zp_signals + +# ─── 配置 ─── +GAP_MIN_VALUES = [2.0, 2.5, 3.0] # 多GAP对比: 验证信号密度与量子优势的关系 +N_QUBITS = 6 # 量子比特数 (=特征数) +N_REPS = 1 # 电路重复次数 (n_reps=1信号保真度最高) +Q_C = 0.1 # SVM正则化参数 +SCALE = np.pi # 特征缩放因子 +TEST_START = '2022-06-01' # 测试期起始日 +SCAN_THRESHOLDS = [0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40] +INITIAL_CAPITAL = 100000 +MAX_POSITIONS = 5 +HOLD_DAYS = 3 +SEG_LEN = 126 # 按交易日分段 (~6个月) + +FEATURE_NAMES = ['gap_pct', 'vol_ratio', 'ma_dist', 'upper_shadow', 'body_pct', 'ret_5d'] + + +def log(msg): + print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True) + + +def build_stock_features(signals_df, all_data): + """ + 为每个信号构建6维个股特征 (全部T-1口径, 零前视偏差) + + 特征: + 1. gap_pct — 跳空幅度 (T日open/T-1 close, 09:25可见) + 2. vol_ratio — 5日/10日量比 (T-1截止) + 3. ma_dist — T-1收盘/MA10偏离% + 4. upper_shadow — T-1上影线% + 5. body_pct — T-1实体% + 6. ret_5d — 5日涨幅% (T-1截止) + + 标签: sell_ret > median = 1 (好票), sell_ret <= median = 0 (坏票) + + 参数: + signals_df: DataFrame 交易信号 (含code, gap_pct, sell_ret等) + all_data: dict 个股K线数据 {field: {code: DataFrame/Series}} + + 返回: + features: np.array (N, 6) + labels: np.array (N,) + sig_data: list [(day_str, gap_pct, sell_ret), ...] + """ + print(" 构建个股特征...") + t0 = time.time() + features = [] + labels = [] + sig_data = [] + n_matched = n_missed = 0 + code_cache = {} + vol_key = 'vol' if 'vol' in all_data else 'volume' + + for idx, row in signals_df.iterrows(): + code = row['code'] + date = idx # T日 (买入日) + + if code not in code_cache: + if code not in all_data['close']: + code_cache[code] = None + n_missed += 1 + continue + closes = all_data['close'][code] + date_idx = closes.index + date_str_map = {str(d)[:10]: j for j, d in enumerate(date_idx)} + code_cache[code] = { + 'close': closes.values.astype(float), + 'open': all_data['open'][code].values.astype(float), + 'high': all_data['high'][code].values.astype(float), + 'low': all_data['low'][code].values.astype(float), + 'vol': all_data[vol_key][code].values.astype(float), + 'date_str_map': date_str_map, + } + + cd = code_cache[code] + if cd is None: + n_missed += 1 + continue + + # 字符串匹配 (信号用00:00, K线用15:00, Timestamp不等) + date_str = str(date)[:10] + dsm = cd['date_str_map'] + if date_str not in dsm: + n_missed += 1 + continue + i = dsm[date_str] + if i < 20: + n_missed += 1 + continue + + closes = cd['close'] + opens = cd['open'] + highs = cd['high'] + lows = cd['low'] + vols = cd['vol'] + + # ── 6维特征 (全部T-1零前视) ── + gap_pct = float(row['gap_pct']) + + vol_5d = np.mean(vols[i-5:i]) + vol_10d = np.mean(vols[i-10:i]) + vol_ratio = vol_5d / vol_10d if vol_10d > 0 else 0.0 + + ma10 = np.mean(closes[i-10:i]) + ma_dist = (closes[i-1] / ma10 - 1.0) * 100 if ma10 > 0 else 0.0 + + h, l, o, c = highs[i-1], lows[i-1], opens[i-1], closes[i-1] + upper_shadow = (h - max(o, c)) / (h - l) * 100 if h > l else 0.0 + body_pct = (c - o) / o * 100 if o > 0 else 0.0 + ret_5d = (closes[i-1] / closes[i-6] - 1.0) * 100 if closes[i-6] > 0 else 0.0 + + features.append([gap_pct, vol_ratio, ma_dist, upper_shadow, body_pct, ret_5d]) + labels.append(1 if row['sell_ret'] > 1.0 else 0) + sig_data.append((date_str, gap_pct, float(row['sell_ret']))) + n_matched += 1 + + print(f" 匹配{n_matched}/{n_matched+n_missed}个信号, {time.time()-t0:.1f}s") + return np.array(features, dtype=float), np.array(labels, dtype=float), sig_data + + +def walk_forward_stock_level(features, labels, sig_data): + """ + Walk-forward扩展窗口验证 — 个股级 + + 方法论: + - 按交易日分段 (126日≈6个月), 扩展窗口 + - StandardScaler仅fit训练段 (零前视偏差) + - 量子核SVM vs 经典LogReg + + 返回: + dict: {q_probs, lr_probs} — 与sig_data对齐的概率 + """ + sig_dates = [sd[0] for sd in sig_data] + order = np.argsort(sig_dates) + sorted_features = features[order] + sorted_labels = labels[order] + sorted_dates = [sig_dates[i] for i in order] + + test_start_idx = None + for i, d in enumerate(sorted_dates): + if d >= TEST_START: + test_start_idx = i + break + if test_start_idx is None: + return None + + # ★按交易日分段 (非按信号个数), 避免重复计算全部训练态 + test_dates_list = sorted_dates[test_start_idx:] + unique_test_days = sorted(set(test_dates_list)) + n_day_segs = max(1, (len(unique_test_days) + SEG_LEN - 1) // SEG_LEN) + day_segments = [] + for s in range(n_day_segs): + d0 = s * SEG_LEN + d1 = min((s+1) * SEG_LEN, len(unique_test_days)) + day_segments.append((unique_test_days[d0], unique_test_days[d1-1])) + + segments = [] + for day_lo, day_hi in day_segments: + s_start = s_end = test_start_idx + for j in range(test_start_idx, len(sorted_dates)): + if sorted_dates[j] < day_lo: + s_start = j + 1 + if sorted_dates[j] <= day_hi: + s_end = j + 1 + segments.append((s_start, s_end)) + + q_probs = np.zeros(len(sorted_dates)) + lr_probs = np.zeros(len(sorted_dates)) + + for si, (seg_start, seg_end) in enumerate(segments): + train_X = sorted_features[:seg_start].copy() + train_y = sorted_labels[:seg_start].copy() + test_X = sorted_features[seg_start:seg_end].copy() + + if len(train_X) < 30 or len(np.unique(train_y)) < 2: + q_probs[seg_start:seg_end] = 0.5 + lr_probs[seg_start:seg_end] = 0.5 + log(f" Seg {si+1}/{len(segments)}: train={len(train_X)} test={len(test_X)} (skip)") + continue + + scaler = StandardScaler() + train_X_s = scaler.fit_transform(train_X) + test_X_s = scaler.transform(test_X) + + # ── 量子核SVM ── + t0 = time.time() + try: + train_states = compute_quantum_states( + train_X_s, build_angle_encoding, N_QUBITS, N_REPS, SCALE) + test_states = compute_quantum_states( + test_X_s, build_angle_encoding, N_QUBITS, N_REPS, SCALE) + K_train = quantum_kernel_matrix(train_states) + K_test = quantum_kernel_matrix(train_states, test_states) + q_clf = SVC(kernel='precomputed', C=Q_C, probability=True, random_state=42) + q_clf.fit(K_train, train_y) + q_prob = q_clf.predict_proba(K_test) + q_prob_pos = q_prob[:, 1] if q_clf.classes_[1] == 1 else q_prob[:, 0] + except Exception as e: + log(f" Seg {si+1} Q FAIL: {e}") + q_prob_pos = np.array([0.5] * len(test_X_s)) + q_time = time.time() - t0 + + # ── 经典LogReg ── + try: + lr_clf = LogisticRegression(max_iter=1000, random_state=42) + lr_clf.fit(train_X_s, train_y) + lr_prob = lr_clf.predict_proba(test_X_s) + lr_prob_pos = lr_prob[:, 1] if lr_clf.classes_[1] == 1 else lr_prob[:, 0] + except Exception: + lr_prob_pos = np.array([0.5] * len(test_X_s)) + + q_probs[seg_start:seg_end] = q_prob_pos + lr_probs[seg_start:seg_end] = lr_prob_pos + + q_acc = float(((q_prob_pos > 0.5).astype(int) == sorted_labels[seg_start:seg_end]).mean()) + lr_acc = float(((lr_prob_pos > 0.5).astype(int) == sorted_labels[seg_start:seg_end]).mean()) + log(f" Seg {si+1}/{len(segments)}: train={len(train_X)} test={len(test_X)} " + f"Q_acc={q_acc:.3f} L_acc={lr_acc:.3f} ({q_time:.1f}s)") + + # 恢复原始顺序 + q_probs_orig = np.zeros(len(sig_data)) + lr_probs_orig = np.zeros(len(sig_data)) + for new_i, orig_pos in enumerate(order): + q_probs_orig[orig_pos] = q_probs[new_i] + lr_probs_orig[orig_pos] = lr_probs[new_i] + + return {'q_probs': q_probs_orig, 'lr_probs': lr_probs_orig} + + +def run_backtest(sig_data, probs, threshold=None, + initial_capital=INITIAL_CAPITAL, max_positions=MAX_POSITIONS, + hold_days=HOLD_DAYS, sort_mode='gap'): + """ + 个股级筛选回测 + + 规则: + 1. 每日: 先平仓到期持仓 + 2. 买入: 按指定模式排序选股, 概率= pos['exit_idx']: + portfolio += pos['capital'] * pos['sell_ret'] + n_trades += 1 + if pos['sell_ret'] > 1.0: + n_wins += 1 + else: + new_positions.append(pos) + positions = new_positions + + available = max_positions - len(positions) + for gap_pct, sell_ret, prob in sig_by_date[day_str]: + if available <= 0: + break + if threshold is not None and prob < threshold: + n_skipped += 1 + continue + alloc = portfolio / max_positions if max_positions > 0 else 0 + if alloc > 0: + positions.append({'exit_idx': day_i + hold_days, + 'capital': alloc, 'sell_ret': sell_ret}) + portfolio -= alloc + available -= 1 + n_bought += 1 + + mkt_val = portfolio + sum(p['capital'] * p['sell_ret'] for p in positions) + eq_vals.append(mkt_val) + + for pos in positions: + portfolio += pos['capital'] * pos['sell_ret'] + n_trades += 1 + if pos['sell_ret'] > 1.0: + n_wins += 1 + + final_equity = max(portfolio, 1.0) + total_return = (final_equity / initial_capital - 1.0) * 100 + win_rate = n_wins / n_trades * 100 if n_trades > 0 else 0 + + eq = np.array(eq_vals) + if len(eq) > 0 and eq.max() > 0: + cummax = np.maximum.accumulate(eq) + dd = (eq - cummax) / np.where(cummax > 0, cummax, 1) + mdd = float(dd.min() * 100) + else: + mdd = 0 + + return { + 'final_equity': final_equity, 'total_return': total_return, + 'n_trades': n_trades, 'win_rate': win_rate, 'max_drawdown': mdd, + 'n_bought': n_bought, 'n_skipped': n_skipped, + } + + +# ═══════════════════════════════════════════════════════════════ +# 5c. 鲁棒性验证 — 超参数稳定性确认 +# ═══════════════════════════════════════════════════════════════ + +def walk_forward_stock_refit(features, labels, sig_data, + refit_months=6, feature_indices=None): + """ + Walk-forward扩展窗口验证 — 可参数化refit窗口和特征子集 + + 用于鲁棒性验证(5c节): 扫描不同refit窗口(3/6/12月)和特征集(full/manual), + 验证量子优势是否依赖特定超参数配置。 + + 参数: + refit_months: refit窗口长度(月), 3/6/12 → 63/126/252交易日 + feature_indices: 特征列索引列表, None=全部特征 + + 返回: 同walk_forward_stock_level ({q_probs, lr_probs}) + """ + if feature_indices is not None: + feats = features[:, feature_indices] + n_qubits = len(feature_indices) + else: + feats = features + n_qubits = N_QUBITS + + seg_len = refit_months * 21 # ~21交易日/月 + + sig_dates = [sd[0] for sd in sig_data] + order = np.argsort(sig_dates) + sorted_features = feats[order] + sorted_labels = labels[order] + sorted_dates = [sig_dates[i] for i in order] + + test_start_idx = None + for i, d in enumerate(sorted_dates): + if d >= TEST_START: + test_start_idx = i + break + if test_start_idx is None: + return None + + test_dates_list = sorted_dates[test_start_idx:] + unique_test_days = sorted(set(test_dates_list)) + n_day_segs = max(1, (len(unique_test_days) + seg_len - 1) // seg_len) + day_segments = [] + for s in range(n_day_segs): + d0 = s * seg_len + d1 = min((s + 1) * seg_len, len(unique_test_days)) + day_segments.append((unique_test_days[d0], unique_test_days[d1 - 1])) + + segments = [] + for day_lo, day_hi in day_segments: + s_start = s_end = test_start_idx + for j in range(test_start_idx, len(sorted_dates)): + if sorted_dates[j] < day_lo: + s_start = j + 1 + if sorted_dates[j] <= day_hi: + s_end = j + 1 + segments.append((s_start, s_end)) + + q_probs = np.zeros(len(sorted_dates)) + lr_probs = np.zeros(len(sorted_dates)) + + for si, (seg_start, seg_end) in enumerate(segments): + train_X = sorted_features[:seg_start].copy() + train_y = sorted_labels[:seg_start].copy() + test_X = sorted_features[seg_start:seg_end].copy() + + if len(train_X) < 30 or len(np.unique(train_y)) < 2: + q_probs[seg_start:seg_end] = 0.5 + lr_probs[seg_start:seg_end] = 0.5 + continue + + scaler = StandardScaler() + train_X_s = scaler.fit_transform(train_X) + test_X_s = scaler.transform(test_X) + + # 量子核SVM + try: + train_states = compute_quantum_states( + train_X_s, build_angle_encoding, n_qubits, N_REPS, SCALE) + test_states = compute_quantum_states( + test_X_s, build_angle_encoding, n_qubits, N_REPS, SCALE) + K_train = quantum_kernel_matrix(train_states) + K_test = quantum_kernel_matrix(train_states, test_states) + q_clf = SVC(kernel='precomputed', C=Q_C, probability=True, random_state=42) + q_clf.fit(K_train, train_y) + q_prob = q_clf.predict_proba(K_test) + q_prob_pos = q_prob[:, 1] if q_clf.classes_[1] == 1 else q_prob[:, 0] + except Exception: + q_prob_pos = np.array([0.5] * len(test_X_s)) + + # 经典LogReg + try: + lr_clf = LogisticRegression(max_iter=1000, random_state=42) + lr_clf.fit(train_X_s, train_y) + lr_prob = lr_clf.predict_proba(test_X_s) + lr_prob_pos = lr_prob[:, 1] if lr_clf.classes_[1] == 1 else lr_prob[:, 0] + except Exception: + lr_prob_pos = np.array([0.5] * len(test_X_s)) + + q_probs[seg_start:seg_end] = q_prob_pos + lr_probs[seg_start:seg_end] = lr_prob_pos + + # 恢复原始顺序 + q_probs_orig = np.zeros(len(sig_data)) + lr_probs_orig = np.zeros(len(sig_data)) + for new_i, orig_pos in enumerate(order): + q_probs_orig[orig_pos] = q_probs[new_i] + lr_probs_orig[orig_pos] = lr_probs[new_i] + + return {'q_probs': q_probs_orig, 'lr_probs': lr_probs_orig} + + +def adjust_trades_for_shorten_bad(sig_data, probs, threshold=0.35, shorten_days=1): + """ + 卖出端量子调整 — shorten_bad机制 (5c.3 / 5d节) + + 量子核SVM预测每个交易日的"好/坏"概率, 对概率L稳定性检验 (5c节) + + 扫描6种配置: 3种refit窗口(3/6/12月) × 2种特征集(full6/manual4) + 每组: walk-forward量子核SVM + 经典LogReg, 阈值扫描, 量子概率排序回测 + 报告: Q>L / Q>基线 的通过率 + + 5c.2结果(强化基线策略): 6/6 Q>L ✅, 6/6 Q>基线 ✅, Q/L=1.92~3.90x + """ + log("=" * 70) + log("鲁棒性验证 — 超参数稳定性确认 (5c节)") + log("=" * 70) + + GAP_TARGET = 2.0 + signals = signals_df[signals_df['gap_pct'] >= GAP_TARGET].copy() + log(f" GAP{GAP_TARGET}%, {len(signals)}个信号") + + features, labels, sig_data = build_stock_features(signals, all_data) + log(f" 特征矩阵: {features.shape}, 正样本率: {labels.mean() * 100:.1f}%") + + # 基线 + baseline = run_backtest(sig_data, None, None) + log(f" 基线: {baseline['total_return']:+.1f}% ({baseline['final_equity']:.0f}元)") + + # 6种配置: 3 refit × 2 feature sets + # manual4 = 精选4维 [gap_pct, vol_ratio, ma_dist, ret_5d] (跳过上影线/实体) + configs = [ + ('refit3m_full6', 3, None, '3月refit + 6维全特征'), + ('refit6m_full6', 6, None, '6月refit + 6维全特征'), + ('refit12m_full6', 12, None, '12月refit + 6维全特征'), + ('refit3m_manual4', 3, [0, 1, 2, 5], '3月refit + 4维精选'), + ('refit6m_manual4', 6, [0, 1, 2, 5], '6月refit + 4维精选'), + ('refit12m_manual4',12, [0, 1, 2, 5], '12月refit + 4维精选'), + ] + + results = OrderedDict() + n_q_gt_l = 0 + n_q_gt_bl = 0 + + for name, refit_m, feat_idx, desc in configs: + log(f"\n [{name}] {desc}") + wf = walk_forward_stock_refit(features, labels, sig_data, + refit_months=refit_m, + feature_indices=feat_idx) + if wf is None: + log(f" SKIP (wf failed)") + continue + + q_probs = wf['q_probs'] + lr_probs = wf['lr_probs'] + + # 阈值扫描 — B_sort_desc模式(量子概率排序) + best_q = {'lift': -9999, 'result': None, 'th': None} + best_lr = {'lift': -9999, 'result': None, 'th': None} + min_trades = max(10, int(baseline['n_trades'] * 0.20)) + + for th in SCAN_THRESHOLDS: + q_r = run_backtest(sig_data, q_probs, th, sort_mode='prob') + lr_r = run_backtest(sig_data, lr_probs, th, sort_mode='prob') + q_lift = q_r['total_return'] - baseline['total_return'] + lr_lift = lr_r['total_return'] - baseline['total_return'] + if q_lift > best_q['lift'] and q_r['n_trades'] >= min_trades: + best_q = {'lift': q_lift, 'result': q_r, 'th': th} + if lr_lift > best_lr['lift'] and lr_r['n_trades'] >= min_trades: + best_lr = {'lift': lr_lift, 'result': lr_r, 'th': th} + + ql = best_q['lift'] + ll = best_lr['lift'] + ratio = ql / ll if ll != 0 else float('inf') + q_gt_l = ql > ll + q_gt_bl = ql > 0 + + if q_gt_l: + n_q_gt_l += 1 + if q_gt_bl: + n_q_gt_bl += 1 + + bqr = best_q['result'] + blr = best_lr['result'] + log(f" Q: {bqr['total_return']:+.1f}% (Δ{ql:+.1f}pp) | " + f"L: {blr['total_return']:+.1f}% (Δ{ll:+.1f}pp) | " + f"Q/L={ratio:.2f}x | Q>L:{'✅' if q_gt_l else '❌'} | " + f"Q>基线:{'✅' if q_gt_bl else '❌'}") + + results[name] = { + 'refit_months': refit_m, + 'feature_set': 'full6' if feat_idx is None else 'manual4', + 'q_return': bqr['total_return'] if bqr else None, + 'q_lift': ql, + 'l_return': blr['total_return'] if blr else None, + 'l_lift': ll, + 'ql_ratio': float(ratio) if ratio != float('inf') else None, + 'q_beats_l': q_gt_l, + 'q_beats_baseline': q_gt_bl, + } + + # 汇总 + n_configs = len(configs) + log(f"\n{'=' * 70}") + log(f"鲁棒性验证汇总 ({n_configs}组)") + log(f" Q>L: {n_q_gt_l}/{n_configs} {'✅ 全部通过' if n_q_gt_l == n_configs else '❌'}") + log(f" Q>基线: {n_q_gt_bl}/{n_configs} {'✅ 全部通过' if n_q_gt_bl == n_configs else '❌'}") + log(f"{'=' * 70}") + + # 保存结果 + out_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), + 'robustness_results.json') + with open(out_path, 'w', encoding='utf-8') as f: + json.dump(dict(results), f, ensure_ascii=False, indent=2, default=str) + log(f"结果已保存: {out_path}") + log("✓ 鲁棒性验证完成!") + + +# ═══════════════════════════════════════════════════════════════ +# 5d. 买卖结合实验 — 协同效应分析 (框架说明) +# ═══════════════════════════════════════════════════════════════ +# +# 买卖结合实验需要同时使用: +# - 买入端: 个股级量子排序 (walk_forward_stock_refit + run_backtest sort_mode='prob') +# - 卖出端: 日级量子预测 (main.py的walk_forward_validation + adjust_trades_for_shorten_bad) +# +# 实验设计: +# baseline: 跳空%排序 + 无卖出调整 +# B_only: 量子概率排序 + 无卖出调整 (仅买入端量子) +# S_only: 跳空%排序 + shorten_bad-1 (仅卖出端量子) +# B+S: 量子概率排序 + shorten_bad-1 (买卖双向量子) +# +# 5d.3结果(强化基线策略): +# baseline: Q+4220% / L+4220% +# B_only: Q+5291% (Δ+1071pp) / L+3050% → ★★★ 最优 +# S_only: Q+3371% (Δ-849pp) / L+3055% +# B+S: Q+4712% (Δ+492pp) / L+1850% → 无协同效应(-579pp synergy gap) +# +# 结论: 买入端量子排序单独使用效果最好, 买卖结合产生拮抗效应 + + +def main(data_path=None, mode='default'): + """ + 主函数: 个股级量子筛选完整流程 + + mode='default': 3组GAP阈值扫描 (5b节) + mode='robustness': 鲁棒性验证 — 多refit×多特征集Q>L稳定性 (5c节) + """ + log("=" * 70) + log("量子核SVM个股级筛选 — Stock-Level Quantum Filtering") + log("★从日级NOOP升级为个股级判定★") + log("=" * 70) + + # === 数据加载 === + if data_path is None: + data_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), + '..', 'all_data.pkl') + if not os.path.exists(data_path): + log(f"all_data.pkl not found at {data_path}") + log("Please provide --data_path /path/to/all_data.pkl") + return + + log(f"加载数据: {data_path}") + with open(data_path, 'rb') as f: + all_data = pickle.load(f) + + signals_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), + 'trading_signals_sample.pkl') + signals_df = load_zp_signals(signals_path) + if signals_df is None or len(signals_df) == 0: + log("无信号! 请检查 trading_signals_sample.pkl") + return + log(f" 交易信号: {len(signals_df)}个, 日期范围: " + f"{signals_df.index[0].date()} ~ {signals_df.index[-1].date()}") + log(f" 个股数据: {len(all_data.get('close', {}))}只") + + # === 模式分发 === + if mode == 'robustness': + run_robustness_check(signals_df, all_data) + return + + # === 多GAP扫描 === + results = OrderedDict() + + for gap_min in GAP_MIN_VALUES: + label = f"GAP{gap_min:.1f}" + log(f"\n{'='*60}") + log(f"[*] GAP_MIN={gap_min}% ({label})") + log(f"{'='*60}") + + signals = signals_df[signals_df['gap_pct'] >= gap_min].copy() + log(f" {len(signals)}个信号") + if len(signals) < 100: + log(f" 信号太少, 跳过") + results[label] = {'error': 'too few', 'n_signals': len(signals)} + continue + + features, labels, sig_data = build_stock_features(signals, all_data) + pos_rate = labels.mean() * 100 + log(f" 特征矩阵: {features.shape}, 正样本率: {pos_rate:.1f}%") + + log(f" Walk-Forward个股级验证...") + wf = walk_forward_stock_level(features, labels, sig_data) + if wf is None: + results[label] = {'error': 'wf failed'} + continue + + q_probs = wf['q_probs'] + lr_probs = wf['lr_probs'] + + # 基线 + baseline = run_backtest(sig_data, None, None) + log(f" 基线: {baseline['total_return']:+.1f}% " + f"({baseline['final_equity']:.0f}元, {baseline['n_trades']}笔, " + f"WR{baseline['win_rate']:.1f}%)") + + # 阈值扫描 + min_trades = max(10, int(baseline['n_trades'] * 0.20)) + best_q = {'result': None, 'th': None, 'lift': -9999} + best_lr = {'result': None, 'th': None, 'lift': -9999} + th_results = [] + + for th in SCAN_THRESHOLDS: + q_r = run_backtest(sig_data, q_probs, th) + q_lift = q_r['total_return'] - baseline['total_return'] + lr_r = run_backtest(sig_data, lr_probs, th) + lr_lift = lr_r['total_return'] - baseline['total_return'] + + th_results.append({ + 'th': th, + 'q_ret': q_r['total_return'], 'q_lift': q_lift, + 'q_trades': q_r['n_trades'], 'q_wr': q_r['win_rate'], + 'q_bought': q_r['n_bought'], 'q_skipped': q_r['n_skipped'], + 'lr_ret': lr_r['total_return'], 'lr_lift': lr_lift, + 'lr_trades': lr_r['n_trades'], 'lr_wr': lr_r['win_rate'], + }) + + if q_lift > best_q['lift'] and q_r['n_trades'] >= min_trades: + best_q = {'result': q_r, 'th': th, 'lift': q_lift} + if lr_lift > best_lr['lift'] and lr_r['n_trades'] >= min_trades: + best_lr = {'result': lr_r, 'th': th, 'lift': lr_lift} + + bqr = best_q['result'] + blr = best_lr['result'] + ql = best_q['lift'] + ll = best_lr['lift'] + ratio = ql / ll if ll != 0 else float('inf') + + log(f"\n === {label} 个股级筛选结果 ===") + log(f" {'th':>5} | {'Q收益%':>8} | {'Q提升':>7} | {'Q笔数':>5} | " + f"{'L收益%':>8} | {'L提升':>7} | {'L笔数':>5}") + log(" " + "-" * 75) + for tr in th_results: + log(f" {tr['th']:>5.2f} | {tr['q_ret']:>+8.1f} | {tr['q_lift']:>+7.1f} | " + f"{tr['q_trades']:>5} | {tr['lr_ret']:>+8.1f} | {tr['lr_lift']:>+7.1f} | " + f"{tr['lr_trades']:>5}") + + if bqr: + skip_pct = bqr['n_skipped'] / max(bqr['n_bought'] + bqr['n_skipped'], 1) * 100 + log(f" 量子最佳(th={best_q['th']}): {bqr['total_return']:+.1f}% " + f"({bqr['final_equity']:.0f}元, {bqr['n_trades']}笔, 跳过{skip_pct:.0f}%)") + log(f" 量子提升: {ql:+.1f}pp") + if blr: + log(f" 经典最佳(th={best_lr['th']}): {blr['total_return']:+.1f}%, 经典提升: {ll:+.1f}pp") + log(f" Q/L = {ratio:.2f}x") + + results[label] = { + 'gap_min': gap_min, 'n_signals': len(signals), + 'n_matched': len(sig_data), 'pos_rate': float(pos_rate), + 'baseline_return': baseline['total_return'], + 'baseline_equity': baseline['final_equity'], + 'baseline_trades': baseline['n_trades'], + 'baseline_wr': baseline['win_rate'], + 'best_q_th': best_q['th'], + 'best_q_return': bqr['total_return'] if bqr else None, + 'best_q_equity': bqr['final_equity'] if bqr else None, + 'best_q_trades': bqr['n_trades'] if bqr else None, + 'best_q_wr': bqr['win_rate'] if bqr else None, + 'best_q_mdd': bqr['max_drawdown'] if bqr else None, + 'best_q_bought': bqr['n_bought'] if bqr else None, + 'best_q_skipped': bqr['n_skipped'] if bqr else None, + 'best_q_lift': ql, + 'best_lr_th': best_lr['th'], + 'best_lr_return': blr['total_return'] if blr else None, + 'best_lr_lift': ll, + 'ql_ratio': float(ratio) if ratio != float('inf') else None, + 'threshold_scan': th_results, + } + + # === 综合对比 === + log("\n" + "=" * 90) + log("综合对比 — 个股级量子筛选") + log("=" * 90) + log(f"\n{'GAP':>5} | {'信号':>5} | {'正样本%':>6} | {'基线%':>8} | " + f"{'量子%':>8} | {'Q提升':>7} | {'经典%':>8} | {'L提升':>7} | {'Q/L':>5} | {'跳过%':>5}") + log("-" * 90) + + for label, r in results.items(): + if 'error' in r: + continue + ql = r.get('best_q_lift', 0) + ll = r.get('best_lr_lift', 0) + ratio = ql / ll if ll != 0 else float('inf') + skip_pct = r.get('best_q_skipped', 0) / max( + r.get('best_q_bought', 1) + r.get('best_q_skipped', 0), 1) * 100 + log(f"{r['gap_min']:>4.1f}% | {r['n_matched']:>5} | {r['pos_rate']:>5.1f}% | " + f"{r['baseline_return']:>+8.1f} | {r.get('best_q_return',0):>+8.1f} | " + f"{ql:>+7.1f} | {r.get('best_lr_return',0):>+8.1f} | {ll:>+7.1f} | " + f"{ratio:>5.2f} | {skip_pct:>4.0f}%") + + # === 保存结果 === + out_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), + 'stock_level_results.json') + with open(out_path, 'w', encoding='utf-8') as f: + json.dump(dict(results), f, ensure_ascii=False, indent=2, default=str) + log(f"\n结果已保存: {out_path}") + log("✓ 完成!") + + +if __name__ == '__main__': + import argparse + parser = argparse.ArgumentParser(description='Stock-Level Quantum Filtering') + parser.add_argument('--data_path', type=str, default=None, + help='Path to all_data.pkl') + parser.add_argument('--mode', type=str, default='default', + choices=['default', 'robustness'], + help='default=3组GAP扫描(5b), robustness=鲁棒性验证(5c)') + args = parser.parse_args() + main(data_path=args.data_path, mode=args.mode) diff --git a/quantum_ashare_market_timing/trading_signals_sample.pkl b/quantum_ashare_market_timing/trading_signals_sample.pkl new file mode 100644 index 00000000..8b41b5c5 Binary files /dev/null and b/quantum_ashare_market_timing/trading_signals_sample.pkl differ