企业官网建设流程全解析

如果你想在量化交易里少写一点代码，多留一点时间看行情，这个方向值得认真看一下：模板、指标、提示词，全部交给 AI 生成，你只描述需求。这篇文章不聊玄乎的“AI 预测涨停”，只聊一条能落地的工作流——用大模型把量化交易里最耗时间的模板搭建、指标编写、回测脚本和提示词设计自动化，让你从“写代码的人”变成“提需求的人”。

这套玩法的核心可以拆成四句话：

• 指标公式不用手写，让 AI 根据自然语言描述生成。
• 回测模板不用每次重搭，用提示词让 AI 按固定结构输出。
• 策略框架不用从零写，用模板字符串和参数化设计批量复用。
• 你只负责描述交易想法和控制风险，剩下的交给模型。

文中会给出完整的提示词模板、指标代码生成示例、回测框架示例、批量任务设计思路，以及接入 LLM API 的通用调用方式。无论你是刚接触量化交易，还是已经折腾了不少指标源码，这套流程都能帮你把重复劳动压下去。

先说明一点：AI 生成策略代码不等于自动赚钱。量化交易的核心永远是逻辑、风控和数据质量，AI 只是把“从想法到代码”这一段路的效率提上来。下面的内容按“能力速览 -> 场景边界 -> 工作流设计 -> 环境准备 -> 提示词模板 -> 指标代码生成 -> 回测框架 -> 批量任务 -> 性能观察 -> 问题排查 -> 最佳实践”展开，你可以直接跳到最关心的部分。

1. 核心能力速览

从材料看，这个方向强调的是“一句话需求 -> 自动生成整套模板、指标、提示词”，所以下面所有示例都围绕这条链路来设计。

2. 适用场景与使用边界

这套方法最适合下面几种情况：

• 你有一个交易想法，但不确定用哪个指标，或者不知道怎么把想法写成代码。
• 你想快速对比不同参数的均线策略、MACD 策略、布林带策略，不想每次改代码。
• 你需要批量生成多个股票或多种周期的回测模板，手工写太慢。
• 你想把常用指标整理成一套可复用的模板库，方便后续直接调用。
• 你正在做量化策略研究，希望把“想法验证”的周期从几天压缩到几个小时。

不适合的场景也很明显：

• 不要指望 AI 生成一个策略就能稳定盈利，回测结果需要严格验证。
• 不要用 AI 生成的高频交易代码直接上实盘，延迟、滑点和风控都没验证。
• 不要忽略数据质量，AI 生成的代码跑出来的结果只能作为研究参考。

使用边界和合规方面，需要特别注意：

• 涉及股票、期货等真实交易数据时，确认数据来源的授权。
• AI 生成的模板和代码可能存在逻辑漏洞，实盘前必须人工复核。
• 不要把策略信号视为投资建议，相关决策风险自负。
• 如果使用在线 LLM API，避免提交未脱敏的隐私数据和商业敏感信息。

3. 工作流设计：从一句话到可用代码

在动手装环境之前，先把整条工作流的结构理清楚。只有先把流程拆开，后面将每个环节改成提示词模板时才不会乱。

更完整的流程设计如下。

输入：一句话交易需求 -> AI 需求解析（提示词模板 A） -> 输出：策略逻辑、指标清单、参数范围 -> AI 生成指标公式（提示词模板 B） -> 输出：通达信公式或 Python 指标函数 -> AI 生成回测脚本（提示词模板 C） -> 输出：标准 Python 回测脚本 -> 批量参数扫描（模板字符串 + 参数配置文件） -> 输出：多组回测结果汇总 -> 人工复核：逻辑、风险、收益指标

这个流程有四个关键节点，每一个都需要对应的提示词模板来约束输出格式。

第一，需求解析。用户说的是“我想做一只股票的突破策略，突破 20 日高点就买入，跌破 10 日低点就卖出”，AI 需要把它拆成：入场条件、出场条件、参考指标、参数范围。

第二，指标生成。根据需求解析结果，AI 生成对应语言的指标代码。如果你在通达信里用，生成 THS/通达信公式；如果你在 Python 里回测，生成 pandas 向量化代码。

