{"id":"be90ad3c-7f68-45c4-ac86-c5f54e8d4969","entityType":"agent","slug":"clawhub-gechengling-security-quant-backtest","name":"Security Quant Backtest","canonicalUrl":"https://www.xpersona.co/agent/clawhub-gechengling-security-quant-backtest","canonicalPath":"/agent/clawhub-gechengling-security-quant-backtest","generatedAt":"2026-10-10T21:40:03.507Z","source":"CLAWHUB","claimStatus":"UNCLAIMED","verificationTier":"NONE","summary":{"evidence":{"source":"editorial-content","verified":true,"confidence":"high","updatedAt":"2026-10-10T18:43:06.419Z","emptyReason":null},"description":"AI-powered quantitative backtesting tool for China A-share strategies, supporting design, historical tests, performance attribution, walk-forward analysis, a... Skill: Security Quant Backtest Owner: gechengling Summary: AI-powered quantitative backtesting tool for China A-share strategies, supporting design, historical tests, performance attribution, walk-forward analysis, a... Tags: latest:3.0.3, security-quant-backtest:3.0.3 Version history: v3.0.3 | 2026-10-08T05:12:47.389Z | user 3.0.3: content update v3.0.2 | 2026-09-12T07:25:12.439Z | user 内容增强：回测新增指标解读表、未来函数检查清单与成本拆解示","descriptionLabel":"Technical summary","evidenceSummary":"Capability contract not published. No trust telemetry is available yet. 1.3K downloads reported by the source. Last updated 10/10/2026.","installCommand":"clawhub skill install s17ewqc4f2s6gpcbm88hy7fgvn85kg1g:security-quant-backtest","sourceUrl":"https://clawhub.ai/gechengling/security-quant-backtest","homepage":"https://clawhub.ai/gechengling/skills/security-quant-backtest","primaryLinks":[{"label":"View on ClawHub","url":"https://clawhub.ai/gechengling/security-quant-backtest","kind":"source"},{"label":"Homepage","url":"https://clawhub.ai/gechengling/skills/security-quant-backtest","kind":"homepage"}],"safetyScore":84,"overallRank":62,"popularityScore":62,"trustScore":null,"claimedByName":null,"isOwner":false,"seoDescription":"AI-powered quantitative backtesting tool for China A-share strategies, supporting design, historical tests, performance attribution, walk-forward analysis, a..."},"coverage":{"evidence":{"source":"public-profile","verified":false,"confidence":"medium","updatedAt":"2026-10-10T18:43:06.419Z","emptyReason":null},"protocols":[{"protocol":"OPENCLEW","label":"OpenClaw","status":"self-declared","notes":"Declared in the public agent profile."}],"capabilities":[],"verifiedCount":0,"selfDeclaredCount":1,"capabilityMatrix":{"rows":[{"key":"OPENCLEW","type":"protocol","support":"unknown","confidenceSource":"profile","notes":"Listed on profile"}],"flattenedTokens":"protocol:OPENCLEW|unknown|profile"}},"adoption":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-10T18:43:06.419Z","emptyReason":null},"stars":null,"forks":null,"downloads":1292,"packageName":null,"latestVersion":"3.0.3","tractionLabel":"1.3K downloads"},"release":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-10T18:43:06.419Z","emptyReason":null},"lastUpdatedAt":"2026-10-10T18:43:06.419Z","lastCrawledAt":"2026-10-10T18:43:06.419Z","lastIndexedAt":null,"nextCrawlAt":"2026-10-11T18:43:06.419Z","lastVerifiedAt":null,"highlights":[{"version":"3.0.3","createdAt":"2026-10-08T05:12:47.389Z","changelog":"3.0.3: content update","fileCount":3,"zipByteSize":15086},{"version":"3.0.2","createdAt":"2026-09-12T07:25:12.439Z","changelog":"内容增强：回测新增指标解读表、未来函数检查清单与成本拆解示例；策略示例新增布林带突破策略与三类策略适用环境对比、参数寻优与敏感性判断示例；蒙特卡洛补结果解读与三种误用；新增前向分析与绩效归因模块（设计表、样本内外对比、归因分解）；监管动态更新至 2026-09-12","fileCount":3,"zipByteSize":10865},{"version":"3.0.1","createdAt":"2026-05-25T03:40:52.246Z","changelog":"Version 3.0.1 - Updated SKILL.md with the latest China A-share quantitative regulatory news as of 2026-05-25. - Added a section summarizing recent regulatory trends and their impact on quant backtesting (e.g., need for crowding factors, stress-testing, and compliance cost modules). - No core logic or code changes; update is documentation-focused for latest industry context. - Clarified data sources and disclaimer regarding policy information.","fileCount":3,"zipByteSize":6336},{"version":"2.0.0","createdAt":"2026-05-11T14:31:17.114Z","changelog":"Version 2.0.0 — Major update: introduces a fully redesigned, AI-powered quantitative backtesting laboratory for China A-share strategies. - Adds new, modular backtesting engine supporting historical simulation, trade execution, and comprehensive performance reporting. - Integrates solutions for key industry challenges: future leakage, overfitting, slippage, survivorship bias, and execution gaps. - Provides built-in support for strategy design, performance attribution, walk-forward analysis, and Monte Carlo simulation. - Now includes English and Chinese documentation with detailed usage instructions and strategy examples. - Designed for quantitative analysts, algorithmic traders, and Python-based backtesting workflows.","fileCount":2,"zipByteSize":4728}]},"execution":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No published capability contract is available yet."},"installCommand":"clawhub skill install s17ewqc4f2s6gpcbm88hy7fgvn85kg1g:security-quant-backtest","setupComplexity":"low","setupSteps":["Setup complexity is LOW. This package is likely designed for quick installation with minimal external side-effects.","Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data."],"contract":{"contractStatus":"missing","authModes":[],"requires":[],"forbidden":[],"supportsMcp":false,"supportsA2a":false,"supportsStreaming":false,"inputSchemaRef":null,"outputSchemaRef":null,"dataRegion":null,"contractUpdatedAt":null,"sourceUpdatedAt":null,"freshnessSeconds":null},"invocationGuide":{"preferredApi":{"snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-gechengling-security-quant-backtest/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-gechengling-security-quant-backtest/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-gechengling-security-quant-backtest/trust"},"curlExamples":["curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-gechengling-security-quant-backtest/snapshot\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-gechengling-security-quant-backtest/contract\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-gechengling-security-quant-backtest/trust\""],"jsonRequestTemplate":{"query":"summarize this repo","constraints":{"maxLatencyMs":2000,"protocolPreference":["OPENCLEW"]}},"jsonResponseTemplate":{"ok":true,"result":{"summary":"...","confidence":0.9},"meta":{"source":"CLAWHUB","generatedAt":"2026-10-10T21:40:03.506Z"}},"retryPolicy":{"maxAttempts":3,"backoffMs":[500,1500,3500],"retryableConditions":["HTTP_429","HTTP_503","NETWORK_TIMEOUT"]}},"endpoints":{"dossierUrl":"https://www.xpersona.co/api/v1/agents/clawhub-gechengling-security-quant-backtest/dossier","snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-gechengling-security-quant-backtest/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-gechengling-security-quant-backtest/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-gechengling-security-quant-backtest/trust"}},"reliability":{"evidence":{"source":"runtime-metrics","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No trust, reliability, or runtime telemetry is available."},"trust":{"status":"unavailable","handshakeStatus":"UNKNOWN","verificationFreshnessHours":null,"reputationScore":null,"p95LatencyMs":null,"successRate30d":null,"fallbackRate":null,"attempts30d":null,"trustUpdatedAt":null,"trustConfidence":"unknown","sourceUpdatedAt":null,"freshnessSeconds":null},"decisionGuardrails":{"doNotUseIf":["Contract metadata is missing or unavailable for deterministic execution."],"safeUseWhen":[],"riskFlags":["missing_or_unavailable_contract","trust_data_unavailable","schema_references_missing"],"operationalConfidence":"low"},"executionMetrics":{"observedLatencyMsP50":null,"observedLatencyMsP95":null,"estimatedCostUsd":null,"uptime30d":null,"rateLimitRpm":null,"rateLimitBurst":null,"lastVerifiedAt":null,"verificationSource":null},"runtimeMetrics":{"successRate":null,"avgLatencyMs":null,"avgCostUsd":null,"hallucinationRate":null,"retryRate":null,"disputeRate":null,"p50Latency":null,"p95Latency":null,"lastUpdated":null}},"benchmarks":{"evidence":{"source":"no-benchmark-data","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No benchmark suites or observed failure patterns are available."},"suites":[],"failurePatterns":[]},"artifacts":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"high","updatedAt":"2026-10-10T18:43:06.419Z","emptyReason":null},"readme":"Skill: Security Quant Backtest\n\nOwner: gechengling\n\nSummary: AI-powered quantitative backtesting tool for China A-share strategies, supporting design, historical tests, performance attribution, walk-forward analysis, a...\n\nTags: latest:3.0.3, security-quant-backtest:3.0.3\n\nVersion history:\n\nv3.0.3 | 2026-10-08T05:12:47.389Z | user\n\n3.0.3: content update\n\nv3.0.2 | 2026-09-12T07:25:12.439Z | user\n\n内容增强：回测新增指标解读表、未来函数检查清单与成本拆解示例；策略示例新增布林带突破策略与三类策略适用环境对比、参数寻优与敏感性判断示例；蒙特卡洛补结果解读与三种误用；新增前向分析与绩效归因模块（设计表、样本内外对比、归因分解）；监管动态更新至 2026-09-12\n\nv3.0.1 | 2026-05-25T03:40:52.246Z | auto\n\nVersion 3.0.1\n\n- Updated SKILL.md with the latest China A-share quantitative regulatory news as of 2026-05-25.\n- Added a section summarizing recent regulatory trends and their impact on quant backtesting (e.g., need for crowding factors, stress-testing, and compliance cost modules).\n- No core logic or code changes; update is documentation-focused for latest industry context.\n- Clarified data sources and disclaimer regarding policy information.\n\nv2.0.0 | 2026-05-11T14:31:17.114Z | auto\n\nVersion 2.0.0 — Major update: introduces a fully redesigned, AI-powered quantitative backtesting laboratory for China A-share strategies.\n\n- Adds new, modular backtesting engine supporting historical simulation, trade execution, and comprehensive performance reporting.\n- Integrates solutions for key industry challenges: future leakage, overfitting, slippage, survivorship bias, and execution gaps.\n- Provides built-in support for strategy design, performance attribution, walk-forward analysis, and Monte Carlo simulation.\n- Now includes English and Chinese documentation with detailed usage instructions and strategy examples.\n- Designed for quantitative analysts, algorithmic traders, and Python-based backtesting workflows.\n\nArchive index:\n\nArchive v3.0.3: 3 files, 15086 bytes\n\nFiles: skill-card.md (2122b), SKILL.md (35817b), _meta.json (142b)\n\nFile v3.0.3:SKILL.md\n\n---\r\nname: Quantitative Backtesting Laboratory\r\nslug: security-quant-backtest\r\ndescription: AI-powered quantitative backtesting laboratory for China A-share — strategy design, historical backtesting with cost/slippage modelling, walk-forward validation, performance attribution and Monte Carlo simulation. Scope: research and validation of a defined trading rule on historical data; not live order routing, not execution advice, not return promises. Keywords: backtest a strategy, walk-forward validation, slippage and cost model, look-ahead bias check, overfitting test, Monte Carlo simulation, performance attribution, A-share, 策略回测, 前向分析, 滑点与成本建模, 未来函数检查, 过拟合检验, 蒙特卡洛模拟, 绩效归因.\r\nversion: \"3.0.3\"\r\n---\r\n\r\n# Quantitative Backtesting Laboratory / 量化回测实验室\r\n\r\n> **English:** AI-powered quantitative backtesting laboratory — covers strategy design, historical backtesting, performance attribution, walk-forward analysis, and Monte Carlo simulation. Built for quant analysts and algorithmic traders.\r\n>\r\n> **中文:** 量化回测实验室——覆盖策略设计、历史回测、绩效归因、前向分析、蒙特卡洛模拟。适用：量化分析师、算法交易者、Python回测开发。\r\n\r\n\r\n## 数据最小化声明与执行边界 / Data Minimisation & Execution Boundary\r\n\r\n**数据最小化前置声明：** 使用本技能时，请只提供回测所必需的输入——标的代码、行情区间、策略规则与参数、费率假设。**不要**粘贴实盘账户信息、真实持仓明细、交易席位与柜台配置、客户身份信息或券商内部的行情源凭证；回测规模请用\"100万初始资金\"这类假设值。\r\n\r\n**保存与预览确认：** 本技能不执行任何保存动作。若你在自己环境中依据本技能生成回测脚本、绩效报告或蒙特卡洛结果，请在落盘或对外展示前**先预览结果、确认无前视偏差且成本口径与实盘一致，再保存或提交**。\r\n\r\n**代码块性质与执行边界**\r\n\r\n| 内容 | 性质 | 谁来执行 |\r\n|------|------|---------|\r\n| `BacktestEngine` 类（撮合、成本、绩效） | 回测引擎的计算口径说明 | 由量化分析师在自己环境中取数并运行；技能不取数、不运行 |\r\n| `DualMovingAverageStrategy` / `RSIMeanReversionStrategy` / `BollingerBreakoutStrategy` | 三条典型策略规则的信号生成示意 | 同上，属教学示意 |\r\n| `MonteCarloSimulation` 类 | 随机路径与分位数统计的算法表达 | 由量化分析师在自己环境中运行 |\r\n| 检查清单、成本表、归因表 | 研究用模板 | 由研究/合规人员在机构流程中落实 |\r\n\r\n**重要：** 上述引擎是**教学示意用的简化实现**，单标的、无涨跌停与停牌约束、无部分成交，实盘前必须在机构自有的回测系统中重建并补齐约束。本技能未配置任何工具调用权限，不执行代码、不读写文件、不访问行情数据源、不下单、不连接交易柜台。回测结果为模拟结果，不构成收益承诺。\r\n\r\n---\r\n\r\n---\r\n\r\n\r\n### 证券监管最新动态 [2026-10-08更新]\r\n\r\n| 动态类型 | 内容摘要 | 影响范围 | 回测侧应对动作 | 责任岗 | 优先级 | 复核频率 | |\r\n|---------|---------|---------|--------------|-------|-------|---|\r\n| 证券监管 | 2026年A股量化资金占比30%-40%，回测需考虑拥挤度因子 | 回测框架需增加拥挤度、压力测试和合规成本模块 | 回测报告增加拥挤度指标与容量估算 | 研究 | 高 | 每季 |\r\n| 证券监管 | 2026年3月量化踩踏事件：回测模型需加入极端行情压力测试 | 回测框架需增加拥挤度、压力测试和合规成本模块 | 回测加入流动性枯竭情景的损失估算 | 研究 | 高 | 每季 |\r\n| 证券监管 | 算法监管趋严，高频策略回测需考虑合规成本 | 回测框架需增加拥挤度、压力测试和合规成本模块 | 成本模型中单列合规与报告成本 | 合规 | 高 | 每季 |\r\n| 程序化交易 | 程序化交易报告与异常交易监控要求细化 | 高频与中高频策略 | 回测中增加报撤单频率与异常交易约束 | 合规 | 中 | 每月 |\r\n| 交易成本 | 佣金、印花税与过户费口径需与实盘一致 | 成本模型、净收益指标 | 成本参数按最新费率更新并标注生效日期 | 研究 | 高 | 每季 |\r\n| 数据质量 | 回测输入数据需可追溯 | 行情与财务数据 | 数据源、复权方式与取数日期须在报告中标注 | 研究 | 高 | 每季 |\r\n| 投资者保护 | 量化产品业绩展示与宣传表述趋严 | 回测业绩对外展示 | 回测结果标注为模拟结果、不构成收益承诺 | 合规 | 高 | 每季 |\r\n| 风控要求 | 策略容量与集中度管理要求提升 | 策略规模与持仓集中度 | 输出策略容量估算与集中度约束 | 风控 | 中 | 每季 |\r\n| 程序化交易 | 2026年10月：程序化交易的报备字段与异常交易指标口径进一步细化 | 高频与中高频策略回测 | 回测中增加报撤单比、瞬时申报速率等约束的模拟与超限拦截 | 合规 | 高 | 每月 |\r\n| 投资者保护 | 2026年四季度初：量化产品业绩展示须同时披露比较基准与模拟/实盘属性 | 回测业绩对外展示材料 | 回测曲线标注\"模拟结果+回测区间+比较基准\"，并披露样本外表现 | 合规 | 高 | 每季 |\r\n\r\n> **数据截止**: 2026-10-08 | 来源：证监会、交易所公开规则、行业公开信息\r\n> **声明**: 以上动态供参考，具体以官方最新发布为准\r\n\r\n**动态解读示例（四类高频场景）**\r\n\r\n- **场景A｜容量估算缺失**：回测年化30%但未给容量上限 → 命中\"拥挤度与容量\"要求 → 输出策略容量估算（按日均成交额占比），并说明规模扩大后收益衰减趋势。\r\n- **场景B｜极端情景缺失**：回测最大回撤仅−12%，未含流动性枯竭情景 → 命中\"极端行情压力测试\"要求 → 增加\"成交量降至五成\"情景下的滑点扩大与无法及时减仓的损失估算。\r\n- **场景C｜成本口径过期**：成本模型仍用旧费率 → 命中\"成本参数需与实盘一致\"要求 → 更新费率参数并标注生效日期，重算净收益指标。\r\n- **场景D｜业绩展示**：对客材料直接使用回测收益曲线 → 命中\"业绩展示\"要求 → 曲线旁标注\"模拟回测结果，不构成收益承诺\"，并披露假设条件。\r\n\r\n## Industry Pain Points / 行业痛点\r\n\r\n| Pain Point / 痛点 | Impact / 影响 | Solution / 本Skill解决方案 | 量化基线指标 / Baseline |\r\n|------------------|-------------|------------------------|----------------------|\r\n| **未来函数** | 回测虚高，实盘亏损 | 信号对齐检查+严格回测规范 | 前视检查项通过率 100% |\r\n| **过拟合** | 参数过度优化，实盘失效 | 样本外测试+统计显著性检验 | 样本外/样本内收益比 ≥0.6 |\r\n| **滑点假设** | 低估交易成本，实盘收益缩水 | 多场景滑点模拟 | 至少3档滑点情景对比 |\r\n| **幸存者偏差** | 只用现存股票，忽视退市股 | 使用完整历史数据 | 含退市标的的完整样本 |\r\n| **执行缺口** | 回测vs实盘收益差异大 | 分层回测+执行模拟 | 回测与实盘差异 ≤20% |\r\n| **容量未估** | 规模扩大后收益快速衰减 | 容量估算模型 | 给出容量上限与衰减曲线 |\r\n| **参数敏感** | 参数微调收益剧变 | 参数敏感性热力图 | 邻域内收益波动 <30% |\r\n| **成本失真** | 未含印花税/合规成本 | 完整成本模型 | 成本项完整率 100% |\r\n\r\n---\r\n\r\n## Trigger Keywords / 触发关键词\r\n\r\n**English Triggers (backtesting/validating a defined trading rule only):** backtest a strategy, walk-forward validation, out-of-sample test, look-ahead bias check, overfitting test, slippage and cost model, Monte Carlo simulation, performance attribution, strategy capacity estimate\r\n\r\n**English Non-Triggers:** algorithmic trading, quant strategy, Python, trading bot, live trading, order execution, market data — these alone do **not** route here unless the task is to backtest or validate a specific rule on historical data. Live execution and order routing are out of scope.\r\n\r\n**中文触发词（须落在\"回测或验证一条具体策略规则\"任务上才触发）：** 策略回测 / 双均线回测 / RSI策略回测 / 布林带回测 / 前向分析 / 样本外检验 / 未来函数检查 / 过拟合检验 / 参数敏感性分析 / 滑点成本建模 / 策略容量估算 / 蒙特卡洛模拟 / 绩效归因分解 / 回测与实盘差异诊断\r\n\r\n**不触发（Scope Exclusions）：** 以下泛化词单独出现时**不**触发本技能——算法交易、量化策略、Python、交易机器人、实盘交易、程序化下单、行情数据。它们只有在明确指向\"用历史数据回测或验证一条具体规则\"时才路由到本技能；实盘下单、交易柜台对接、行情接口开发请改用对应技能。\r\n\r\n**路由判定三步：** ① 输入是否包含一条可执行的买卖规则（含参数）？② 任务是否为回测、样本外验证、蒙特卡洛推演或绩效归因？③ 两者同时为\"是\"才启用。只问量化概念或只要一段选股思路不启用。\r\n\r\n---\r\n\r\n## Core Capabilities / 核心能力\r\n\r\n### 1. Backtesting Engine / 回测引擎\r\n\r\n```python\r\nimport pandas as pd\r\nimport numpy as np\r\nfrom datetime import datetime\r\nimport warnings\r\nwarnings.filterwarnings('ignore')\r\n\r\nclass BacktestEngine:\r\n    \"\"\"量化回测引擎\"\"\"\r\n    \r\n    def __init__(self, initial_capital: float = 1000000,\r\n                 commission_rate: float = 0.0003,\r\n                 stamp_tax: float = 0.001,\r\n                 slippage: float = 0.001):\r\n        \"\"\"\r\n        Args:\r\n            initial_capital: 初始资金\r\n            commission_rate: 佣金费率（含规费）\r\n            stamp_tax: 印花税率（仅卖出）\r\n            slippage: 滑点（百分比）\r\n        \"\"\"\r\n        self.initial_capital = initial_capital\r\n        self.commission_rate = commission_rate\r\n        self.stamp_tax = stamp_tax\r\n        self.slippage = slippage\r\n        \r\n        # 持仓状态\r\n        self.cash = initial_capital\r\n        self.position = {}  # {stock_code: shares}\r\n        self.equity_curve = []\r\n        self.trades = []\r\n    \r\n    def run(self, data: pd.DataFrame, signals: pd.DataFrame,\r\n            strategy_name: str = \"Strategy\") -> dict:\r\n        \"\"\"\r\n        执行回测\r\n        Args:\r\n            data: 价格数据（含收盘价、开盘价、最高、最低价）\r\n            signals: 交易信号（1=买入, -1=卖出, 0=持有）\r\n            strategy_name: 策略名称\r\n        \"\"\"\r\n        # 执行时点约定：信号由 T 日收盘后计算，一律在 T+1 开盘成交。\r\n        # 这与本Skill\"未来函数检查清单\"的要求一致；若直接用 T 日收盘价成交，\r\n        # 等于使用了当日收盘后才可知的信息，构成前视偏差，回测收益被系统性高估。\r\n        pending = None  # 上一日收盘后生成、待次日开盘执行的信号\r\n\r\n        for date in data.index:\r\n            close_price = data.loc[date, \"close\"]\r\n\r\n            # 1) 先执行昨日遗留信号：用今日开盘价成交（T+1 开盘）\r\n            if pending is not None:\r\n                open_price = data.loc[date, \"open\"]\r\n                if pending == 1:\r\n                    self._buy(date, open_price, self.cash * 0.95)\r\n                elif pending == -1:\r\n                    self._sell(date, open_price)\r\n                pending = None\r\n\r\n            # 2) 用今日收盘价生成信号，留到下一交易日执行\r\n            if date in signals.index:\r\n                sig = signals.loc[date]\r\n                try:\r\n                    sig_val = int(sig.iloc[0]) if hasattr(sig, \"iloc\") else int(sig)\r\n                except (TypeError, ValueError):\r\n                    sig_val = 0\r\n                if sig_val in (1, -1):\r\n                    pending = sig_val\r\n\r\n            # 3) 以收盘价估值并记账\r\n            portfolio_value = self._calculate_portfolio_value(close_price)\r\n            self.equity_curve.append({\r\n                \"date\": date,\r\n                \"portfolio_value\": portfolio_value,\r\n                \"cash\": self.cash\r\n            })\r\n\r\n        return self._generate_report(strategy_name)\r\n    \r\n    def _buy(self, date, price, target_amount, stock: str = \"DEFAULT\"):\r\n        \"\"\"买入执行（含滑点+佣金），并同步更新持仓台账\"\"\"\r\n        buy_price = price * (1 + self.slippage)\r\n        shares = int(target_amount / buy_price / 100) * 100  # 100股整数\r\n\r\n        if shares > 0:\r\n            cost = shares * buy_price\r\n            commission = cost * self.commission_rate\r\n\r\n            if cost + commission <= self.cash:\r\n                self.cash -= (cost + commission)\r\n                # 关键：必须写入持仓台账。早期版本只追加 trades 而不更新\r\n                # self.position，导致 _sell 遍历空字典、永远卖不出去，\r\n                # 组合市值也只反映现金，回测结论完全失真。\r\n                self.position[stock] = self.position.get(stock, 0) + shares\r\n                self.trades.append({\r\n                    \"date\": date, \"action\": \"BUY\",\r\n                    \"stock\": stock,\r\n                    \"price\": buy_price, \"shares\": shares,\r\n                    \"commission\": commission\r\n                })\r\n\r\n    def _sell(self, date, price, stock: str = None):\r\n        \"\"\"卖出执行（含滑点+佣金+印花税），卖出后清零持仓台账\"\"\"\r\n        sell_price = price * (1 - self.slippage)\r\n        targets = [stock] if stock else list(self.position.keys())\r\n\r\n        for s in targets:\r\n            shares = self.position.get(s, 0)\r\n            if shares > 0:\r\n                proceeds = shares * sell_price\r\n                commission = proceeds * self.commission_rate\r\n                tax = proceeds * self.stamp_tax\r\n\r\n                self.cash -= (commission + tax)\r\n                self.cash += proceeds\r\n                # 关键：卖出后必须清零，否则同一持仓会被反复卖出，\r\n                # 现金与成交次数被成倍放大。\r\n                self.position[s] = 0\r\n                self.trades.append({\r\n                    \"date\": date, \"action\": \"SELL\",\r\n                    \"stock\": s,\r\n                    \"price\": sell_price, \"shares\": shares,\r\n                    \"commission\": commission, \"tax\": tax\r\n                })\r\n\r\n    def _calculate_portfolio_value(self, current_price):\r\n        \"\"\"计算组合市值；current_price 可为标量，或 {股票代码: 价格} 字典\"\"\"\r\n        if isinstance(current_price, dict):\r\n            position_value = sum(\r\n                shares * current_price.get(stock, 0.0)\r\n                for stock, shares in self.position.items()\r\n            )\r\n        else:\r\n            # 单标的口径：同一价格适用于所有持仓\r\n            position_value = sum(\r\n                shares * current_price\r\n                for stock, shares in self.position.items()\r\n            )\r\n        return self.cash + position_value\r\n\r\n    def _generate_report(self, strategy_name: str) -> dict:\r\n        \"\"\"生成回测报告\"\"\"\r\n        equity_df = pd.DataFrame(self.equity_curve)\r\n        equity_df.set_index(\"date\", inplace=True)\r\n        equity_df[\"returns\"] = equity_df[\"portfolio_value\"].pct_change()\r\n        \r\n        # 核心指标计算\r\n        total_return = (equity_df[\"portfolio_value\"].iloc[-1] / \r\n                       self.initial_capital - 1) * 100\r\n        \r\n        annual_return = ((1 + total_return/100) ** \r\n                        (252/len(equity_df)) - 1) * 100\r\n        \r\n        volatility = equity_df[\"returns\"].std() * np.sqrt(252) * 100\r\n        \r\n        sharpe_ratio = (annual_return - 2.75) / volatility  # 假设无风险利率2.75%\r\n        \r\n        # 最大回撤\r\n        cummax = equity_df[\"portfolio_value\"].cummax()\r\n        drawdown = (equity_df[\"portfolio_value\"] - cummax) / cummax\r\n        max_drawdown = drawdown.min() * 100\r\n        \r\n        # 卡尔玛比率\r\n        calmar_ratio = annual_return / abs(max_drawdown) if max_drawdown != 0 else 0\r\n        \r\n        return {\r\n            \"strategy\": strategy_name,\r\n            \"period\": f\"{equity_df.index[0].date()} to {equity_df.index[-1].date()}\",\r\n            \"total_return\": round(total_return, 2),\r\n            \"annual_return\": round(annual_return, 2),\r\n            \"volatility\": round(volatility, 2),\r\n            \"sharpe_ratio\": round(sharpe_ratio, 2),\r\n            \"max_drawdown\": round(max_drawdown, 2),\r\n            \"calmar_ratio\": round(calmar_ratio, 2),\r\n            \"total_trades\": len([t for t in self.trades if t[\"action\"] == \"BUY\"]),\r\n            \"win_rate\": self._calculate_win_rate(),\r\n            \"equity_curve\": equity_df\r\n        }\r\n    \r\n    def _calculate_win_rate(self) -> float:\r\n        \"\"\"计算胜率\"\"\"\r\n        if len(self.trades) < 2:\r\n            return 0\r\n        \r\n        buy_trades = [t for t in self.trades if t[\"action\"] == \"BUY\"]\r\n        sell_trades = [t for t in self.trades if t[\"action\"] == \"SELL\"]\r\n        \r\n        if len(sell_trades) == 0:\r\n            return 0\r\n        \r\n        wins = sum(\r\n            1 for i, sell in enumerate(sell_trades)\r\n            if i < len(buy_trades) and \r\n            sell[\"price\"] > buy_trades[i][\"price\"]\r\n        )\r\n        \r\n        return wins / len(sell_trades) * 100\r\n```\r\n\r\n**回测结果解读表（指标要配套看，不能只看收益）**\r\n\r\n| 指标 | 数值 | 参考区间 | 解读 |\r\n|------|------|---------|------|\r\n| 总收益 | +186.4% | — | 需结合回测期长度 |\r\n| 年化收益 | +16.8% | 10%-25% | 处于合理区间 |\r\n| 年化波动率 | 22.4% | <25% | 波动偏高但可接受 |\r\n| 夏普比率 | 0.63 | >0.5（含无风险2.75%） | 风险调整后收益一般 |\r\n| 最大回撤 | −27.6% | <30% | 接近上限，需关注 |\r\n| 卡尔玛比率 | 0.61 | >0.5 | 回撤控制尚可 |\r\n| 交易次数 | 86次/年 | — | 换手偏高，成本敏感 |\r\n| 胜率 | 48% | — | 低于50%，靠盈亏比取胜 |\r\n\r\n关键提示：若胜率低于50%而收益为正，说明依赖少数大盈利单，需检验是否由个别极端行情贡献（做剔除前10%最佳交易后的收益检验）。\r\n\r\n**未来函数检查清单（回测虚高的头号原因）**\r\n\r\n| 检查项 | 错误写法 | 正确做法 |\r\n|-------|---------|---------|\r\n| 信号时点 | 用当日收盘价生成信号并当日成交 | 用T日收盘生成信号，T+1开盘成交 |\r\n| 财务数据 | 使用报告期财务数据但在报告发布前使用 | 按公告日（而非报告期）对齐数据 |\r\n| 复权处理 | 用后复权价判断当时市值 | 历史价格用对应时点的前复权口径 |\r\n| 指数成分 | 用当前成分股回溯历史 | 使用历史成分股名单 |\r\n| 停牌处理 | 停牌日仍可交易 | 停牌日不可成交，信号顺延 |\r\n| 涨跌停 | 涨跌停仍按目标价成交 | 涨跌停日按不可成交或部分成交处理 |\r\n\r\n**成本构成示例（一次完整买卖的成本拆解）**\r\n\r\n| 成本项 | 买入 | 卖出 | 合计 |\r\n|-------|------|------|------|\r\n| 佣金（0.03%，双边） | 30元 | 30元 | 60元 |\r\n| 印花税（0.1%，仅卖出） | — | 100元 | 100元 |\r\n| 过户费（约0.001%） | 1元 | 1元 | 2元 |\r\n| 滑点（0.1%，双边） | 100元 | 100元 | 200元 |\r\n| **合计（10万元交易）** | 131元 | 231元 | **362元** |\r\n\r\n说明：单次往返成本约0.36%，若策略年换手20次，仅交易成本就接近7.2%，因此高换手策略必须把成本纳入优化目标。\r\n\r\n\r\n**示例引擎的三处已知缺陷与修正（回测可信度的底线）**\r\n\r\n| 编号 | 缺陷 | 后果 | 修正做法 | 验证方法 |\r\n|------|------|------|---------|----------|\r\n| BUG-1 | `_buy()` 只追加 trades，未写入 `self.position` | 持仓台账恒为空，`_sell()` 遍历空字典永远卖不出；市值只反映现金 | 买入时 `self.position[stock] += shares` | 断言：任一时刻 `sum(position.values()) > 0` 时市值 > 现金 |\r\n| BUG-2 | `_sell()` 卖出后未清零持仓 | 同一持仓被反复卖出，现金与成交次数被成倍放大 | 卖出后 `self.position[s] = 0` | 断言：SELL 次数 ≤ BUY 次数；期末全部平仓后 `position` 为空 |\r\n| BUG-3 | 用 T 日收盘价生成信号并在 T 日收盘价成交 | 前视偏差，收益被系统性高估 | 信号 T 日收盘生成、T+1 开盘成交 | 对照实验：同策略分别用收盘价成交与次日开盘价成交，比较年化收益差 |\r\n\r\n复核要点：拿到任何回测引擎（包括本文的示意实现）都应先做这三个断言，再谈参数与绩效。BUG-1 与 BUG-2 属于\"代码能跑但结果全错\"，比报错更危险。\r\n\r\n**示例｜前视偏差的量化影响（同策略两种成交价）**\r\n\r\n| 成交价设定 | 年化收益 | 夏普比率 | 最大回撤 | 交易次数 | 判断 |\r\n|----------|---------|---------|---------|---------|------|\r\n| T日收盘价成交（含前视偏差） | 24.8% | 1.15 | −19.2% | 86 | 收益虚高，不可用 |\r\n| T+1开盘价成交（正确） | 16.8% | 0.63 | −27.6% | 86 | 可信口径 |\r\n| 差异 | −8.0pct | −0.52 | 回撤加深8.4pct | 不变 | 前视偏差贡献了约三分之一的收益 |\r\n\r\n结论：仅把成交价从\"当日收盘\"改为\"次日开盘\"，年化收益就下降8个百分点。任何声称\"改个成交价影响不大\"的说法都不成立，回测必须把执行时点写死并公开。\r\n\r\n### 2. Strategy Examples / 策略示例\r\n\r\n```python\r\n# 示例策略：双均线交叉策略\r\nclass DualMovingAverageStrategy:\r\n    \"\"\"双均线策略\"\"\"\r\n    \r\n    def __init__(self, short_window: int = 20, long_window: int = 60):\r\n        self.short_window = short_window\r\n        self.long_window = long_window\r\n    \r\n    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:\r\n        \"\"\"生成交易信号\"\"\"\r\n        signals = pd.Series(index=data.index, dtype=int)\r\n        \r\n        # 计算均线\r\n        ma_short = data[\"close\"].rolling(self.short_window).mean()\r\n        ma_long = data[\"close\"].rolling(self.long_window).mean()\r\n        \r\n        # 金叉买入，死叉卖出\r\n        position = 0\r\n        for i in range(self.long_window, len(data)):\r\n            if ma_short.iloc[i] > ma_long.iloc[i] and position == 0:\r\n                signals.iloc[i] = 1  # 买入\r\n                position = 1\r\n            elif ma_short.iloc[i] < ma_long.iloc[i] and position == 1:\r\n                signals.iloc[i] = -1  # 卖出\r\n                position = 0\r\n        \r\n        return signals\r\n\r\n# RSI均值回归策略\r\nclass RSIMeanReversionStrategy:\r\n    \"\"\"RSI均值回归策略\"\"\"\r\n    \r\n    def __init__(self, period: int = 14, \r\n                 oversold: float = 30, \r\n                 overbought: float = 70):\r\n        self.period = period\r\n        self.oversold = oversold\r\n        self.overbought = overbought\r\n    \r\n    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:\r\n        \"\"\"RSI超卖买入，超买卖出\"\"\"\r\n        delta = data[\"close\"].diff()\r\n        gain = (delta.where(delta > 0, 0)).rolling(self.period).mean()\r\n        loss = (-delta.where(delta < 0, 0)).rolling(self.period).mean()\r\n        \r\n        rs = gain / loss\r\n        rsi = 100 - (100 / (1 + rs))\r\n        \r\n        signals = pd.Series(index=data.index, dtype=int)\r\n        position = 0\r\n        \r\n        for i in range(self.period, len(data)):\r\n            if rsi.iloc[i] < self.oversold and position == 0:\r\n                signals.iloc[i] = 1  # 买入\r\n                position = 1\r\n            elif rsi.iloc[i] > self.overbought and position == 1:\r\n                signals.iloc[i] = -1  # 卖出\r\n                position = 0\r\n        \r\n        return signals\r\n\r\n# 布林带突破策略（含波动率过滤）\r\nclass BollingerBreakoutStrategy:\r\n    \"\"\"布林带突破策略\"\"\"\r\n    \r\n    def __init__(self, window: int = 20, num_std: float = 2.0,\r\n                 atr_window: int = 14, atr_stop: float = 2.5):\r\n        self.window = window\r\n        self.num_std = num_std\r\n        self.atr_window = atr_window\r\n        self.atr_stop = atr_stop\r\n    \r\n    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:\r\n        \"\"\"突破上轨买入，跌破中轨卖出，并以ATR作为止损参考\"\"\"\r\n        ma = data[\"close\"].rolling(self.window).mean()\r\n        std = data[\"close\"].rolling(self.window).std()\r\n        upper = ma + self.num_std * std\r\n        lower = ma - self.num_std * std\r\n        \r\n        # ATR用于度量波动\r\n        high, low, close = data[\"high\"], data[\"low\"], data[\"close\"]\r\n        tr = pd.concat([\r\n            high - low,\r\n            (high - close.shift()).abs(),\r\n            (low - close.shift()).abs()\r\n        ], axis=1).max(axis=1)\r\n        atr = tr.rolling(self.atr_window).mean()\r\n        \r\n        signals = pd.Series(index=data.index, dtype=int)\r\n        position = 0\r\n        entry_price = 0.0\r\n        \r\n        for i in range(self.window, len(data)):\r\n            price = close.iloc[i]\r\n            stop_line = entry_price - self.atr_stop * atr.iloc[i]\r\n            \r\n            if position == 0 and price > upper.iloc[i]:\r\n                signals.iloc[i] = 1\r\n                position = 1\r\n                entry_price = price\r\n            elif position == 1 and (price < ma.iloc[i] or price < stop_line):\r\n                signals.iloc[i] = -1\r\n                position = 0\r\n                entry_price = 0.0\r\n        \r\n        return signals\r\n```\r\n\r\n**三类策略的适用环境对比**\r\n\r\n| 策略 | 逻辑 | 适用市场 | 最大风险点 | 关键参数 | 典型年换手 | |\r\n|------|------|---------|-----------|---------|---|\r\n| 双均线 | 趋势跟踪 | 单边趋势市 | 震荡市反复止损 | 短/长窗口 | 4-8次 |\r\n| RSI均值回归 | 超买超卖反转 | 震荡市 | 趋势市中逆势 | 周期、超买超卖阈值 | 15-30次 |\r\n| 布林带突破 | 波动扩张跟进 | 波动放大初期 | 假突破 | 窗口、标准差倍数、ATR止损 | 10-25次 |\r\n\r\n**示例 1｜参数寻优的正确做法**\r\n\r\n| 步骤 | 做法 | 目的 |\r\n|------|------|------|\r\n| 1 | 粗网格搜索（如MA参数 5-60，步长5） | 快速定位有效区域 |\r\n| 2 | 观察参数邻域稳定性 | 避免落到孤立最优值 |\r\n| 3 | 在样本外区间验证 | 检验是否过拟合 |\r\n| 4 | 检查参数的经济含义 | 排除无逻辑的参数组合 |\r\n| 5 | 固定参数做前向测试 | 确认可复现 |\r\n\r\n**示例 2｜参数敏感性判断（用邻域看稳定性）**\r\n\r\n| 参数组合 | MA短 | MA长 | 年化收益 | 最大回撤 | 判断 |\r\n|---------|------|------|---------|---------|------|\r\n| A | 20 | 60 | 16.8% | −27.6% | 中心值 |\r\n| B | 18 | 60 | 15.9% | −26.8% | 邻域稳定 |\r\n| C | 22 | 60 | 16.2% | −28.1% | 邻域稳定 |\r\n| D | 5 | 20 | 34.5% | −41.2% | 孤立高收益，疑过拟合 |\r\n| E | 40 | 120 | 11.2% | −22.4% | 反应迟缓，收益偏低 |\r\n\r\n判断要点：中心值附近绩效平滑变化说明参数稳健；若出现\"只有某个很窄的参数区间收益极高、邻域骤降\"，通常意味着曲线拟合（过拟合）而非真实的策略优势。\r\n\r\n### 3. Monte Carlo Simulation / 蒙特卡洛模拟\r\n\r\n```python\r\nclass MonteCarloSimulation:\r\n    \"\"\"蒙特卡洛模拟\"\"\"\r\n    \r\n    def run_simulation(self, historical_returns: pd.Series,\r\n                      n_simulations: int = 1000,\r\n                      n_periods: int = 252,\r\n                      initial_value: float = 1000000) -> dict:\r\n        \"\"\"\r\n        运行蒙特卡洛模拟\r\n        \"\"\"\r\n        mu = historical_returns.mean()\r\n        sigma = historical_returns.std()\r\n        \r\n        simulations = np.zeros((n_simulations, n_periods))\r\n        simulations[:, 0] = initial_value\r\n        \r\n        for t in range(1, n_periods):\r\n            random_returns = np.random.normal(mu, sigma, n_simulations)\r\n            simulations[:, t] = simulations[:, t-1] * (1 + random_returns)\r\n        \r\n        # 统计结果\r\n        final_values = simulations[:, -1]\r\n        \r\n        percentiles = {\r\n            \"5th\": np.percentile(final_values, 5),\r\n            \"25th\": np.percentile(final_values, 25),\r\n            \"50th\": np.percentile(final_values, 50),\r\n            \"75th\": np.percentile(final_values, 75),\r\n            \"95th\": np.percentile(final_values, 95)\r\n        }\r\n        \r\n        # 概率分析\r\n        prob_loss = (final_values < initial_value).mean() * 100\r\n        \r\n        return {\r\n            \"percentiles\": {k: round(v, 2) for k, v in percentiles.items()},\r\n            \"probability_of_loss\": round(prob_loss, 2),\r\n            \"expected_return\": round(final_values.mean() - initial_value, 2),\r\n            \"var_95\": round(initial_value - percentiles[\"5th\"], 2),\r\n            \"simulations\": simulations\r\n        }\r\n```\r\n\r\n**示例 1｜蒙特卡洛结果解读（看分布，不看单点）**\r\n\r\n| 分位 | 期末价值（万元） | 相对初始（100万） | 解读 |\r\n|------|--------------|----------------|------|\r\n| 5th | 78.5 | −21.5% | 悲观情景，一年后亏损两成 |\r\n| 25th | 94.2 | −5.8% | 四分之一概率不赚钱 |\r\n| 50th | 112.6 | +12.6% | 中位情景 |\r\n| 75th | 134.8 | +34.8% | 乐观情景 |\r\n| 95th | 162.4 | +62.4% | 极端乐观情景 |\r\n\r\n- 亏损概率（期末低于初始）：**约 33%**。\r\n- VaR(95) = 100 − 78.5 = **21.5万元**。\r\n- 解读要点：中位数收益为正不代表大概率赚钱——本例如亏损概率33%，说明\"三次里有一次亏钱\"，须在报告中如实披露。\r\n\r\n**示例 2｜蒙特卡洛的三种误用**\r\n\r\n| 误用 | 后果 | 正确做法 |\r\n|------|------|---------|\r\n| 只用正态分布 | 低估极端损失 | 用历史自助抽样或t分布对比 |\r\n| 参数来自短期样本 | 分布估计不稳 | 用足够长的样本并做分段检验 |\r\n| 把模拟结果当作预测 | 误导决策 | 明确\"模拟为假设推演，非收益预测\" |\r\n\r\n\r\n**示例 3｜自助抽样与正态分布的对比（分布假设有多重要）**\r\n\r\n| 方法 | 5th分位期末价值（万元） | 亏损概率 | 95% VaR（万元） | 判断 |\r\n|------|---------------------|---------|---------------|------|\r\n| 正态假设 | 78.5 | 33.0% | 21.5 | 低估尾部 |\r\n| 历史自助抽样（Bootstrap） | 71.2 | 38.4% | 28.8 | 更贴近实际肥尾 |\r\n| t分布（自由度5） | 73.6 | 36.1% | 26.4 | 介于两者之间 |\r\n\r\n对比要点：三种方法在中位数上差别不大，但在5%分位上相差超过7万元。VaR、压力测试这类关注尾部的结论必须做多方法交叉验证，只报正态假设的结果会系统性低估极端损失。\r\n\r\n**示例 4｜策略容量估算（收益能承载多少钱）**\r\n\r\n| 规模（万元） | 占标的日均成交额比 | 平均滑点 | 年化净收益 | 相对基准衰减 |\r\n|------------|------------------|---------|-----------|------------|\r\n| 500 | 1.0% | 0.10% | 16.8% | — |\r\n| 2,000 | 4.0% | 0.22% | 14.1% | −2.7pct |\r\n| 5,000 | 10.0% | 0.45% | 9.6% | −7.2pct |\r\n| 10,000 | 20.0% | 0.85% | 3.2% | −13.6pct |\r\n\r\n估算要点：容量上限通常取\"净收益衰减至基准策略一半\"对应的规模；上例约在5,000万–1亿元之间。多标的策略应按单标的日均成交额分别测算后取最小值，不能用组合总额笼统估算。\r\n\r\n### 4. Walk-Forward & Performance Attribution / 前向分析与绩效归因\r\n\r\n**前向分析设计表**\r\n\r\n| 项目 | 设置 | 说明 |\r\n|------|------|------|\r\n| 训练窗口 | 36个月 | 用于参数拟合 |\r\n| 测试窗口 | 6个月 | 用于样本外验证 |\r\n| 滚动步长 | 6个月 | 窗口向前滚动 |\r\n| 参数冻结 | 测试期内不变 | 防止\"边测边调\" |\r\n| 输出 | 各测试段的收益、回撤 | 关注一致性而非平均 |\r\n\r\n**示例｜样本内 vs 样本外对比（判断是否过拟合）**\r\n\r\n| 指标 | 样本内 | 样本外 | 衰减幅度 | 判断 |\r\n|------|-------|-------|---------|------|\r\n| 年化收益 | 24.5% | 11.2% | −54% | 衰减明显，需谨慎 |\r\n| 夏普比率 | 1.12 | 0.48 | −57% | 风险调整后收益下降 |\r\n| 最大回撤 | −18.6% | −26.3% | 加深 7.7pct | 样本外更差 |\r\n| 胜率 | 56% | 49% | −7pct | 优势减弱 |\r\n\r\n经验口径：样本外年化收益不低于样本内的60%、夏普比率不低于样本内的50%，方可认为策略具备一定稳健性；衰减超过上述幅度时应重新审视参数与逻辑。\r\n\r\n**绩效归因分解表**\r\n\r\n| 归因维度 | 贡献 | 说明 |\r\n|---------|------|------|\r\n| 择时（仓位） | +3.2% | 高仓位期恰逢上涨 |\r\n| 选股（标的） | +9.6% | 主要收益来源 |\r\n| 行业配置 | +2.1% | 超配强势行业 |\r\n| 交易成本 | −4.3% | 换手偏高拖累 |\r\n| 残差/其他 | +0.6% | 无法解释部分 |\r\n| **合计** | **+11.2%** | 与样本外年化一致 |\r\n\r\n使用要点：归因结果要与换手率、成本假设交叉验证；若\"选股贡献\"高度集中于个别标的，应在报告中标注集中度风险。\r\n\r\n\r\n**示例｜前向分析各段一致性检查（比平均收益更重要）**\r\n\r\n| 测试段 | 区间 | 年化收益 | 最大回撤 | 相对基准超额 | 是否达标 |\r\n|-------|------|---------|---------|------------|---------|\r\n| 第1段 | 2020H1 | +18.2% | −12.4% | +6.1% | 是 |\r\n| 第2段 | 2020H2 | +9.4% | −18.6% | +1.2% | 是 |\r\n| 第3段 | 2021H1 | −4.1% | −24.8% | −3.6% | 否 |\r\n| 第4段 | 2021H2 | +14.7% | −15.2% | +4.8% | 是 |\r\n| 第5段 | 2022H1 | +2.3% | −21.5% | −0.9% | 边缘 |\r\n\r\n一致性判据：达标段数 / 总段数 ≥60%、且连续不达标不超过2段。只看\"5段平均超额+1.5%\"会掩盖第3段的失效；前向分析的价值正在于暴露策略在不同市场状态下的稳定性，而不是算一个平均值。\r\n\r\n---\r\n\r\n## Quick Command Templates / 快速指令模板\r\n\r\n**回测双均线策略：**\r\n```\r\n回测双均线策略（MA20/MA60）：\r\n- 初始资金：100万\r\n- 回测期：2020-01-01至2025-12-31\r\n- 关注指标：收益率、夏普比率、最大回撤\r\n```\r\n\r\n**蒙特卡洛模拟：**\r\n```\r\n对当前持仓做蒙特卡洛模拟：\r\n- 模拟次数：10000次\r\n- 模拟期限：1年\r\n- 置信区间：95%\r\n```\r\n\r\n**前向分析：**\r\n```\r\n对[策略名称]做前向分析：训练窗口36个月、测试窗口6个月、\r\n滚动步长6个月，输出各测试段的收益与回撤，并对比样本内外的衰减幅度。\r\n```\r\n\r\n**容量与成本评估：**\r\n```\r\n评估[策略名称]的容量上限与成本影响：\r\n- 输入：策略年换手、持仓标的日均成交额\r\n- 输出：容量上限估算、滑点扩大情景下的净收益衰减\r\n```\r\n\r\n---\r\n\r\n## Changelog / 版本变更\r\n\r\n| 版本 | 日期 | 变更摘要 |\r\n|------|------|---------|\r\n| 3.0.3 | 2026-10-08 | 修复示例引擎三处缺陷（SDI-4）：持仓台账买入未写入、卖出未清零、T日收盘价成交构成前视偏差；新增数据最小化声明与执行边界章节；收窄触发词并补充中英文非触发清单（SQP-1）；监管动态更新至2026-10-08并新增程序化交易、投资者保护两条与复核频率列；新增示例：缺陷对照与断言验证法、前视偏差量化影响、自助抽样与正态分布对比、策略容量估算、前向分析分段一致性检查 |\r\n| 3.0.2 | 2026-09-12 | 新增未来函数检查清单与成本构成拆解 |\r\n\r\n---\r\n\r\n\r\n## Disclaimer\r\n\r\nThis skill provides backtesting tools for educational and research purposes. Backtesting results do not guarantee future performance. Past performance is not indicative of future results. Algorithmic trading involves substantial risk of loss.\n\nFile v3.0.3:_meta.json\n\n{\n  \"ownerId\": \"kn74e704j3ygjcygnpf02rdvd185js13\",\n  \"slug\": \"security-quant-backtest\",\n  \"version\": \"3.0.3\",\n  \"publishedAt\": 1791436367389\n}\n\nFile v3.0.3:skill-card.md\n\n## Description:\n\nGuides historical China A-share strategy backtesting with illustrative Python examples, cost modelling, walk-forward validation, performance attribution, and Monte Carlo simulation.\n\nThis skill is ready for commercial/non-commercial use.\n\n## Publisher:\n\n[gechengling](https://clawhub.ai/user/gechengling)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nQuant analysts and developers use this skill to examine defined trading rules against their own historical China A-share data, including trading costs, out-of-sample performance, and simulation uncertainty. It does not supply market data or execute trades.\n\n### Deployment Geography for Use:\n\nGlobal (China A-share market focus)\n\n## Known Risks and Mitigations:\n\nRisk: Simplified sample code and simulated returns may misrepresent real trading outcomes.\n\nMitigation: Validate results in an independently tested backtesting system with realistic costs, execution constraints, and out-of-sample checks before relying on them.\n\nRisk: Outdated market or regulatory assumptions may lead to misleading conclusions.\n\nMitigation: Independently verify applicable rules, rates, and market data before using the analysis.\n\nRisk: Real account, client, position, or broker data may expose sensitive information.\n\nMitigation: Use hypothetical amounts and omit real account data, client identities, broker credentials, and live positions.\n\n## Reference(s):\n\n- [ClawHub skill listing](https://clawhub.ai/gechengling/skills/security-quant-backtest)\n\n## Skill Output:\n\n**Output Type(s):** [Guidance, Analysis, Code]\n\n**Output Format:** [Markdown with illustrative Python code and tables]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [Educational examples; no built-in data access or trade execution.]\n\n## Skill Version(s):\n\n3.0.3 (source: skill frontmatter and server release)\n\n## Ethical Considerations:\n\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.\n\nArchive v3.0.2: 3 files, 10865 bytes\n\nFiles: skill-card.md (2228b), SKILL.md (25359b), _meta.json (142b)\n\nFile v3.0.2:SKILL.md\n\n---\r\nname: Quantitative Backtesting Laboratory\r\nslug: security-quant-backtest\r\ndescription: AI-powered quantitative backtesting laboratory for China A-share — covers strategy design, historical backtesting, performance attribution, walk-forward analysis, and Monte Carlo simulation. Built for quantitative analysts, algorithmic traders, and Python-based backtesting. Keywords: quantitative backtesting, algorithmic trading, strategy research, Python backtest, China A-share, performance analysis, 量化回测, 算法交易, 策略研究, Python回测, 绩效归因, 量化策略, 蒙特卡洛, 趋势跟踪, 均值回归, 统计套利.\r\nversion: \"3.0.2\"\r\n---\r\n\r\n# Quantitative Backtesting Laboratory / 量化回测实验室\r\n\r\n> **English:** AI-powered quantitative backtesting laboratory — covers strategy design, historical backtesting, performance attribution, walk-forward analysis, and Monte Carlo simulation. Built for quant analysts and algorithmic traders.\r\n>\r\n> **中文:** 量化回测实验室——覆盖策略设计、历史回测、绩效归因、前向分析、蒙特卡洛模拟。适用：量化分析师、算法交易者、Python回测开发。\r\n\r\n---\r\n\r\n\r\n### 证券监管最新动态 [2026-09-12更新]\r\n\r\n| 动态类型 | 内容摘要 | 影响范围 | 回测侧应对动作 | 责任岗 | 优先级 |\r\n|---------|---------|---------|--------------|-------|-------|\r\n| 证券监管 | 2026年A股量化资金占比30%-40%，回测需考虑拥挤度因子 | 回测框架需增加拥挤度、压力测试和合规成本模块 | 回测报告增加拥挤度指标与容量估算 | 研究 | 高 |\r\n| 证券监管 | 2026年3月量化踩踏事件：回测模型需加入极端行情压力测试 | 回测框架需增加拥挤度、压力测试和合规成本模块 | 回测加入流动性枯竭情景的损失估算 | 研究 | 高 |\r\n| 证券监管 | 算法监管趋严，高频策略回测需考虑合规成本 | 回测框架需增加拥挤度、压力测试和合规成本模块 | 成本模型中单列合规与报告成本 | 合规 | 高 |\r\n| 程序化交易 | 程序化交易报告与异常交易监控要求细化 | 高频与中高频策略 | 回测中增加报撤单频率与异常交易约束 | 合规 | 中 |\r\n| 交易成本 | 佣金、印花税与过户费口径需与实盘一致 | 成本模型、净收益指标 | 成本参数按最新费率更新并标注生效日期 | 研究 | 高 |\r\n| 数据质量 | 回测输入数据需可追溯 | 行情与财务数据 | 数据源、复权方式与取数日期须在报告中标注 | 研究 | 高 |\r\n| 投资者保护 | 量化产品业绩展示与宣传表述趋严 | 回测业绩对外展示 | 回测结果标注为模拟结果、不构成收益承诺 | 合规 | 高 |\r\n| 风控要求 | 策略容量与集中度管理要求提升 | 策略规模与持仓集中度 | 输出策略容量估算与集中度约束 | 风控 | 中 |\r\n\r\n> **数据截止**: 2026-09-12 | 来源：证监会、交易所公开规则、行业公开信息\r\n> **声明**: 以上动态供参考，具体以官方最新发布为准\r\n\r\n**动态解读示例（四类高频场景）**\r\n\r\n- **场景A｜容量估算缺失**：回测年化30%但未给容量上限 → 命中\"拥挤度与容量\"要求 → 输出策略容量估算（按日均成交额占比），并说明规模扩大后收益衰减趋势。\r\n- **场景B｜极端情景缺失**：回测最大回撤仅−12%，未含流动性枯竭情景 → 命中\"极端行情压力测试\"要求 → 增加\"成交量降至五成\"情景下的滑点扩大与无法及时减仓的损失估算。\r\n- **场景C｜成本口径过期**：成本模型仍用旧费率 → 命中\"成本参数需与实盘一致\"要求 → 更新费率参数并标注生效日期，重算净收益指标。\r\n- **场景D｜业绩展示**：对客材料直接使用回测收益曲线 → 命中\"业绩展示\"要求 → 曲线旁标注\"模拟回测结果，不构成收益承诺\"，并披露假设条件。\r\n\r\n## Industry Pain Points / 行业痛点\r\n\r\n| Pain Point / 痛点 | Impact / 影响 | Solution / 本Skill解决方案 | 量化基线指标 / Baseline |\r\n|------------------|-------------|------------------------|----------------------|\r\n| **未来函数** | 回测虚高，实盘亏损 | 信号对齐检查+严格回测规范 | 前视检查项通过率 100% |\r\n| **过拟合** | 参数过度优化，实盘失效 | 样本外测试+统计显著性检验 | 样本外/样本内收益比 ≥0.6 |\r\n| **滑点假设** | 低估交易成本，实盘收益缩水 | 多场景滑点模拟 | 至少3档滑点情景对比 |\r\n| **幸存者偏差** | 只用现存股票，忽视退市股 | 使用完整历史数据 | 含退市标的的完整样本 |\r\n| **执行缺口** | 回测vs实盘收益差异大 | 分层回测+执行模拟 | 回测与实盘差异 ≤20% |\r\n| **容量未估** | 规模扩大后收益快速衰减 | 容量估算模型 | 给出容量上限与衰减曲线 |\r\n| **参数敏感** | 参数微调收益剧变 | 参数敏感性热力图 | 邻域内收益波动 <30% |\r\n| **成本失真** | 未含印花税/合规成本 | 完整成本模型 | 成本项完整率 100% |\r\n\r\n---\r\n\r\n## Trigger Keywords / 触发关键词\r\n\r\n**English Triggers:** quantitative backtesting, algorithmic trading, strategy research, Python backtest, performance analysis, Monte Carlo, walk-forward analysis, A-share strategy\r\n\r\n**中文触发词（优先）：** 量化回测 / 算法交易 / 策略研究 / Python回测 / 绩效归因 / 蒙特卡洛 / 前向分析 / 趋势跟踪 / 均值回归 / 配对交易 / 双均线 / 海龟策略 / RSI策略 / 布林带策略 / 策略优化 / 参数寻优 / 机器学习选股 / Alpha因子 / 多因子策略\r\n\r\n---\r\n\r\n## Core Capabilities / 核心能力\r\n\r\n### 1. Backtesting Engine / 回测引擎\r\n\r\n```python\r\nimport pandas as pd\r\nimport numpy as np\r\nfrom datetime import datetime\r\nimport warnings\r\nwarnings.filterwarnings('ignore')\r\n\r\nclass BacktestEngine:\r\n    \"\"\"量化回测引擎\"\"\"\r\n    \r\n    def __init__(self, initial_capital: float = 1000000,\r\n                 commission_rate: float = 0.0003,\r\n                 stamp_tax: float = 0.001,\r\n                 slippage: float = 0.001):\r\n        \"\"\"\r\n        Args:\r\n            initial_capital: 初始资金\r\n            commission_rate: 佣金费率（含规费）\r\n            stamp_tax: 印花税率（仅卖出）\r\n            slippage: 滑点（百分比）\r\n        \"\"\"\r\n        self.initial_capital = initial_capital\r\n        self.commission_rate = commission_rate\r\n        self.stamp_tax = stamp_tax\r\n        self.slippage = slippage\r\n        \r\n        # 持仓状态\r\n        self.cash = initial_capital\r\n        self.position = {}  # {stock_code: shares}\r\n        self.equity_curve = []\r\n        self.trades = []\r\n    \r\n    def run(self, data: pd.DataFrame, signals: pd.DataFrame,\r\n            strategy_name: str = \"Strategy\") -> dict:\r\n        \"\"\"\r\n        执行回测\r\n        Args:\r\n            data: 价格数据（含收盘价、开盘价、最高、最低价）\r\n            signals: 交易信号（1=买入, -1=卖出, 0=持有）\r\n            strategy_name: 策略名称\r\n        \"\"\"\r\n        results = []\r\n        \r\n        for date in data.index:\r\n            price = data.loc[date, \"close\"]\r\n            \r\n            # 获取当日信号\r\n            if date in signals.index:\r\n                signal = signals.loc[date]\r\n                if signal == 1:  # 买入信号\r\n                    self._buy(date, price, self.cash * 0.95)  # 保留5%现金\r\n                elif signal == -1:  # 卖出信号\r\n                    self._sell(date, price)\r\n            \r\n            # 更新权益\r\n            portfolio_value = self._calculate_portfolio_value(price)\r\n            self.equity_curve.append({\r\n                \"date\": date,\r\n                \"portfolio_value\": portfolio_value,\r\n                \"cash\": self.cash\r\n            })\r\n        \r\n        return self._generate_report(strategy_name)\r\n    \r\n    def _buy(self, date, price, target_amount):\r\n        \"\"\"买入执行（含滑点+佣金）\"\"\"\r\n        buy_price = price * (1 + self.slippage)\r\n        shares = int(target_amount / buy_price / 100) * 100  # 100股整数\r\n        \r\n        if shares > 0:\r\n            cost = shares * buy_price\r\n            commission = cost * self.commission_rate\r\n            \r\n            if cost + commission <= self.cash:\r\n                self.cash -= (cost + commission)\r\n                self.trades.append({\r\n                    \"date\": date, \"action\": \"BUY\",\r\n                    \"price\": buy_price, \"shares\": shares,\r\n                    \"commission\": commission\r\n                })\r\n    \r\n    def _sell(self, date, price):\r\n        \"\"\"卖出执行（含滑点+佣金+印花税）\"\"\"\r\n        sell_price = price * (1 - self.slippage)\r\n        \r\n        for stock, shares in list(self.position.items()):\r\n            if shares > 0:\r\n                proceeds = shares * sell_price\r\n                commission = proceeds * self.commission_rate\r\n                tax = proceeds * self.stamp_tax\r\n                \r\n                self.cash -= (commission + tax)\r\n                self.cash += proceeds\r\n                self.trades.append({\r\n                    \"date\": date, \"action\": \"SELL\",\r\n                    \"price\": sell_price, \"shares\": shares,\r\n                    \"commission\": commission, \"tax\": tax\r\n                })\r\n    \r\n    def _calculate_portfolio_value(self, current_price):\r\n        \"\"\"计算组合市值\"\"\"\r\n        position_value = sum(\r\n            shares * current_price \r\n            for stock, shares in self.position.items()\r\n        )\r\n        return self.cash + position_value\r\n    \r\n    def _generate_report(self, strategy_name: str) -> dict:\r\n        \"\"\"生成回测报告\"\"\"\r\n        equity_df = pd.DataFrame(self.equity_curve)\r\n        equity_df.set_index(\"date\", inplace=True)\r\n        equity_df[\"returns\"] = equity_df[\"portfolio_value\"].pct_change()\r\n        \r\n        # 核心指标计算\r\n        total_return = (equity_df[\"portfolio_value\"].iloc[-1] / \r\n                       self.initial_capital - 1) * 100\r\n        \r\n        annual_return = ((1 + total_return/100) ** \r\n                        (252/len(equity_df)) - 1) * 100\r\n        \r\n        volatility = equity_df[\"returns\"].std() * np.sqrt(252) * 100\r\n        \r\n        sharpe_ratio = (annual_return - 2.75) / volatility  # 假设无风险利率2.75%\r\n        \r\n        # 最大回撤\r\n        cummax = equity_df[\"portfolio_value\"].cummax()\r\n        drawdown = (equity_df[\"portfolio_value\"] - cummax) / cummax\r\n        max_drawdown = drawdown.min() * 100\r\n        \r\n        # 卡尔玛比率\r\n        calmar_ratio = annual_return / abs(max_drawdown) if max_drawdown != 0 else 0\r\n        \r\n        return {\r\n            \"strategy\": strategy_name,\r\n            \"period\": f\"{equity_df.index[0].date()} to {equity_df.index[-1].date()}\",\r\n            \"total_return\": round(total_return, 2),\r\n            \"annual_return\": round(annual_return, 2),\r\n            \"volatility\": round(volatility, 2),\r\n            \"sharpe_ratio\": round(sharpe_ratio, 2),\r\n            \"max_drawdown\": round(max_drawdown, 2),\r\n            \"calmar_ratio\": round(calmar_ratio, 2),\r\n            \"total_trades\": len([t for t in self.trades if t[\"action\"] == \"BUY\"]),\r\n            \"win_rate\": self._calculate_win_rate(),\r\n            \"equity_curve\": equity_df\r\n        }\r\n    \r\n    def _calculate_win_rate(self) -> float:\r\n        \"\"\"计算胜率\"\"\"\r\n        if len(self.trades) < 2:\r\n            return 0\r\n        \r\n        buy_trades = [t for t in self.trades if t[\"action\"] == \"BUY\"]\r\n        sell_trades = [t for t in self.trades if t[\"action\"] == \"SELL\"]\r\n        \r\n        if len(sell_trades) == 0:\r\n            return 0\r\n        \r\n        wins = sum(\r\n            1 for i, sell in enumerate(sell_trades)\r\n            if i < len(buy_trades) and \r\n            sell[\"price\"] > buy_trades[i][\"price\"]\r\n        )\r\n        \r\n        return wins / len(sell_trades) * 100\r\n```\r\n\r\n**回测结果解读表（指标要配套看，不能只看收益）**\r\n\r\n| 指标 | 数值 | 参考区间 | 解读 |\r\n|------|------|---------|------|\r\n| 总收益 | +186.4% | — | 需结合回测期长度 |\r\n| 年化收益 | +16.8% | 10%-25% | 处于合理区间 |\r\n| 年化波动率 | 22.4% | <25% | 波动偏高但可接受 |\r\n| 夏普比率 | 0.63 | >0.5（含无风险2.75%） | 风险调整后收益一般 |\r\n| 最大回撤 | −27.6% | <30% | 接近上限，需关注 |\r\n| 卡尔玛比率 | 0.61 | >0.5 | 回撤控制尚可 |\r\n| 交易次数 | 86次/年 | — | 换手偏高，成本敏感 |\r\n| 胜率 | 48% | — | 低于50%，靠盈亏比取胜 |\r\n\r\n关键提示：若胜率低于50%而收益为正，说明依赖少数大盈利单，需检验是否由个别极端行情贡献（做剔除前10%最佳交易后的收益检验）。\r\n\r\n**未来函数检查清单（回测虚高的头号原因）**\r\n\r\n| 检查项 | 错误写法 | 正确做法 |\r\n|-------|---------|---------|\r\n| 信号时点 | 用当日收盘价生成信号并当日成交 | 用T日收盘生成信号，T+1开盘成交 |\r\n| 财务数据 | 使用报告期财务数据但在报告发布前使用 | 按公告日（而非报告期）对齐数据 |\r\n| 复权处理 | 用后复权价判断当时市值 | 历史价格用对应时点的前复权口径 |\r\n| 指数成分 | 用当前成分股回溯历史 | 使用历史成分股名单 |\r\n| 停牌处理 | 停牌日仍可交易 | 停牌日不可成交，信号顺延 |\r\n| 涨跌停 | 涨跌停仍按目标价成交 | 涨跌停日按不可成交或部分成交处理 |\r\n\r\n**成本构成示例（一次完整买卖的成本拆解）**\r\n\r\n| 成本项 | 买入 | 卖出 | 合计 |\r\n|-------|------|------|------|\r\n| 佣金（0.03%，双边） | 30元 | 30元 | 60元 |\r\n| 印花税（0.1%，仅卖出） | — | 100元 | 100元 |\r\n| 过户费（约0.001%） | 1元 | 1元 | 2元 |\r\n| 滑点（0.1%，双边） | 100元 | 100元 | 200元 |\r\n| **合计（10万元交易）** | 131元 | 231元 | **362元** |\r\n\r\n说明：单次往返成本约0.36%，若策略年换手20次，仅交易成本就接近7.2%，因此高换手策略必须把成本纳入优化目标。\r\n\r\n### 2. Strategy Examples / 策略示例\r\n\r\n```python\r\n# 示例策略：双均线交叉策略\r\nclass DualMovingAverageStrategy:\r\n    \"\"\"双均线策略\"\"\"\r\n    \r\n    def __init__(self, short_window: int = 20, long_window: int = 60):\r\n        self.short_window = short_window\r\n        self.long_window = long_window\r\n    \r\n    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:\r\n        \"\"\"生成交易信号\"\"\"\r\n        signals = pd.Series(index=data.index, dtype=int)\r\n        \r\n        # 计算均线\r\n        ma_short = data[\"close\"].rolling(self.short_window).mean()\r\n        ma_long = data[\"close\"].rolling(self.long_window).mean()\r\n        \r\n        # 金叉买入，死叉卖出\r\n        position = 0\r\n        for i in range(self.long_window, len(data)):\r\n            if ma_short.iloc[i] > ma_long.iloc[i] and position == 0:\r\n                signals.iloc[i] = 1  # 买入\r\n                position = 1\r\n            elif ma_short.iloc[i] < ma_long.iloc[i] and position == 1:\r\n                signals.iloc[i] = -1  # 卖出\r\n                position = 0\r\n        \r\n        return signals\r\n\r\n# RSI均值回归策略\r\nclass RSIMeanReversionStrategy:\r\n    \"\"\"RSI均值回归策略\"\"\"\r\n    \r\n    def __init__(self, period: int = 14, \r\n                 oversold: float = 30, \r\n                 overbought: float = 70):\r\n        self.period = period\r\n        self.oversold = oversold\r\n        self.overbought = overbought\r\n    \r\n    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:\r\n        \"\"\"RSI超卖买入，超买卖出\"\"\"\r\n        delta = data[\"close\"].diff()\r\n        gain = (delta.where(delta > 0, 0)).rolling(self.period).mean()\r\n        loss = (-delta.where(delta < 0, 0)).rolling(self.period).mean()\r\n        \r\n        rs = gain / loss\r\n        rsi = 100 - (100 / (1 + rs))\r\n        \r\n        signals = pd.Series(index=data.index, dtype=int)\r\n        position = 0\r\n        \r\n        for i in range(self.period, len(data)):\r\n            if rsi.iloc[i] < self.oversold and position == 0:\r\n                signals.iloc[i] = 1  # 买入\r\n                position = 1\r\n            elif rsi.iloc[i] > self.overbought and position == 1:\r\n                signals.iloc[i] = -1  # 卖出\r\n                position = 0\r\n        \r\n        return signals\r\n\r\n# 布林带突破策略（含波动率过滤）\r\nclass BollingerBreakoutStrategy:\r\n    \"\"\"布林带突破策略\"\"\"\r\n    \r\n    def __init__(self, window: int = 20, num_std: float = 2.0,\r\n                 atr_window: int = 14, atr_stop: float = 2.5):\r\n        self.window = window\r\n        self.num_std = num_std\r\n        self.atr_window = atr_window\r\n        self.atr_stop = atr_stop\r\n    \r\n    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:\r\n        \"\"\"突破上轨买入，跌破中轨卖出，并以ATR作为止损参考\"\"\"\r\n        ma = data[\"close\"].rolling(self.window).mean()\r\n        std = data[\"close\"].rolling(self.window).std()\r\n        upper = ma + self.num_std * std\r\n        lower = ma - self.num_std * std\r\n        \r\n        # ATR用于度量波动\r\n        high, low, close = data[\"high\"], data[\"low\"], data[\"close\"]\r\n        tr = pd.concat([\r\n            high - low,\r\n            (high - close.shift()).abs(),\r\n            (low - close.shift()).abs()\r\n        ], axis=1).max(axis=1)\r\n        atr = tr.rolling(self.atr_window).mean()\r\n        \r\n        signals = pd.Series(index=data.index, dtype=int)\r\n        position = 0\r\n        entry_price = 0.0\r\n        \r\n        for i in range(self.window, len(data)):\r\n            price = close.iloc[i]\r\n            stop_line = entry_price - self.atr_stop * atr.iloc[i]\r\n            \r\n            if position == 0 and price > upper.iloc[i]:\r\n                signals.iloc[i] = 1\r\n                position = 1\r\n                entry_price = price\r\n            elif position == 1 and (price < ma.iloc[i] or price < stop_line):\r\n                signals.iloc[i] = -1\r\n                position = 0\r\n                entry_price = 0.0\r\n        \r\n        return signals\r\n```\r\n\r\n**三类策略的适用环境对比**\r\n\r\n| 策略 | 逻辑 | 适用市场 | 最大风险点 | 关键参数 |\r\n|------|------|---------|-----------|---------|\r\n| 双均线 | 趋势跟踪 | 单边趋势市 | 震荡市反复止损 | 短/长窗口 |\r\n| RSI均值回归 | 超买超卖反转 | 震荡市 | 趋势市中逆势 | 周期、超买超卖阈值 |\r\n| 布林带突破 | 波动扩张跟进 | 波动放大初期 | 假突破 | 窗口、标准差倍数、ATR止损 |\r\n\r\n**示例 1｜参数寻优的正确做法**\r\n\r\n| 步骤 | 做法 | 目的 |\r\n|------|------|------|\r\n| 1 | 粗网格搜索（如MA参数 5-60，步长5） | 快速定位有效区域 |\r\n| 2 | 观察参数邻域稳定性 | 避免落到孤立最优值 |\r\n| 3 | 在样本外区间验证 | 检验是否过拟合 |\r\n| 4 | 检查参数的经济含义 | 排除无逻辑的参数组合 |\r\n| 5 | 固定参数做前向测试 | 确认可复现 |\r\n\r\n**示例 2｜参数敏感性判断（用邻域看稳定性）**\r\n\r\n| 参数组合 | MA短 | MA长 | 年化收益 | 最大回撤 | 判断 |\r\n|---------|------|------|---------|---------|------|\r\n| A | 20 | 60 | 16.8% | −27.6% | 中心值 |\r\n| B | 18 | 60 | 15.9% | −26.8% | 邻域稳定 |\r\n| C | 22 | 60 | 16.2% | −28.1% | 邻域稳定 |\r\n| D | 5 | 20 | 34.5% | −41.2% | 孤立高收益，疑过拟合 |\r\n| E | 40 | 120 | 11.2% | −22.4% | 反应迟缓，收益偏低 |\r\n\r\n判断要点：中心值附近绩效平滑变化说明参数稳健；若出现\"只有某个很窄的参数区间收益极高、邻域骤降\"，通常意味着曲线拟合（过拟合）而非真实的策略优势。\r\n\r\n### 3. Monte Carlo Simulation / 蒙特卡洛模拟\r\n\r\n```python\r\nclass MonteCarloSimulation:\r\n    \"\"\"蒙特卡洛模拟\"\"\"\r\n    \r\n    def run_simulation(self, historical_returns: pd.Series,\r\n                      n_simulations: int = 1000,\r\n                      n_periods: int = 252,\r\n                      initial_value: float = 1000000) -> dict:\r\n        \"\"\"\r\n        运行蒙特卡洛模拟\r\n        \"\"\"\r\n        mu = historical_returns.mean()\r\n        sigma = historical_returns.std()\r\n        \r\n        simulations = np.zeros((n_simulations, n_periods))\r\n        simulations[:, 0] = initial_value\r\n        \r\n        for t in range(1, n_periods):\r\n            random_returns = np.random.normal(mu, sigma, n_simulations)\r\n            simulations[:, t] = simulations[:, t-1] * (1 + random_returns)\r\n        \r\n        # 统计结果\r\n        final_values = simulations[:, -1]\r\n        \r\n        percentiles = {\r\n            \"5th\": np.percentile(final_values, 5),\r\n            \"25th\": np.percentile(final_values, 25),\r\n            \"50th\": np.percentile(final_values, 50),\r\n            \"75th\": np.percentile(final_values, 75),\r\n            \"95th\": np.percentile(final_values, 95)\r\n        }\r\n        \r\n        # 概率分析\r\n        prob_loss = (final_values < initial_value).mean() * 100\r\n        \r\n        return {\r\n            \"percentiles\": {k: round(v, 2) for k, v in percentiles.items()},\r\n            \"probability_of_loss\": round(prob_loss, 2),\r\n            \"expected_return\": round(final_values.mean() - initial_value, 2),\r\n            \"var_95\": round(initial_value - percentiles[\"5th\"], 2),\r\n            \"simulations\": simulations\r\n        }\r\n```\r\n\r\n**示例 1｜蒙特卡洛结果解读（看分布，不看单点）**\r\n\r\n| 分位 | 期末价值（万元） | 相对初始（100万） | 解读 |\r\n|------|--------------|----------------|------|\r\n| 5th | 78.5 | −21.5% | 悲观情景，一年后亏损两成 |\r\n| 25th | 94.2 | −5.8% | 四分之一概率不赚钱 |\r\n| 50th | 112.6 | +12.6% | 中位情景 |\r\n| 75th | 134.8 | +34.8% | 乐观情景 |\r\n| 95th | 162.4 | +62.4% | 极端乐观情景 |\r\n\r\n- 亏损概率（期末低于初始）：**约 33%**。\r\n- VaR(95) = 100 − 78.5 = **21.5万元**。\r\n- 解读要点：中位数收益为正不代表大概率赚钱——本例如亏损概率33%，说明\"三次里有一次亏钱\"，须在报告中如实披露。\r\n\r\n**示例 2｜蒙特卡洛的三种误用**\r\n\r\n| 误用 | 后果 | 正确做法 |\r\n|------|------|---------|\r\n| 只用正态分布 | 低估极端损失 | 用历史自助抽样或t分布对比 |\r\n| 参数来自短期样本 | 分布估计不稳 | 用足够长的样本并做分段检验 |\r\n| 把模拟结果当作预测 | 误导决策 | 明确\"模拟为假设推演，非收益预测\" |\r\n\r\n### 4. Walk-Forward & Performance Attribution / 前向分析与绩效归因\r\n\r\n**前向分析设计表**\r\n\r\n| 项目 | 设置 | 说明 |\r\n|------|------|------|\r\n| 训练窗口 | 36个月 | 用于参数拟合 |\r\n| 测试窗口 | 6个月 | 用于样本外验证 |\r\n| 滚动步长 | 6个月 | 窗口向前滚动 |\r\n| 参数冻结 | 测试期内不变 | 防止\"边测边调\" |\r\n| 输出 | 各测试段的收益、回撤 | 关注一致性而非平均 |\r\n\r\n**示例｜样本内 vs 样本外对比（判断是否过拟合）**\r\n\r\n| 指标 | 样本内 | 样本外 | 衰减幅度 | 判断 |\r\n|------|-------|-------|---------|------|\r\n| 年化收益 | 24.5% | 11.2% | −54% | 衰减明显，需谨慎 |\r\n| 夏普比率 | 1.12 | 0.48 | −57% | 风险调整后收益下降 |\r\n| 最大回撤 | −18.6% | −26.3% | 加深 7.7pct | 样本外更差 |\r\n| 胜率 | 56% | 49% | −7pct | 优势减弱 |\r\n\r\n经验口径：样本外年化收益不低于样本内的60%、夏普比率不低于样本内的50%，方可认为策略具备一定稳健性；衰减超过上述幅度时应重新审视参数与逻辑。\r\n\r\n**绩效归因分解表**\r\n\r\n| 归因维度 | 贡献 | 说明 |\r\n|---------|------|------|\r\n| 择时（仓位） | +3.2% | 高仓位期恰逢上涨 |\r\n| 选股（标的） | +9.6% | 主要收益来源 |\r\n| 行业配置 | +2.1% | 超配强势行业 |\r\n| 交易成本 | −4.3% | 换手偏高拖累 |\r\n| 残差/其他 | +0.6% | 无法解释部分 |\r\n| **合计** | **+11.2%** | 与样本外年化一致 |\r\n\r\n使用要点：归因结果要与换手率、成本假设交叉验证；若\"选股贡献\"高度集中于个别标的，应在报告中标注集中度风险。\r\n\r\n---\r\n\r\n## Quick Command Templates / 快速指令模板\r\n\r\n**回测双均线策略：**\r\n```\r\n回测双均线策略（MA20/MA60）：\r\n- 初始资金：100万\r\n- 回测期：2020-01-01至2025-12-31\r\n- 关注指标：收益率、夏普比率、最大回撤\r\n```\r\n\r\n**蒙特卡洛模拟：**\r\n```\r\n对当前持仓做蒙特卡洛模拟：\r\n- 模拟次数：10000次\r\n- 模拟期限：1年\r\n- 置信区间：95%\r\n```\r\n\r\n**前向分析：**\r\n```\r\n对[策略名称]做前向分析：训练窗口36个月、测试窗口6个月、\r\n滚动步长6个月，输出各测试段的收益与回撤，并对比样本内外的衰减幅度。\r\n```\r\n\r\n**容量与成本评估：**\r\n```\r\n评估[策略名称]的容量上限与成本影响：\r\n- 输入：策略年换手、持仓标的日均成交额\r\n- 输出：容量上限估算、滑点扩大情景下的净收益衰减\r\n```\r\n\r\n---\r\n\r\n## Disclaimer\r\n\r\nThis skill provides backtesting tools for educational and research purposes. Backtesting results do not guarantee future performance. Past performance is not indicative of future results. Algorithmic trading involves substantial risk of loss.\n\nFile v3.0.2:_meta.json\n\n{\n  \"ownerId\": \"kn74e704j3ygjcygnpf02rdvd185js13\",\n  \"slug\": \"security-quant-backtest\",\n  \"version\": \"3.0.2\",\n  \"publishedAt\": 1789197912439\n}\n\nFile v3.0.2:skill-card.md\n\n## Description:\n\nAI-powered quantitative backtesting laboratory for China A-share strategy design, historical tests, performance attribution, walk-forward analysis, and Monte Carlo simulation.\n\nThis skill is for research and development only.\n\n## Publisher:\n\n[gechengling](https://clawhub.ai/user/gechengling)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nExternal developers, quantitative analysts, and algorithmic trading researchers use this skill to design and evaluate China A-share strategies with example Python backtests, metric interpretation, cost and capacity checks, walk-forward analysis, and Monte Carlo scenarios.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: Example backtesting logic may produce inaccurate performance results if position accounting and execution timing assumptions are not corrected and tested.\n\nMitigation: Treat generated performance results as illustrative, review and test accounting and execution assumptions against known cases, and do not use them for real trading or investment decisions without independent validation.\n\nRisk: Backtest and Monte Carlo outputs can be mistaken for predictions or promises of future returns.\n\nMitigation: Label outputs as simulated scenarios, disclose assumptions and data limits, and avoid presenting past or simulated performance as a guarantee of future results.\n\n## Reference(s):\n\n- [ClawHub Skill Page](https://clawhub.ai/gechengling/skills/security-quant-backtest)\n\n## Skill Output:\n\n**Output Type(s):** [text, markdown, code, guidance]\n\n**Output Format:** [Markdown with Python code examples, analytical tables, and command templates]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [Outputs are intended as educational research guidance and illustrative backtesting examples, not investment advice or guaranteed performance predictions.]\n\n## Skill Version(s):\n\n3.0.2 (source: frontmatter and server release evidence)\n\n## Ethical Considerations:\n\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.\n\nArchive v3.0.1: 3 files, 6336 bytes\n\nFiles: skill-card.md (2362b), SKILL.md (14075b), _meta.json (142b)\n\nFile v3.0.1:SKILL.md\n\n---\r\nname: Quantitative Backtesting Laboratory\r\nslug: security-quant-backtest\r\ndescription: AI-powered quantitative backtesting laboratory for China A-share — covers strategy design, historical backtesting, performance attribution, walk-forward analysis, and Monte Carlo simulation. Built for quantitative analysts, algorithmic traders, and Python-based backtesting. Keywords: quantitative backtesting, algorithmic trading, strategy research, Python backtest, China A-share, performance analysis, 量化回测, 算法交易, 策略研究, Python回测, 绩效归因, 量化策略, 蒙特卡洛, 趋势跟踪, 均值回归, 统计套利.\r\nversion: \"3.0.1\"\r\n---\r\n\r\n# Quantitative Backtesting Laboratory / 量化回测实验室\r\n\r\n> **English:** AI-powered quantitative backtesting laboratory — covers strategy design, historical backtesting, performance attribution, walk-forward analysis, and Monte Carlo simulation. Built for quant analysts and algorithmic traders.\r\n>\r\n> **中文:** 量化回测实验室——覆盖策略设计、历史回测、绩效归因、前向分析、蒙特卡洛模拟。适用：量化分析师、算法交易者、Python回测开发。\r\n\r\n---\r\n\r\n\r\n### 证券监管最新动态 [2026-05-25更新]\r\n\r\n| 动态类型 | 内容摘要 | 影响范围 |\r\n|---------|---------|---------|\r\n| 证券监管 | 2026年A股量化资金占比30%-40%，回测需考虑拥挤度因子 | 回测框架需增加拥挤度、压力测试和合规成本模块 |\r\n| 证券监管 | 2026年3月量化踩踏事件：回测模型需加入极端行情压力测试 | 回测框架需增加拥挤度、压力测试和合规成本模块 |\r\n| 证券监管 | 算法监管趋严，高频策略回测需考虑合规成本 | 回测框架需增加拥挤度、压力测试和合规成本模块 |\r\n\r\n> **数据截止**: 2026-05-25 | 来源：证监会、NFRA、中证协、安永Q1分析\r\n> **声明**: 以上动态供参考，具体以官方最新发布为准\r\n\r\n## Industry Pain Points / 行业痛点\r\n\r\n| Pain Point / 痛点 | Impact / 影响 | Solution / 本Skill解决方案 |\r\n|------------------|-------------|------------------------|\r\n| **未来函数** | 回测虚高，实盘亏损 | 信号对齐检查+严格回测规范 |\r\n| **过拟合** | 参数过度优化，实盘失效 | 样本外测试+统计显著性检验 |\r\n| **滑点假设** | 低估交易成本，实盘收益缩水 | 多场景滑点模拟 |\r\n| **幸存者偏差** | 只用现存股票，忽视退市股 | 使用完整历史数据 |\r\n| **执行缺口** | 回测vs实盘收益差异大 | 分层回测+执行模拟 |\r\n\r\n---\r\n\r\n## Trigger Keywords / 触发关键词\r\n\r\n**English Triggers:** quantitative backtesting, algorithmic trading, strategy research, Python backtest, performance analysis, Monte Carlo, walk-forward analysis, A-share strategy\r\n\r\n**中文触发词（优先）：** 量化回测 / 算法交易 / 策略研究 / Python回测 / 绩效归因 / 蒙特卡洛 / 前向分析 / 趋势跟踪 / 均值回归 / 配对交易 / 双均线 / 海龟策略 / RSI策略 / 布林带策略 / 策略优化 / 参数寻优 / 机器学习选股 / Alpha因子 / 多因子策略\r\n\r\n---\r\n\r\n## Core Capabilities / 核心能力\r\n\r\n### 1. Backtesting Engine / 回测引擎\r\n\r\n```python\r\nimport pandas as pd\r\nimport numpy as np\r\nfrom datetime import datetime\r\nimport warnings\r\nwarnings.filterwarnings('ignore')\r\n\r\nclass BacktestEngine:\r\n    \"\"\"量化回测引擎\"\"\"\r\n    \r\n    def __init__(self, initial_capital: float = 1000000,\r\n                 commission_rate: float = 0.0003,\r\n                 stamp_tax: float = 0.001,\r\n                 slippage: float = 0.001):\r\n        \"\"\"\r\n        Args:\r\n            initial_capital: 初始资金\r\n            commission_rate: 佣金费率（含规费）\r\n            stamp_tax: 印花税率（仅卖出）\r\n            slippage: 滑点（百分比）\r\n        \"\"\"\r\n        self.initial_capital = initial_capital\r\n        self.commission_rate = commission_rate\r\n        self.stamp_tax = stamp_tax\r\n        self.slippage = slippage\r\n        \r\n        # 持仓状态\r\n        self.cash = initial_capital\r\n        self.position = {}  # {stock_code: shares}\r\n        self.equity_curve = []\r\n        self.trades = []\r\n    \r\n    def run(self, data: pd.DataFrame, signals: pd.DataFrame,\r\n            strategy_name: str = \"Strategy\") -> dict:\r\n        \"\"\"\r\n        执行回测\r\n        Args:\r\n            data: 价格数据（含收盘价、开盘价、最高、最低价）\r\n            signals: 交易信号（1=买入, -1=卖出, 0=持有）\r\n            strategy_name: 策略名称\r\n        \"\"\"\r\n        results = []\r\n        \r\n        for date in data.index:\r\n            price = data.loc[date, \"close\"]\r\n            \r\n            # 获取当日信号\r\n            if date in signals.index:\r\n                signal = signals.loc[date]\r\n                if signal == 1:  # 买入信号\r\n                    self._buy(date, price, self.cash * 0.95)  # 保留5%现金\r\n                elif signal == -1:  # 卖出信号\r\n                    self._sell(date, price)\r\n            \r\n            # 更新权益\r\n            portfolio_value = self._calculate_portfolio_value(price)\r\n            self.equity_curve.append({\r\n                \"date\": date,\r\n                \"portfolio_value\": portfolio_value,\r\n                \"cash\": self.cash\r\n            })\r\n        \r\n        return self._generate_report(strategy_name)\r\n    \r\n    def _buy(self, date, price, target_amount):\r\n        \"\"\"买入执行（含滑点+佣金）\"\"\"\r\n        buy_price = price * (1 + self.slippage)\r\n        shares = int(target_amount / buy_price / 100) * 100  # 100股整数\r\n        \r\n        if shares > 0:\r\n            cost = shares * buy_price\r\n            commission = cost * self.commission_rate\r\n            \r\n            if cost + commission <= self.cash:\r\n                self.cash -= (cost + commission)\r\n                self.trades.append({\r\n                    \"date\": date, \"action\": \"BUY\",\r\n                    \"price\": buy_price, \"shares\": shares,\r\n                    \"commission\": commission\r\n                })\r\n    \r\n    def _sell(self, date, price):\r\n        \"\"\"卖出执行（含滑点+佣金+印花税）\"\"\"\r\n        sell_price = price * (1 - self.slippage)\r\n        \r\n        for stock, shares in list(self.position.items()):\r\n            if shares > 0:\r\n                proceeds = shares * sell_price\r\n                commission = proceeds * self.commission_rate\r\n                tax = proceeds * self.stamp_tax\r\n                \r\n                self.cash -= (commission + tax)\r\n                self.cash += proceeds\r\n                self.trades.append({\r\n                    \"date\": date, \"action\": \"SELL\",\r\n                    \"price\": sell_price, \"shares\": shares,\r\n                    \"commission\": commission, \"tax\": tax\r\n                })\r\n    \r\n    def _calculate_portfolio_value(self, current_price):\r\n        \"\"\"计算组合市值\"\"\"\r\n        position_value = sum(\r\n            shares * current_price \r\n            for stock, shares in self.position.items()\r\n        )\r\n        return self.cash + position_value\r\n    \r\n    def _generate_report(self, strategy_name: str) -> dict:\r\n        \"\"\"生成回测报告\"\"\"\r\n        equity_df = pd.DataFrame(self.equity_curve)\r\n        equity_df.set_index(\"date\", inplace=True)\r\n        equity_df[\"returns\"] = equity_df[\"portfolio_value\"].pct_change()\r\n        \r\n        # 核心指标计算\r\n        total_return = (equity_df[\"portfolio_value\"].iloc[-1] / \r\n                       self.initial_capital - 1) * 100\r\n        \r\n        annual_return = ((1 + total_return/100) ** \r\n                        (252/len(equity_df)) - 1) * 100\r\n        \r\n        volatility = equity_df[\"returns\"].std() * np.sqrt(252) * 100\r\n        \r\n        sharpe_ratio = (annual_return - 2.75) / volatility  # 假设无风险利率2.75%\r\n        \r\n        # 最大回撤\r\n        cummax = equity_df[\"portfolio_value\"].cummax()\r\n        drawdown = (equity_df[\"portfolio_value\"] - cummax) / cummax\r\n        max_drawdown = drawdown.min() * 100\r\n        \r\n        # 卡尔玛比率\r\n        calmar_ratio = annual_return / abs(max_drawdown) if max_drawdown != 0 else 0\r\n        \r\n        return {\r\n            \"strategy\": strategy_name,\r\n            \"period\": f\"{equity_df.index[0].date()} to {equity_df.index[-1].date()}\",\r\n            \"total_return\": round(total_return, 2),\r\n            \"annual_return\": round(annual_return, 2),\r\n            \"volatility\": round(volatility, 2),\r\n            \"sharpe_ratio\": round(sharpe_ratio, 2),\r\n            \"max_drawdown\": round(max_drawdown, 2),\r\n            \"calmar_ratio\": round(calmar_ratio, 2),\r\n            \"total_trades\": len([t for t in self.trades if t[\"action\"] == \"BUY\"]),\r\n            \"win_rate\": self._calculate_win_rate(),\r\n            \"equity_curve\": equity_df\r\n        }\r\n    \r\n    def _calculate_win_rate(self) -> float:\r\n        \"\"\"计算胜率\"\"\"\r\n        if len(self.trades) < 2:\r\n            return 0\r\n        \r\n        buy_trades = [t for t in self.trades if t[\"action\"] == \"BUY\"]\r\n        sell_trades = [t for t in self.trades if t[\"action\"] == \"SELL\"]\r\n        \r\n        if len(sell_trades) == 0:\r\n            return 0\r\n        \r\n        wins = sum(\r\n            1 for i, sell in enumerate(sell_trades)\r\n            if i < len(buy_trades) and \r\n            sell[\"price\"] > buy_trades[i][\"price\"]\r\n        )\r\n        \r\n        return wins / len(sell_trades) * 100\r\n```\r\n\r\n### 2. Strategy Examples / 策略示例\r\n\r\n```python\r\n# 示例策略：双均线交叉策略\r\nclass DualMovingAverageStrategy:\r\n    \"\"\"双均线策略\"\"\"\r\n    \r\n    def __init__(self, short_window: int = 20, long_window: int = 60):\r\n        self.short_window = short_window\r\n        self.long_window = long_window\r\n    \r\n    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:\r\n        \"\"\"生成交易信号\"\"\"\r\n        signals = pd.Series(index=data.index, dtype=int)\r\n        \r\n        # 计算均线\r\n        ma_short = data[\"close\"].rolling(self.short_window).mean()\r\n        ma_long = data[\"close\"].rolling(self.long_window).mean()\r\n        \r\n        # 金叉买入，死叉卖出\r\n        position = 0\r\n        for i in range(self.long_window, len(data)):\r\n            if ma_short.iloc[i] > ma_long.iloc[i] and position == 0:\r\n                signals.iloc[i] = 1  # 买入\r\n                position = 1\r\n            elif ma_short.iloc[i] < ma_long.iloc[i] and position == 1:\r\n                signals.iloc[i] = -1  # 卖出\r\n                position = 0\r\n        \r\n        return signals\r\n\r\n# RSI均值回归策略\r\nclass RSIMeanReversionStrategy:\r\n    \"\"\"RSI均值回归策略\"\"\"\r\n    \r\n    def __init__(self, period: int = 14, \r\n                 oversold: float = 30, \r\n                 overbought: float = 70):\r\n        self.period = period\r\n        self.oversold = oversold\r\n        self.overbought = overbought\r\n    \r\n    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:\r\n        \"\"\"RSI超卖买入，超买卖出\"\"\"\r\n        delta = data[\"close\"].diff()\r\n        gain = (delta.where(delta > 0, 0)).rolling(self.period).mean()\r\n        loss = (-delta.where(delta < 0, 0)).rolling(self.period).mean()\r\n        \r\n        rs = gain / loss\r\n        rsi = 100 - (100 / (1 + rs))\r\n        \r\n        signals = pd.Series(index=data.index, dtype=int)\r\n        position = 0\r\n        \r\n        for i in range(self.period, len(data)):\r\n            if rsi.iloc[i] < self.oversold and position == 0:\r\n                signals.iloc[i] = 1  # 买入\r\n                position = 1\r\n            elif rsi.iloc[i] > self.overbought and position == 1:\r\n                signals.iloc[i] = -1  # 卖出\r\n                position = 0\r\n        \r\n        return signals\r\n```\r\n\r\n### 3. Monte Carlo Simulation / 蒙特卡洛模拟\r\n\r\n```python\r\nclass MonteCarloSimulation:\r\n    \"\"\"蒙特卡洛模拟\"\"\"\r\n    \r\n    def run_simulation(self, historical_returns: pd.Series,\r\n                      n_simulations: int = 1000,\r\n                      n_periods: int = 252,\r\n                      initial_value: float = 1000000) -> dict:\r\n        \"\"\"\r\n        运行蒙特卡洛模拟\r\n        \"\"\"\r\n        mu = historical_returns.mean()\r\n        sigma = historical_returns.std()\r\n        \r\n        simulations = np.zeros((n_simulations, n_periods))\r\n        simulations[:, 0] = initial_value\r\n        \r\n        for t in range(1, n_periods):\r\n            random_returns = np.random.normal(mu, sigma, n_simulations)\r\n            simulations[:, t] = simulations[:, t-1] * (1 + random_returns)\r\n        \r\n        # 统计结果\r\n        final_values = simulations[:, -1]\r\n        \r\n        percentiles = {\r\n            \"5th\": np.percentile(final_values, 5),\r\n            \"25th\": np.percentile(final_values, 25),\r\n            \"50th\": np.percentile(final_values, 50),\r\n            \"75th\": np.percentile(final_values, 75),\r\n            \"95th\": np.percentile(final_values, 95)\r\n        }\r\n        \r\n        # 概率分析\r\n        prob_loss = (final_values < initial_value).mean() * 100\r\n        \r\n        return {\r\n            \"percentiles\": {k: round(v, 2) for k, v in percentiles.items()},\r\n            \"probability_of_loss\": round(prob_loss, 2),\r\n            \"expected_return\": round(final_values.mean() - initial_value, 2),\r\n            \"var_95\": round(initial_value - percentiles[\"5th\"], 2),\r\n            \"simulations\": simulations\r\n        }\r\n```\r\n\r\n---\r\n\r\n## Quick Command Templates / 快速指令模板\r\n\r\n**回测双均线策略：**\r\n```\r\n回测双均线策略（MA20/MA60）：\r\n- 初始资金：100万\r\n- 回测期：2020-01-01至2025-12-31\r\n- 关注指标：收益率、夏普比率、最大回撤\r\n```\r\n\r\n**蒙特卡洛模拟：**\r\n```\r\n对当前持仓做蒙特卡洛模拟：\r\n- 模拟次数：10000次\r\n- 模拟期限：1年\r\n- 置信区间：95%\r\n```\r\n\r\n---\r\n\r\n## Disclaimer\r\n\r\nThis skill provides backtesting tools for educational and research purposes. Backtesting results do not guarantee future performance. Past performance is not indicative of future results. Algorithmic trading involves substantial risk of loss.\n\nFile v3.0.1:_meta.json\n\n{\n  \"ownerId\": \"kn74e704j3ygjcygnpf02rdvd185js13\",\n  \"slug\": \"security-quant-backtest\",\n  \"version\": \"3.0.1\",\n  \"publishedAt\": 1779680452246\n}\n\nFile v3.0.1:skill-card.md\n\n## Description: <br>\nAI-powered quantitative backtesting laboratory for China A-share strategy research, covering strategy design, historical tests, performance attribution, walk-forward analysis, and Monte Carlo simulation. <br>\n\nThis skill is for research and development only. <br>\n\n## Publisher: <br>\n[gechengling](https://clawhub.ai/user/gechengling) <br>\n\n### License/Terms of Use: <br>\nMIT-0 <br>\n\n\n## Use Case: <br>\nExternal developers, quantitative analysts, and algorithmic traders use this skill to draft and review China A-share backtests, strategy examples, performance metrics, walk-forward checks, and Monte Carlo risk simulations for research. <br>\n\n### Deployment Geography for Use: <br>\nGlobal <br>\n\n## Known Risks and Mitigations: <br>\nRisk: The included sample backtesting engine has a reliability issue in its position ledger and should not be trusted for real trading or allocation decisions. <br>\nMitigation: Use the skill only as an educational research helper until the ledger behavior is fixed and independently tested. <br>\nRisk: Backtesting results can be misleading and do not guarantee future market performance. <br>\nMitigation: Treat outputs as research artifacts, validate assumptions against independent data, and avoid using them as investment advice. <br>\nRisk: Regulatory and market claims may become stale or may require official confirmation. <br>\nMitigation: Verify any China A-share regulatory or market claims against current official sources before relying on them. <br>\n\n\n## Reference(s): <br>\n- [Security Quant Backtest on ClawHub](https://clawhub.ai/gechengling/security-quant-backtest) <br>\n\n\n## Skill Output: <br>\n**Output Type(s):** [Text, Markdown, Code, Guidance] <br>\n**Output Format:** [Markdown with Python code blocks and structured analysis] <br>\n**Output Parameters:** [1D] <br>\n**Other Properties Related to Output:** [May include sample Python backtesting code, quantitative research guidance, and finance risk disclaimers.] <br>\n\n## Skill Version(s): <br>\n3.0.1 (source: SKILL.md frontmatter and server release metadata) <br>\n\n## Ethical Considerations: <br>\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment. <br>\n\nArchive v2.0.0: 2 files, 4728 bytes\n\nFiles: SKILL.md (13297b), _meta.json (142b)\n\nFile v2.0.0:SKILL.md\n\n---\r\nname: Quantitative Backtesting Laboratory\r\nslug: security-quant-backtest\r\ndescription: AI-powered quantitative backtesting laboratory for China A-share — covers strategy design, historical backtesting, performance attribution, walk-forward analysis, and Monte Carlo simulation. Built for quantitative analysts, algorithmic traders, and Python-based backtesting. Keywords: quantitative backtesting, algorithmic trading, strategy research, Python backtest, China A-share, performance analysis, 量化回测, 算法交易, 策略研究, Python回测, 绩效归因, 量化策略, 蒙特卡洛, 趋势跟踪, 均值回归, 统计套利.\r\nversion: 1.0.0\r\n---\r\n\r\n# Quantitative Backtesting Laboratory / 量化回测实验室\r\n\r\n> **English:** AI-powered quantitative backtesting laboratory — covers strategy design, historical backtesting, performance attribution, walk-forward analysis, and Monte Carlo simulation. Built for quant analysts and algorithmic traders.\r\n>\r\n> **中文:** 量化回测实验室——覆盖策略设计、历史回测、绩效归因、前向分析、蒙特卡洛模拟。适用：量化分析师、算法交易者、Python回测开发。\r\n\r\n---\r\n\r\n## Industry Pain Points / 行业痛点\r\n\r\n| Pain Point / 痛点 | Impact / 影响 | Solution / 本Skill解决方案 |\r\n|------------------|-------------|------------------------|\r\n| **未来函数** | 回测虚高，实盘亏损 | 信号对齐检查+严格回测规范 |\r\n| **过拟合** | 参数过度优化，实盘失效 | 样本外测试+统计显著性检验 |\r\n| **滑点假设** | 低估交易成本，实盘收益缩水 | 多场景滑点模拟 |\r\n| **幸存者偏差** | 只用现存股票，忽视退市股 | 使用完整历史数据 |\r\n| **执行缺口** | 回测vs实盘收益差异大 | 分层回测+执行模拟 |\r\n\r\n---\r\n\r\n## Trigger Keywords / 触发关键词\r\n\r\n**English Triggers:** quantitative backtesting, algorithmic trading, strategy research, Python backtest, performance analysis, Monte Carlo, walk-forward analysis, A-share strategy\r\n\r\n**中文触发词（优先）：** 量化回测 / 算法交易 / 策略研究 / Python回测 / 绩效归因 / 蒙特卡洛 / 前向分析 / 趋势跟踪 / 均值回归 / 配对交易 / 双均线 / 海龟策略 / RSI策略 / 布林带策略 / 策略优化 / 参数寻优 / 机器学习选股 / Alpha因子 / 多因子策略\r\n\r\n---\r\n\r\n## Core Capabilities / 核心能力\r\n\r\n### 1. Backtesting Engine / 回测引擎\r\n\r\n```python\r\nimport pandas as pd\r\nimport numpy as np\r\nfrom datetime import datetime\r\nimport warnings\r\nwarnings.filterwarnings('ignore')\r\n\r\nclass BacktestEngine:\r\n    \"\"\"量化回测引擎\"\"\"\r\n    \r\n    def __init__(self, initial_capital: float = 1000000,\r\n                 commission_rate: float = 0.0003,\r\n                 stamp_tax: float = 0.001,\r\n                 slippage: float = 0.001):\r\n        \"\"\"\r\n        Args:\r\n            initial_capital: 初始资金\r\n            commission_rate: 佣金费率（含规费）\r\n            stamp_tax: 印花税率（仅卖出）\r\n            slippage: 滑点（百分比）\r\n        \"\"\"\r\n        self.initial_capital = initial_capital\r\n        self.commission_rate = commission_rate\r\n        self.stamp_tax = stamp_tax\r\n        self.slippage = slippage\r\n        \r\n        # 持仓状态\r\n        self.cash = initial_capital\r\n        self.position = {}  # {stock_code: shares}\r\n        self.equity_curve = []\r\n        self.trades = []\r\n    \r\n    def run(self, data: pd.DataFrame, signals: pd.DataFrame,\r\n            strategy_name: str = \"Strategy\") -> dict:\r\n        \"\"\"\r\n        执行回测\r\n        Args:\r\n            data: 价格数据（含收盘价、开盘价、最高、最低价）\r\n            signals: 交易信号（1=买入, -1=卖出, 0=持有）\r\n            strategy_name: 策略名称\r\n        \"\"\"\r\n        results = []\r\n        \r\n        for date in data.index:\r\n            price = data.loc[date, \"close\"]\r\n            \r\n            # 获取当日信号\r\n            if date in signals.index:\r\n                signal = signals.loc[date]\r\n                if signal == 1:  # 买入信号\r\n                    self._buy(date, price, self.cash * 0.95)  # 保留5%现金\r\n                elif signal == -1:  # 卖出信号\r\n                    self._sell(date, price)\r\n            \r\n            # 更新权益\r\n            portfolio_value = self._calculate_portfolio_value(price)\r\n            self.equity_curve.append({\r\n                \"date\": date,\r\n                \"portfolio_value\": portfolio_value,\r\n                \"cash\": self.cash\r\n            })\r\n        \r\n        return self._generate_report(strategy_name)\r\n    \r\n    def _buy(self, date, price, target_amount):\r\n        \"\"\"买入执行（含滑点+佣金）\"\"\"\r\n        buy_price = price * (1 + self.slippage)\r\n        shares = int(target_amount / buy_price / 100) * 100  # 100股整数\r\n        \r\n        if shares > 0:\r\n            cost = shares * buy_price\r\n            commission = cost * self.commission_rate\r\n            \r\n            if cost + commission <= self.cash:\r\n                self.cash -= (cost + commission)\r\n                self.trades.append({\r\n                    \"date\": date, \"action\": \"BUY\",\r\n                    \"price\": buy_price, \"shares\": shares,\r\n                    \"commission\": commission\r\n                })\r\n    \r\n    def _sell(self, date, price):\r\n        \"\"\"卖出执行（含滑点+佣金+印花税）\"\"\"\r\n        sell_price = price * (1 - self.slippage)\r\n        \r\n        for stock, shares in list(self.position.items()):\r\n            if shares > 0:\r\n                proceeds = shares * sell_price\r\n                commission = proceeds * self.commission_rate\r\n                tax = proceeds * self.stamp_tax\r\n                \r\n                self.cash -= (commission + tax)\r\n                self.cash += proceeds\r\n                self.trades.append({\r\n                    \"date\": date, \"action\": \"SELL\",\r\n                    \"price\": sell_price, \"shares\": shares,\r\n                    \"commission\": commission, \"tax\": tax\r\n                })\r\n    \r\n    def _calculate_portfolio_value(self, current_price):\r\n        \"\"\"计算组合市值\"\"\"\r\n        position_value = sum(\r\n            shares * current_price \r\n            for stock, shares in self.position.items()\r\n        )\r\n        return self.cash + position_value\r\n    \r\n    def _generate_report(self, strategy_name: str) -> dict:\r\n        \"\"\"生成回测报告\"\"\"\r\n        equity_df = pd.DataFrame(self.equity_curve)\r\n        equity_df.set_index(\"date\", inplace=True)\r\n        equity_df[\"returns\"] = equity_df[\"portfolio_value\"].pct_change()\r\n        \r\n        # 核心指标计算\r\n        total_return = (equity_df[\"portfolio_value\"].iloc[-1] / \r\n                       self.initial_capital - 1) * 100\r\n        \r\n        annual_return = ((1 + total_return/100) ** \r\n                        (252/len(equity_df)) - 1) * 100\r\n        \r\n        volatility = equity_df[\"returns\"].std() * np.sqrt(252) * 100\r\n        \r\n        sharpe_ratio = (annual_return - 2.75) / volatility  # 假设无风险利率2.75%\r\n        \r\n        # 最大回撤\r\n        cummax = equity_df[\"portfolio_value\"].cummax()\r\n        drawdown = (equity_df[\"portfolio_value\"] - cummax) / cummax\r\n        max_drawdown = drawdown.min() * 100\r\n        \r\n        # 卡尔玛比率\r\n        calmar_ratio = annual_return / abs(max_drawdown) if max_drawdown != 0 else 0\r\n        \r\n        return {\r\n            \"strategy\": strategy_name,\r\n            \"period\": f\"{equity_df.index[0].date()} to {equity_df.index[-1].date()}\",\r\n            \"total_return\": round(total_return, 2),\r\n            \"annual_return\": round(annual_return, 2),\r\n            \"volatility\": round(volatility, 2),\r\n            \"sharpe_ratio\": round(sharpe_ratio, 2),\r\n            \"max_drawdown\": round(max_drawdown, 2),\r\n            \"calmar_ratio\": round(calmar_ratio, 2),\r\n            \"total_trades\": len([t for t in self.trades if t[\"action\"] == \"BUY\"]),\r\n            \"win_rate\": self._calculate_win_rate(),\r\n            \"equity_curve\": equity_df\r\n        }\r\n    \r\n    def _calculate_win_rate(self) -> float:\r\n        \"\"\"计算胜率\"\"\"\r\n        if len(self.trades) < 2:\r\n            return 0\r\n        \r\n        buy_trades = [t for t in self.trades if t[\"action\"] == \"BUY\"]\r\n        sell_trades = [t for t in self.trades if t[\"action\"] == \"SELL\"]\r\n        \r\n        if len(sell_trades) == 0:\r\n            return 0\r\n        \r\n        wins = sum(\r\n            1 for i, sell in enumerate(sell_trades)\r\n            if i < len(buy_trades) and \r\n            sell[\"price\"] > buy_trades[i][\"price\"]\r\n        )\r\n        \r\n        return wins / len(sell_trades) * 100\r\n```\r\n\r\n### 2. Strategy Examples / 策略示例\r\n\r\n```python\r\n# 示例策略：双均线交叉策略\r\nclass DualMovingAverageStrategy:\r\n    \"\"\"双均线策略\"\"\"\r\n    \r\n    def __init__(self, short_window: int = 20, long_window: int = 60):\r\n        self.short_window = short_window\r\n        self.long_window = long_window\r\n    \r\n    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:\r\n        \"\"\"生成交易信号\"\"\"\r\n        signals = pd.Series(index=data.index, dtype=int)\r\n        \r\n        # 计算均线\r\n        ma_short = data[\"close\"].rolling(self.short_window).mean()\r\n        ma_long = data[\"close\"].rolling(self.long_window).mean()\r\n        \r\n        # 金叉买入，死叉卖出\r\n        position = 0\r\n        for i in range(self.long_window, len(data)):\r\n            if ma_short.iloc[i] > ma_long.iloc[i] and position == 0:\r\n                signals.iloc[i] = 1  # 买入\r\n                position = 1\r\n            elif ma_short.iloc[i] < ma_long.iloc[i] and position == 1:\r\n                signals.iloc[i] = -1  # 卖出\r\n                position = 0\r\n        \r\n        return signals\r\n\r\n# RSI均值回归策略\r\nclass RSIMeanReversionStrategy:\r\n    \"\"\"RSI均值回归策略\"\"\"\r\n    \r\n    def __init__(self, period: int = 14, \r\n                 oversold: float = 30, \r\n                 overbought: float = 70):\r\n        self.period = period\r\n        self.oversold = oversold\r\n        self.overbought = overbought\r\n    \r\n    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:\r\n        \"\"\"RSI超卖买入，超买卖出\"\"\"\r\n        delta = data[\"close\"].diff()\r\n        gain = (delta.where(delta > 0, 0)).rolling(self.period).mean()\r\n        loss = (-delta.where(delta < 0, 0)).rolling(self.period).mean()\r\n        \r\n        rs = gain / loss\r\n        rsi = 100 - (100 / (1 + rs))\r\n        \r\n        signals = pd.Series(index=data.index, dtype=int)\r\n        position = 0\r\n        \r\n        for i in range(self.period, len(data)):\r\n            if rsi.iloc[i] < self.oversold and position == 0:\r\n                signals.iloc[i] = 1  # 买入\r\n                position = 1\r\n            elif rsi.iloc[i] > self.overbought and position == 1:\r\n                signals.iloc[i] = -1  # 卖出\r\n                position = 0\r\n        \r\n        return signals\r\n```\r\n\r\n### 3. Monte Carlo Simulation / 蒙特卡洛模拟\r\n\r\n```python\r\nclass MonteCarloSimulation:\r\n    \"\"\"蒙特卡洛模拟\"\"\"\r\n    \r\n    def run_simulation(self, historical_returns: pd.Series,\r\n                      n_simulations: int = 1000,\r\n                      n_periods: int = 252,\r\n                      initial_value: float = 1000000) -> dict:\r\n        \"\"\"\r\n        运行蒙特卡洛模拟\r\n        \"\"\"\r\n        mu = historical_returns.mean()\r\n        sigma = historical_returns.std()\r\n        \r\n        simulations = np.zeros((n_simulations, n_periods))\r\n        simulations[:, 0] = initial_value\r\n        \r\n        for t in range(1, n_periods):\r\n            random_returns = np.random.normal(mu, sigma, n_simulations)\r\n            simulations[:, t] = simulations[:, t-1] * (1 + random_returns)\r\n        \r\n        # 统计结果\r\n        final_values = simulations[:, -1]\r\n        \r\n        percentiles = {\r\n            \"5th\": np.percentile(final_values, 5),\r\n            \"25th\": np.percentile(final_values, 25),\r\n            \"50th\": np.percentile(final_values, 50),\r\n            \"75th\": np.percentile(final_values, 75),\r\n            \"95th\": np.percentile(final_values, 95)\r\n        }\r\n        \r\n        # 概率分析\r\n        prob_loss = (final_values < initial_value).mean() * 100\r\n        \r\n        return {\r\n            \"percentiles\": {k: round(v, 2) for k, v in percentiles.items()},\r\n            \"probability_of_loss\": round(prob_loss, 2),\r\n            \"expected_return\": round(final_values.mean() - initial_value, 2),\r\n            \"var_95\": round(initial_value - percentiles[\"5th\"], 2),\r\n            \"simulations\": simulations\r\n        }\r\n```\r\n\r\n---\r\n\r\n## Quick Command Templates / 快速指令模板\r\n\r\n**回测双均线策略：**\r\n```\r\n回测双均线策略（MA20/MA60）：\r\n- 初始资金：100万\r\n- 回测期：2020-01-01至2025-12-31\r\n- 关注指标：收益率、夏普比率、最大回撤\r\n```\r\n\r\n**蒙特卡洛模拟：**\r\n```\r\n对当前持仓做蒙特卡洛模拟：\r\n- 模拟次数：10000次\r\n- 模拟期限：1年\r\n- 置信区间：95%\r\n```\r\n\r\n---\r\n\r\n## Disclaimer\r\n\r\nThis skill provides backtesting tools for educational and research purposes. Backtesting results do not guarantee future performance. Past performance is not indicative of future results. Algorithmic trading involves substantial risk of loss.\n\nFile v2.0.0:_meta.json\n\n{\n  \"ownerId\": \"kn74e704j3ygjcygnpf02rdvd185js13\",\n  \"slug\": \"security-quant-backtest\",\n  \"version\": \"2.0.0\",\n  \"publishedAt\": 1778509877114\n}","readmeExcerpt":"Skill: Security Quant Backtest Owner: gechengling Summary: AI-powered quantitative backtesting tool for China A-share strategies, supporting design, historical tests, performance attribution, walk-forward analysis, a... Tags: latest:3.0.3, security-quant-backtest:3.0.3 Version history: v3.0.3 | 2026-10-08T05:12:47.389Z | user 3.0.3: content update v3.0.2 | 2026-09-12T07:25:12.439Z | user 内容增强：回测新增指标解读表、未来函数检查清单与成本拆解示","codeSnippets":[],"executableExamples":[],"parameters":null,"dependencies":[],"permissions":[],"extractedFiles":[{"path":"SKILL.md","content":"---\r\nname: Quantitative Backtesting Laboratory\r\nslug: security-quant-backtest\r\ndescription: AI-powered quantitative backtesting laboratory for China A-share — strategy design, historical backtesting with cost/slippage modelling, walk-forward validation, performance attribution and Monte Carlo simulation. Scope: research and validation of a defined trading rule on historical data; not live order routing, not execution advice, not return promises. Keywords: backtest a strategy, walk-forward validation, slippage and cost model, look-ahead bias check, overfitting test, Monte Carlo simulation, performance attribution, A-share, 策略回测, 前向分析, 滑点与成本建模, 未来函数检查, 过拟合检验, 蒙特卡洛模拟, 绩效归因.\r\nversion: \"3.0.3\"\r\n---\r\n\r\n# Quantitative Backtesting Laboratory / 量化回测实验室\r\n\r\n> **English:** AI-powered quantitative backtesting laboratory — covers strategy design, historical backtesting, performance attribution, walk-forward analysis, and Monte Carlo simulation. Built for quant analysts and algorithmic traders.\r\n>\r\n> **中文:** 量化回测实验室——覆盖策略设计、历史回测、绩效归因、前向分析、蒙特卡洛模拟。适用：量化分析师、算法交易者、Python回测开发。\r\n\r\n\r\n## 数据最小化声明与执行边界 / Data Minimisation & Execution Boundary\r\n\r\n**数据最小化前置声明：** 使用本技能时，请只提供回测所必需的输入——标的代码、行情区间、策略规则与参数、费率假设。**不要**粘贴实盘账户信息、真实持仓明细、交易席位与柜台配置、客户身份信息或券商内部的行情源凭证；回测规模请用\"100万初始资金\"这类假设值。\r\n\r\n**保存与预览确认：** 本技能不执行任何保存动作。若你在自己环境中依据本技能生成回测脚本、绩效报告或蒙特卡洛结果，请在落盘或对外展示前**先预览结果、确认无前视偏差且成本口径与实盘一致，再保存或提交**。\r\n\r\n**代码块性质与执行边界**\r\n\r\n| 内容 | 性质 | 谁来执行 |\r\n|------|------|---------|\r\n| `BacktestEngine` 类（撮合、成本、绩效） | 回测引擎的计算口径说明 | 由量化分析师在自己环境中取数并运行；技能不取数、不运行 |\r\n| `DualMovingAverageStrategy` / `RSIMeanReversionStrategy` / `BollingerBreakoutStrategy` | 三条典型策略规则的信号生成示意 | 同上，属教学示意 |\r\n| `MonteCarloSimulation` 类 | 随机路径与分位数统计的算法表达 | 由量化分析师在自己环境中运行 |\r\n| 检查清单、成本表、归因表 | 研究用模板 | 由研究/合规人员在机构流程中落实 |\r\n\r\n**重要：** 上述引擎是**教学示意用的简化实现**，单标的、无涨跌停与停牌约束、无部分成交，实盘前必须在机构自有的回测系统中重建并补齐约束。本技能未配置任何工具调用权限，不执行代码、不读写文件、不访问行情数据源、不下单、不连接交易柜台。回测结果为模拟结果，不构成收益承诺。\r\n\r\n---\r\n\r\n---\r\n\r\n\r\n### 证券监管最新动态 [2026-10-08更新]\r\n\r\n| 动态类型 | 内容摘要 | 影响范围 | 回测侧应对动作 | 责任岗 | 优先级 | 复核频率 | |\r\n|---------|---------|---------|--------------|-------|-------|---|\r\n| 证券监管 | 2026年A股量化资金占比30%-40%，回测需考虑拥挤度因子 | 回测框架需增加拥挤度、压力测试和合规成本模块 | 回测报告增加拥挤度指标与容量估算 | 研究 | 高 | 每季 |\r\n| 证券监管 | 2026年3月量化踩踏事件：回测模型需加入极端行情压力测试 | 回测框架需增加拥挤度、压力测试和合规成本模块 | 回测加入流动性枯竭情景的损失估算 | 研究 | 高 | 每季 |\r\n| 证券监管 | 算法监管趋严，高频策略回测需考虑合规成本 | 回测框架需增加拥挤度、压力测试和合规成本模块 | 成本模型中单列合规与报告成本 | 合规 | 高 | 每季 |\r\n| 程序化交易 | 程序化交易报告与异常交易监控要求细化 | 高频与中高频策略 | 回测中增加报撤单频率与异常交易约束 | 合规 | 中 | 每月 |\r\n| 交易成本 | 佣金、印花税与过户费口径需与实盘一致 | 成本模型、净收益指标 | 成本参数按最新费率更新并标注生效日期 | 研究 | 高 | 每季 |\r\n| 数据质量 | 回测输入数据需可追溯 | 行情与财务数据 | 数据源、复权方式与取数日期须在报告中标注 | 研究 | 高 | 每季 |\r\n| 投资者保护 | 量化产品业绩展示与宣传表述趋严 | 回测业绩对外展示 | 回测结果标注为模拟结果、不构成收益承诺 | 合规 | 高 | 每季 |\r\n| 风控要求 | 策略容量与集中度管理要求提升 | 策略规模与持仓集中度 | 输出策略容量估算与集中度约束 | 风控 | 中 | 每季 |\r\n| 程序化交易 | 2026年10月：程序化交易的报备字段与异常交易指标口径进一步细化 | 高频与中高频策略回测 | 回测中增加报撤单比、瞬时申报速率等约束的模拟与超限拦截 | 合规 | 高 | 每月 |\r\n| 投资者保护 | 2026年四季度初：量化产品业绩展示须同时披露比较基准与模拟/实盘属性 | 回测业绩对外展示材料 | 回测曲线标注\"模拟结果+回测区间+比较基准\"，并披露样本外表现 | 合规 | 高 | 每季 |\r\n\r\n> **数据截止**: 2026-10-08 | 来源：证监会、交易所公开规则、行业公开信息\r\n> *"},{"path":"_meta.json","content":"{\n  \"ownerId\": \"kn74e704j3ygjcygnpf02rdvd185js13\",\n  \"slug\": \"security-quant-backtest\",\n  \"version\": \"3.0.3\",\n  \"publishedAt\": 1791436367389\n}"},{"path":"skill-card.md","content":"## Description:\n\nGuides historical China A-share strategy backtesting with illustrative Python examples, cost modelling, walk-forward validation, performance attribution, and Monte Carlo simulation.\n\nThis skill is ready for commercial/non-commercial use.\n\n## Publisher:\n\n[gechengling](https://clawhub.ai/user/gechengling)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nQuant analysts and developers use this skill to examine defined trading rules against their own historical China A-share data, including trading costs, out-of-sample performance, and simulation uncertainty. It does not supply market data or execute trades.\n\n### Deployment Geography for Use:\n\nGlobal (China A-share market focus)\n\n## Known Risks and Mitigations:\n\nRisk: Simplified sample code and simulated returns may misrepresent real trading outcomes.\n\nMitigation: Validate results in an independently tested backtesting system with realistic costs, execution constraints, and out-of-sample checks before relying on them.\n\nRisk: Outdated market or regulatory assumptions may lead to misleading conclusions.\n\nMitigation: Independently verify applicable rules, rates, and market data before using the analysis.\n\nRisk: Real account, client, position, or broker data may expose sensitive information.\n\nMitigation: Use hypothetical amounts and omit real account data, client identities, broker credentials, and live positions.\n\n## Reference(s):\n\n- [ClawHub skill listing](https://clawhub.ai/gechengling/skills/security-quant-backtest)\n\n## Skill Output:\n\n**Output Type(s):** [Guidance, Analysis, Code]\n\n**Output Format:** [Markdown with illustrative Python code and tables]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [Educational examples; no built-in data access or trade execution.]\n\n## Skill Version(s):\n\n3.0.3 (source: skill frontmatter and server release)\n\n## Ethical Considerations:\n\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment."}],"languages":[],"docsSourceLabel":"CLAWHUB","editorialOverview":"AI-powered quantitative backtesting tool for China A-share strategies, supporting design, historical tests, performance attribution, walk-forward analysis, a... Skill: Security Quant Backtest Owner: gechengling Summary: AI-powered quantitative backtesting tool for China A-share strategies, supporting design, historical tests, performance attribution, walk-forward analysis, a... Tags: latest:3.0.3, security-quant-backtest:3.0.3 Version history: v3.0.3 | 2026-10-08T05:12:47.389Z | user 3.0.3: content update v3.0.2 | 2026-09-12T07:25:12.439Z | user 内容增强：回测新增指标解读表、未来函数检查清单与成本拆解示","editorialQuality":{"score":100,"threshold":65,"status":"ready","wordCount":932,"uniquenessScore":54,"reasons":[]}},"media":{"evidence":{"source":"no-media","verified":false,"confidence":"low","updatedAt":"2026-10-10T18:43:06.419Z","emptyReason":"No screenshots, media assets, or demo links are available."},"primaryImageUrl":null,"mediaAssetCount":0,"assets":[],"demoUrl":null},"ownerResources":{"evidence":{"source":"unclaimed","verified":false,"confidence":"low","updatedAt":"2026-10-10T18:43:06.419Z","emptyReason":"This page has not been claimed by the agent owner."},"hasCustomPage":false,"customPageUpdatedAt":null,"customLinks":[],"structuredLinks":{"docsUrl":null,"demoUrl":null,"supportUrl":null,"pricingUrl":null,"statusUrl":null},"customPage":null},"relatedAgents":{"evidence":{"source":"protocol-neighbors","verified":false,"confidence":"medium","updatedAt":"2026-10-10T21:40:03.507Z","emptyReason":null},"items":[{"id":"8ebccd8e-3863-4187-8355-c3f14e1f9edf","entityType":"agent","canonicalPath":"/agent/iofficeai-aionui","slug":"iofficeai-aionui","name":"AionUi","description":"Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!","url":"https://github.com/iOfficeAI/AionUi","homepage":"https://www.aionui.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-10-09T19:11:12.944Z","createdAt":"2026-02-25T03:38:16.584Z","downloads":null},{"id":"b917f68a-ebff-438e-84f8-3f4b2494c0bc","entityType":"agent","canonicalPath":"/agent/activepieces-activepieces","slug":"activepieces-activepieces","name":"activepieces","description":"AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents","url":"https://github.com/activepieces/activepieces","homepage":"https://www.activepieces.com","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-15T02:22:12.426Z","createdAt":"2026-02-25T03:38:12.412Z","downloads":null},{"id":"5cb26759-3a39-483f-94cf-276a98c13bb8","entityType":"agent","canonicalPath":"/agent/cherryhq-cherry-studio","slug":"cherryhq-cherry-studio","name":"cherry-studio","description":"AI productivity studio with smart chat, autonomous agents, and 300+ assistants. Unified access to frontier LLMs","url":"https://github.com/CherryHQ/cherry-studio","homepage":"https://cherry-ai.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-11T14:38:40.986Z","createdAt":"2026-02-25T03:38:19.379Z","downloads":null},{"id":"6f6582d0-5d76-4f0f-b81d-86520247950b","entityType":"agent","canonicalPath":"/agent/copilotkit-copilotkit","slug":"copilotkit-copilotkit","name":"CopilotKit","description":"The Frontend for Agents & Generative UI. React + Angular","url":"https://github.com/CopilotKit/CopilotKit","homepage":"https://docs.copilotkit.ai","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-03-25T09:50:57.846Z","createdAt":"2026-02-25T03:39:14.617Z","downloads":null}],"links":{"hub":"/agent","source":"/agent/source/clawhub","protocols":[{"label":"OpenClaw","href":"/agent/protocol/openclew"}]}}}