第三，回测脚本生成。这个环节最容易出问题，因为回测框架不同，代码结构差异很大。所以要让 AI 输出固定模板，比如基于 backtrader 的格式，字段名和函数名全部统一。

第四，批量参数扫描。把指标参数范围用 JSON 或 YAML 配置化，用模板字符串填充回测脚本，批量执行。

后面几章会分别给出这些环节的具体提示词和代码示例。

4. 环境准备与前置条件

这一节不绑定某个具体项目，但你照着做，就能搭出一套可以运行这套工作流的最小环境。

4.1 Python 环境

建议使用 Python 3.9 以上版本，推荐用 conda 或 venv 创建独立环境，避免影响其他项目。

# 创建独立环境 conda create -n quant-ai python=3.10 -y conda activate quant-ai # 安装基础依赖 pip install pandas numpy matplotlib pip install backtrader

如果你的回测偏向量化，也可以安装 vectorbt：

pip install vectorbt

4.2 LLM 模型接入

这里有两种选择。

第一种是调用在线 API，只需要安装对应的 SDK 或直接用 requests 调 HTTP 接口，不要求本地显卡。要准备好 API Key，并在代码里配置好 base_url、model 名称和请求超时时间。

第二种是本地部署开源模型，例如 Qwen2.5-Coder、DeepSeek-Coder 等。本地部署的好处是数据不出内网，但需要根据模型规格准备显卡，显存占用因模型大小而异，具体要以本机实测为准。

本文示例以在线 API 为默认方式，代码里有明确的请求参数，你可以替换成自己的 base_url 和 model。

4.3 数据准备

回测至少需要历史 K 线数据。常见的数据字段包括：date、open、high、low、close、volume。

可以用 akshare 或 tushare 获取数据，注意遵守数据源的使用条款。

pip install akshare

获取数据的示例：

import akshare as ak # 获取 A 股日线数据，代码需要按实际标的调整 df = ak.stock_zh_a_hist( symbol="000001", period="daily", start_date="20230101", end_date="20241231", adjust="qfq" ) print(df.head())

实际使用时，请根据数据源接口文档调整字段名，并确认数据授权范围。

5. 提示词模板设计：让 AI 按格式输出

这一章是整个工作流的核心。提示词模板设计的目标只有一个：让 AI 的输出稳定、结构化、可直接入库。如果提示词写得模糊，AI 输出就会五花八门，后面的批量任务也就无从谈起。

5.1 需求解析提示词模板

这个模板负责把用户的一句话交易想法，拆成结构化的策略描述。

你是一名量化策略研究员。请把用户输入的交易想法拆解为结构化策略描述。 输出格式要求： 1. 策略名称：不超过 10 个字 2. 交易标的：默认 A 股日线，可补充 3. 入场条件：明确给出条件表达式 4. 出场条件：明确给出条件表达式 5. 参考指标：列出需要用到的指标 6. 参数范围：每个参数给出可选范围 7. 风险提示：用一句话说明该策略的主要风险 用户输入：{user_input} 请严格按照 JSON 格式输出，不要输出额外说明。

对应的调用代码：

import json import requests def parse_requirement(user_input, api_url, api_key, model): prompt = f""" 你是一名量化策略研究员。请把用户输入的交易想法拆解为结构化策略描述。 输出格式要求： 1. 策略名称：不超过 10 个字 2. 交易标的：默认 A 股日线，可补充 3. 入场条件：明确给出条件表达式 4. 出场条件：明确给出条件表达式 5. 参考指标：列出需要用到的指标 6. 参数范围：每个参数给出可选范围 7. 风险提示：用一句话说明该策略的主要风险 用户输入：{user_input} 请严格按照 JSON 格式输出。 """ payload = { "model": model, "messages": [ {"role": "system", "content": "你是量化交易助手，只输出结构化 JSON。"}, {"role": "user", "content": prompt} ], "temperature": 0.2, "max_tokens": 1024 } headers = {"Authorization": f"Bearer {api_key}"} resp = requests.post(api_url, json=payload, headers=headers, timeout=120) resp.raise_for_status() content = resp.json()["choices"][0]["message"]["content"] return json.loads(content)

这里把 temperature 设成 0.2，目的是减少输出随机性。量化交易场景里，代码和配置必须确定性高，不要像聊天那样放飞自我。

5.2 指标生成提示词模板

这个模板负责把策略描述里的指标需求，转换成 Python 向量化代码。需要注意，量化指标实现方式很多，AI 容易写出风格不一的代码，所以要强制规定输入输出格式。

你是量化指标代码生成器。根据用户给出的指标描述，生成 pandas 向量化代码。 要求： 1. 输入 DataFrame 必须包含 high, low, close, volume 列。 2. 输出必须是一个函数，函数名称为 generate_indicator(df, params)。 3. 指标列命名规范：指标名称_参数值，例如 SMA_20。 4. 不允许使用循环，必须使用 pandas 或 numpy 向量化计算。 5. 代码中不能包含中文注释。 6. 返回添加指标列后的 DataFrame。 指标描述：{indicator_description} 参考参数：{params}

这个模板有三个关键约束：

• 必须使用向量化计算，避免 for 循环，否则回测数据量大时性能会很难看。
• 输出必须是一个固定函数名，这样批量调用时可以统一入口。
• 参数必须通过 params 传入，而不是硬编码在函数里，否则无法做参数扫描。

5.3 回测脚本提示词模板

回测脚本是所有环节里最容易出错的，因为不同框架的写法差异很大。建议选一个固定框架，这里以 backtrader 为例。

你是 Python 回测脚本生成器。请根据策略描述，生成一个基于 backtrader 的完整回测脚本。 要求： 1. 使用 backtrader 框架，导入方式统一为 import backtrader as bt。 2. 策略类名固定为 MyStrategy(bt.Strategy)。 3. 输入数据通过 CSV 文件加载，列名包含 date, open, high, low, close, volume。 4. 打印回测结果时，至少包含：总收益率、年化收益率、最大回撤、夏普比率、交易次数。 5. 主程序中通过 cerebro.addstrategy(MyStrategy, params_dict) 传入参数。 6. 只输出 Python 代码，不需要额外解释。 策略描述：{strategy_description} 参数配置：{params_dict}

用固定的类名和固定的数据加载方式，最大的好处是后面做批量任务时，可以批量替换参数、批量执行脚本、批量解析输出。

5.4 提示词模板的迭代规律

第一批提示词生成的结果大概率不完美。这不是模型不行，而是提示词约束不够。如果发现以下问题，对应调整：

• 输出格式不稳定：在提示词里增加“必须输出 JSON / 只输出 Python 代码 / 不要输出额外说明”等强约束。
• 指标写法不统一：在要求里明确“函数名固定为 generate_indicator”和“必须向量化”。
• 参数扫描困难：在参数部分增加 JSON 示例，让 AI 照抄结构。
• 回测结果无法解析：要求回测脚本把结果输出为 JSON 或固定文本格式，而不是一长串日志。

记住一个原则：提示词模板是一个持续迭代的资产，不是一次写好的。每跑一轮批量任务，就把不稳定的点回填到模板里，越用越顺手。

6. 指标代码生成与验证

用自然语言让 AI 生成指标代码，是本工作流最直观的价值点。下面用一个双均线策略作为例子，展示从描述到代码再到验证的完整过程。

6.1 输入描述

假设你的需求是：

生成一个双均线指标，短期均线 10 日，长期均线 30 日，金叉买入，死叉卖出。

6.2 AI 输出的指标代码

按上面的指标生成提示词模板，AI 输出可能如下。注意，这是典型输出，实际生成时可能略有差异，需要根据模板约束微调。

import pandas as pd import numpy as np def generate_indicator(df: pd.DataFrame, params: dict) -> pd.DataFrame: short_window = params.get("short_window", 10) long_window = params.get("long_window", 30) df["SMA_short"] = df["close"].rolling(window=short_window).mean() df["SMA_long"] = df["close"].rolling(window=long_window).mean() df["signal"] = np.where(df["SMA_short"] > df["SMA_long"], 1, 0) df["signal"] = df["signal"].diff().fillna(0) return df

这个函数输出三列：短期均线、长期均线、信号列。signal 为 1 表示金叉买入点，为 -1 表示死叉卖出点。用 diff() 把持仓状态转换成交易信号，这样回测引擎可以直接使用。

6.3 指标验证流程

拿到指标代码后，不要直接上回测，先验证指标本身是否正确。

import pandas as pd # 构造一小段测试数据 test_data = { "date": pd.date_range("2024-01-01", periods=30, freq="D"), "open": range(100, 130), "high": range(101, 131), "low": range(99, 129), "close": range(100, 130), "volume": [1000000] * 30 } df = pd.DataFrame(test_data) # 调用 AI 生成的函数 params = {"short_window": 5, "long_window": 10} result = generate_indicator(df, params) print(result[["date", "close", "SMA_short", "SMA_long", "signal"]])

重点检查三点：

• 金叉位置是否出现在短线均线上穿长线均线的位置。
• signal 列的值是否为 1、-1、0 三种状态，而不是连续出现多个 1。
• 均线最后一行的数值是否等于对应窗口的最后 N 日均值。

如果这三项都没问题，指标代码基本可以放心使用。

6.4 批量生成指标

当你有几十个指标候选要对比时，可以写一个批量脚本，循环调用 LLM 接口，把生成的代码保存到指定目录。

import os indicator_list = [ {"name": "dual_ma", "desc": "双均线指标，金叉买入，死叉卖出"}, {"name": "rsi_reverse", "desc": "RSI 超买超卖，低于30买入，高于70卖出"}, {"name": "boll_break", "desc": "布林带突破，突破上轨买入，跌破中轨卖出"}, ] output_dir = "./generated_indicators" os.makedirs(output_dir, exist_ok=True) for item in indicator_list: prompt = build_indicator_prompt(item["desc"], {"short_window": 10, "long_window": 30}) code = call_llm(prompt, api_url, api_key, model) file_path = os.path.join(output_dir, f"{item['name']}.py") with open(file_path, "w", encoding="utf-8") as f: f.write(code) print(f"generated: {file_path}")

批量生成之后，一定要做自动语法检查和基础测试，不要只生成不验证。可以再用一次 AI 或写一个简单的 import 检查脚本来批量验证语法正确性。

import py_compile for item in ["dual_ma", "rsi_reverse", "boll_break"]: file_path = f"./generated_indicators/{item}.py" try: py_compile.compile(file_path, doraise=True) print(f"{item}: syntax ok") except Exception as e: print(f"{item}: syntax error -> {e}")

7. 模板化的回测框架

指标只是策略的一部分，完整的回测框架同样可以让 AI 生成，然后模板化复用。这里给出一个最小可用的 backtrader 模板，适合做单标的日线策略回测。

7.1 回测脚本模板

把 AI 生成的回测脚本整理成下面的模板结构。以后每次跑新策略，只需要替换指标函数、参数配置和数据文件。

import backtrader as bt import pandas as pd import json import sys class MyStrategy(bt.Strategy): params = ( ("short_window", 10), ("long_window", 30), ("printlog", True), ) def __init__(self): self.sma_short = bt.indicators.SMA( self.data.close, period=self.params.short_window ) self.sma_long = bt.indicators.SMA( self.data.close, period=self.params.long_window ) self.crossover = bt.indicators.CrossOver(self.sma_short, self.sma_long) def next(self): if self.crossover > 0: self.buy() elif self.crossover < 0: self.sell() def stop(self): # 输出回测核心指标 result = { "total_return": self.broker.getvalue() / 100000.0 - 1.0, "trade_count": len(self.stats.trade.count), } print(json.dumps(result, ensure_ascii=False)) def run_backtest(csv_path, params_dict): cerebro = bt.Cerebro() df = pd.read_csv(csv_path, parse_dates=["date"]) data = bt.feeds.PandasData( dataname=df, datetime="date", open="open", high="high", low="low", close="close", volume="volume", ) cerebro.adddata(data) cerebro.addstrategy(MyStrategy, **params_dict) cerebro.broker.setcash(100000.0) cerebro.broker.setcommission(commission=0.0003) cerebro.run() if __name__ == "__main__": csv_path = sys.argv[1] params_json = sys.argv[2] params_dict = json.loads(params_json) run_backtest(csv_path, params_dict)

这个模板用了 JSON 来传递参数，好处是后面做批量参数扫描时，每一条命令都是一个独立的任务，互不干扰。

7.2 运行回测

python backtest_template.py ./data/000001.csv '{"short_window": 5, "long_window": 20}'

执行后，回测脚本会在控制台输出 JSON 格式的结果。输出结果应该包含总收益率、交易次数等关键指标，方便后续批量汇总。

7.3 多标的批量回测

有了固定模板，批量回测就变成一个简单的遍历任务。用目录和配置文件把数据、参数和结果分开管理。

import subprocess import json import os data_dir = "./data" param_dir = "./params" result_dir = "./results" os.makedirs(result_dir, exist_ok=True) strategies = [ { "name": "dual_ma_5_20", "csv": f"{data_dir}/000001.csv", "params": {"short_window": 5, "long_window": 20}, }, { "name": "dual_ma_10_30", "csv": f"{data_dir}/000001.csv", "params": {"short_window": 10, "long_window": 30}, }, { "name": "dual_ma_20_60", "csv": f"{data_dir}/000001.csv", "params": {"short_window": 20, "long_window": 60}, }, ] for s in strategies: params_json = json.dumps(s["params"]) cmd = [ "python", "backtest_template.py", s["csv"], params_json ] proc = subprocess.run(cmd, capture_output=True, text=True, timeout=300) # 输出转存为 JSON 文件，保留 stdout 和 stderr 日志 result_file = os.path.join(result_dir, f"{s['name']}.json") with open(result_file, "w", encoding="utf-8") as f: f.write(proc.stdout) print(f"{s['name']}: done")

多标的批量回测的关键在于参数的 JSON 化。每个任务是独立进程，即使某个标的数据异常报错，也不会影响其他任务。

8. LLM API 接入与批量任务设计

如果你要做更大规模的“一句话生成策略 -> 自动回测 -> 输出结果”流水线，光靠手动跑脚本不够，需要把 LLM API 和回测引擎串起来。

8.1 LLM API 通用调用封装

前面的需求解析代码已经展示了最基本的调用方式。实际使用中，建议封装一个通用函数，用来处理普通的文本生成请求。下面给出一个更通用的封装示例。

import requests import json class LLMClient: def __init__(self, api_url, api_key, model, temperature=0.2): self.api_url = api_url self.api_key = api_key self.model = model self.temperature = temperature def chat(self, system_prompt, user_prompt, max_tokens=2048): payload = { "model": self.model, "messages": [ {"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}, ], "temperature": self.temperature, "max_tokens": max_tokens, } headers = {"Authorization": f"Bearer {self.api_key}"} resp = requests.post(self.api_url, json=payload, headers=headers, timeout=180) resp.raise_for_status() data = resp.json() return data["choices"][0]["message"]["content"]

使用示例：

client = LLMClient( api_url="https://your-llm-endpoint/v1/chat/completions", api_key="your-api-key", model="your-model-name", temperature=0.2, ) parse_output = client.chat( system_prompt="你是量化交易助手，只输出结构化 JSON。", user_prompt="我想做双均线策略，短期均线上穿长期均线买入，下穿卖出。" ) print(parse_output)

注意，这里的 api_url、api_key、model 都需要按你的实际服务替换。不同平台的请求格式可能略有差异，如果返回结构不对，看返回 message 字段的层级。

8.2 批量任务队列设计

批量任务不只是“多跑几个脚本”，还要考虑失败重试、结果汇总和中间状态记录。建议用 JSON 文件描述任务清单，每个任务包含：策略名称、数据路径、参数配置、状态、重试次数。

{ "tasks": [ { "id": "task_001", "name": "dual_ma_5_20", "data_path": "./data/000001.csv", "params": { "short_window": 5, "long_window": 20 }, "status": "pending", "retry_count": 0 }, { "id": "task_002", "name": "rsi_15_70", "data_path": "./data/600000.csv", "params": { "rsi_period": 15, "buy_threshold": 30, "sell_threshold": 70 }, "status": "pending", "retry_count": 0 } ] }

执行时按状态轮询，失败的任务累计重试次数，超过 3 次后被标记为 failed，不影响后续任务。

import time def run_task(task): print(f"running {task['id']} - {task['name']}") # 这里调用指标生成和回测脚本 # 执行成功返回 True，失败返回 False return True def process_queue(task_file): with open(task_file, "r", encoding="utf-8") as f: queue = json.load(f) for task in queue["tasks"]: if task["status"] != "pending": continue try: success = run_task(task) task["status"] = "done" if success else "failed" except Exception as e: task["retry_count"] += 1 if task["retry_count"] >= 3: task["status"] = "failed" else: task["status"] = "pending" print(f"task {task['id']} error: {e}") time.sleep(1) with open(task_file, "w", encoding="utf-8") as f: json.dump(queue, f, ensure_ascii=False, indent=2)

批量任务设计的核心原则：状态要持久化、失败要可重试、日志要完整。否则跑几千个任务，一旦中途断掉，很难定位问题。

8.3 结果汇总

批量任务执行完后，把每个任务输出的 JSON 合并成一张总表。

import pandas as pd import glob import json files = glob.glob("./results/*.json") rows = [] for file in files: with open(file, "r", encoding="utf-8") as f: data = json.load(f) rows.append({ "strategy": file.split("/")[-1].replace(".json", ""), "total_return": data.get("total_return"), "trade_count": data.get("trade_count"), }) df = pd.DataFrame(rows) df.sort_values("total_return", ascending=False, inplace=True) print(df.head(10)) df.to_csv("./results/summary.csv", index=False, encoding="utf-8-sig")

汇总表可以直接用于初步筛选策略。注意，这里只适合做研究阶段的横向对比，不能直接当作实盘依据。

9. 资源占用与性能观察

“AI 量化交易”里最容易被忽略的是性能问题。这里的性能不单指 GPU 显存，还包括 LLM API 延迟、指标计算速度和回测耗时。

9.1 LLM 调用延迟

如果用在线 API，一次需求解析或代码生成请求通常需要几秒到几十秒，取决于模型规模和输入长度。如果要批量生成几百个指标，建议：

• 增加并发，但要控制并发数，避免触发限流。
• 加入指数退避重试，遇到限流时等待后重试。
• 把生成结果缓存到本地，避免重复请求消耗额度。

import time import random def call_with_retry(client, system_prompt, user_prompt, max_retries=3): for attempt in range(max_retries): try: return client.chat(system_prompt, user_prompt) except Exception as e: wait_time = 2 ** attempt + random.uniform(0, 1) print(f"retry {attempt + 1} after {wait_time:.1f}s, error: {e}") time.sleep(wait_time) raise RuntimeError("LLM call failed after retries")

9.2 指标计算性能

AI 生成的指标代码如果用了循环，性能会很差。回测框架里批量跑几百个股票时，每一行慢代码都会被放大。检查指标代码时重点关注：

• 是否使用了 pandas rolling、numpy.where 等向量化方法。
• 是否在函数内部重复计算了不需要的列。
• 是否把数据加载放在循环内部，导致反复 I/O。

9.3 本机部署模型的显存占用

如果你不用在线 API，而是本地部署开源模型，需要重点观察显存占用。显存占用随模型参数量、量化精度和输入长度变化：

• 7B 级别模型，量化后通常需要 6G 到 8G 显存，具体以本机实际为准。
• 14B 级别模型，量化后通常需要 12G 到 16G 显存。
• 如果显存不够，可以尝试加载更小的量化版本，或者把部分层放到 CPU。
• 生成代码任务比普通对话更吃上下文窗口，输入提示词越长，KV Cache 占用的显存越多。

建议用nvidia-smi观察显存变化。

watch -n 1 nvidia-smi

如果本地显存紧张，最简单的方法就是切换到 API 模式，把显存压力转移到服务端。

9.4 回测耗时和磁盘空间

回测耗时主要取决于数据量、策略复杂度和参数量。一般日线级别的单标的回测在几秒内完成，分钟线或全市场扫描需要更长时间。回测过程中生成的中间数据、日志和结果文件也要预留磁盘空间，建议输出目录按日期分目录管理。

10. 常见问题与排查方法

这套工作流看起来简单，真正跑起来会遇到各种问题。下面整理几个高频问题。

除了表格中的问题，还有一个经常被忽略的坑：提示词模板和代码模板版本不一致。比如你更新了回测模板的字段名，但旧的提示词还在按老格式生成代码，结果就是批量任务大面积报错。建议把提示词模板和代码模板放在同一个仓库里，用 Git 做版本管理，更新时同步提交。

11. 最佳实践与使用建议

11.1 先小后大，先单后批

第一次测试时，不要一上来就跑全市场批量任务。先用一个标的、一组参数、一个简单的双均线策略，把整条链路跑通。确认以下环节都没问题后，再扩展：

• LLM 输出能稳定解析成 JSON。
• 指标代码能通过语法检查和基础验证。
• 回测模板能正确读入 CSV、输出结果。
• 批量任务的重试和日志机制正常。

11.2 建立三个独立目录

建议把输入、输出和中间代码分开管理，避免文件混杂。

project/ ├── data/ # 原始行情数据，按标的和周期分目录 ├── generated/ # AI 生成的指标代码和回测脚本 ├── results/ # 回测结果 JSON 和汇总表 ├── templates/ # 提示词模板和代码模板 ├── config/ # 批量任务配置 └── logs/ # 运行日志

11.3 用模板字符串管理参数

批量任务里最容易出错的是参数拼接。建议用 JSON 或 YAML 管理参数，避免在代码里硬编码。

# config/dual_ma.yaml data_dir: "./data" result_dir: "./results" strategies: - name: dual_ma_5_20 csv: "000001.csv" params: short_window: 5 long_window: 20 - name: dual_ma_10_30 csv: "000001.csv" params: short_window: 10 long_window: 30

11.4 人工复核不可省略

AI 生成的指标和策略代码，跑出来的收益曲线再漂亮，也一定要人工复核以下几点：

• 策略逻辑是否符合原始想法。
• 是否存在未来函数，比如用当天收盘价计算信号后当天买入。
• 交易成本、滑点和涨跌停限制是否考虑。
• 参数是否存在过拟合，换一段数据或换几个标的还能不能跑。
• 数据来源是否合规，是否涉及未授权数据。

11.5 合规和安全提醒

再次强调几条底线：

• AI 生成策略仅用于研究和技术学习，不构成投资建议。
• 涉及真实资金交易前，必须在仿真环境充分验证，并明确风险责任。
• 如果处理的是非公开数据或个人信息，先确认隐私边界和授权。
• 在线 API 调用时，不要在提示词中提交未脱敏的隐私信息和商业敏感内容。

12. 总结与下一步

这套“AI 量化交易新玩法”的价值，不在于让 AI 帮你预测行情，而在于把量化研究里最烦琐的三个环节自动化：写指标、搭回测、做参数扫描。你从写代码的人，变成提需求和审结果的人，工作方式会发生明显变化。

其中最值得先尝试的，是双均线策略的完整链路：用一句话描述策略 -> AI 生成指标代码 -> 用模板回测 -> 批量跑几组参数对比。这个链路覆盖了所有核心环节，而且工作量小，最适合用来验证整套流程是否顺滑。

最容易踩的坑有两个：一是提示词模板约束不够，导致 AI 输出格式不稳定；二是批量任务没有日志和重试机制，跑到一半断掉后无法续跑。这两点在前期就要做好设计。

后续如果想继续深入，可以从这几个方向扩展：

• 把提示词模板和回测模板封装成一个内部工具，支持 Web 界面或命令行交互。
• 加入更多的策略模板，比如 RSI 超买超卖、布林带突破、海龟交易法则。
• 接入分钟级数据，测试更高频策略的可行性。
• 用 LLM 自动分析回测结果，输出策略诊断报告。
• 把批量任务队列接入消息队列，比如 Redis 或 Celery，支持更复杂的调度。

建议先把文章里的最小链路跑通，保存一套能稳定运行的提示词模板和代码模板。后续再逐步扩展，效率会越来越高。