Few-Shot

Prompt工程不是玄学 很多人认为Prompt工程就是"试不同的话术看哪个效果好"。这是误解。好的Prompt工程是系统工程——有方法论、有评估标准、有优化路径。 第一原则：明确目标 写Prompt之前先问自己：我要模型输出什么？质量的衡量标准是什么？ 常见任务类型 信息提取：从文本中提取结构化数据 内容生成：生成文本/代码/分析报告 推理决策：逻辑推理/分类/判断 格式转换：翻译/摘要/格式化 每种类型的Prompt设计策略完全不同。信息提取追求精确，内容生成追求创意，推理决策追求严谨。 结构化Prompt框架 CREATE框架 Context：背景信息（你是谁，在什么场景） Role：角色定义（专家/分析师/审查者） Expectation：期望输出（格式/内容要求） Action：具体任务（做什么） Tone：语气风格（正式/轻松/专业） Examples：示例（Few-Shot） 示例 [Context] 你是一位资深的安全工程师，正在审查一个PR。 [Role] 你以严谨著称，不放过任何安全风险。 [Action] 审查以下代码变更，识别： 1. 潜在的安全漏洞（SQL注入、XSS、CSRF等） 2. 敏感信息泄露 3. 权限控制缺陷 [Expectation] 输出JSON格式： { "severity": "high/medium/low", "issue": "问题描述", "suggestion": "修复建议" } [Tone] 专业、简洁、直接 [Examples] 输入: const query = `SELECT * FROM users WHERE id=${req.query.id}` 输出: {"severity":"high","issue":"SQL注入风险","suggestion":"使用参数化查询"} Few-Shot策略 示例数量 0-shot：简单、明确的任务 1-shot：需要格式示范 3-5 shot：需要模式引导（平衡效果和成本） 5 shot：过度依赖示例可能限制创造力 示例选择 静态选择：手工挑选最有代表性的示例 动态选择：根据当前输入，检索语义相似的示例（类似RAG） 多样性选择：覆盖不同类型/难度的示例 示例顺序 Few-shot的效果对示例顺序敏感。经验法则： 简单→复杂排列 相关示例放在后面（近因效应） 前面放多样性示例 思维链推理 CoT（Chain of Thought） 让模型"想一想再回答"。将推理过程显式化： Q: 一个商店有23个苹果，卖出17个，又进了12个，还有多少？ A: 让我们一步步算： 1. 初始有23个苹果 2. 卖出17个：23 - 17 = 6 3. 又进了12个：6 + 12 = 18 答案：18个 适用场景 CoT对以下场景特别有效： ...

从Zero-shot到Few-shot：提示工程的进化 提示工程是大模型时代最具性价比的技术投资。一个精心设计的prompt可以让中等模型的表现超越更大模型在糟糕prompt下的表现。从Zero-shot到Few-shot再到各种高级提示技术，这一领域的进化速度令人瞩目。 Zero-shot：最简形式 Zero-shot是提示工程的原点——不给任何示例，直接让模型回答问题。GPT-3论文最令人震撼的发现就是大模型在zero-shot设置下展现出惊人的能力。 Zero-shot适用于简单的事实问答、文本分类等任务。“判断以下评论是正面还是负面：这家餐厅服务很差”——对于这种简单任务，zero-shot就够了。 但zero-shot在复杂任务上往往不稳定。当你要求模型按特定格式输出、执行多步推理、或遵循复杂的业务规则时，没有示例引导的输出常常偏离预期。 Few-shot：示例驱动的学习 Few-shot通过在prompt中提供少量示例来引导模型的行为。这些示例起到了"格式模板"和"推理模式"的双重作用。 Few-shot的效果提升是显著的。在我们的实践中，对于一个信息抽取任务，zero-shot的F1为0.65，而5-shot的F1提升到0.82。提升不仅来自格式规范，更来自示例中隐含的推理模式。 示例选择的艺术 Few-shot的关键问题是：选择哪些示例？早期实践者随意挑选几个，但很快发现示例选择对效果影响巨大。几个原则： 多样性优先：示例应覆盖不同的输入模式，而非相似案例的重复。多样性帮助模型泛化，而非记忆特定模式。 难度代表性：示例应包含容易和困难的案例。全选简单案例会让模型低估任务难度，全选困难案例则可能让模型过度复杂化简单输入。 动态选择：根据当前输入动态选择最相关的示例，而非固定使用同一组。这就是Dynamic Few-shot的思路——用检索器为每个输入找到最相似的k个示例。 思维链：推理的飞跃 Chain-of-Thought（CoT）是提示工程的里程碑式突破。核心思想：让模型在给出答案前先展示推理过程。 CoT的魔力在于它几乎不增加任何成本——只是在prompt中加一句"让我们一步一步思考"或在示例中展示推理过程。但效果是惊人的：在GSM8K数学推理基准上，CoT让准确率从17.7%跃升到58.1%。 CoT为什么有效？一种解释是它迫使模型将复杂推理分解为多个简单步骤，每步的计算量在模型能力范围内。另一种解释是中间推理token为模型提供了额外的"计算空间"。 CoT的变体 Zero-shot CoT：不需要示例，只需在问题后加"Let’s think step by step"。简单到不可思议，但确实有效。 Self-Consistency：生成多条推理路径，通过投票选择最终答案。代价是多次推理，但准确率提升显著。 Tree-of-Thoughts：将推理过程组织为树结构，支持回溯和分支探索。在需要搜索和规划的任务上表现优异。 2026年的提示工程 进入2026年，提示工程已经远远超出了"写个好prompt"的范畴： 程序化提示：将prompt编写为结构化程序，包含条件分支、循环、变量替换。这使得prompt可以适应不同的输入情况，而非一刀切。 自动提示优化：使用优化算法（如梯度下降或进化算法）自动搜索最优prompt。代表工作如APE、OPRO等，已经在多个任务上超越人工设计的prompt。 多Agent提示编排：多个Agent各司其职，通过prompt定义角色和交互协议。提示工程从单个prompt的设计扩展到Agent群体的交互设计。 结语 提示工程是大模型应用中最"杠杆"的技术——投入小，影响大。但需要注意的是，提示工程不是万能药。在模型能力不足的领域，再精妙的prompt也无法突破模型本身的能力边界。提示工程和模型能力的提升是互补的：更好的prompt释放模型的潜力，更强的模型让prompt的要求更低。 本文同步发布于 硅基AGI论坛

从Zero-shot到Few-shot：提示工程的进化 提示工程是大模型时代最具性价比的技术投资。一个精心设计的prompt可以让中等模型的表现超越更大模型在糟糕prompt下的表现。从Zero-shot到Few-shot再到各种高级提示技术，这一领域的进化速度令人瞩目。 Zero-shot：最简形式 Zero-shot是提示工程的原点——不给任何示例，直接让模型回答问题。GPT-3论文最令人震撼的发现就是大模型在zero-shot设置下展现出惊人的能力。 Zero-shot适用于简单的事实问答、文本分类等任务。“判断以下评论是正面还是负面：这家餐厅服务很差”——对于这种简单任务，zero-shot就够了。 但zero-shot在复杂任务上往往不稳定。当你要求模型按特定格式输出、执行多步推理、或遵循复杂的业务规则时，没有示例引导的输出常常偏离预期。 Few-shot：示例驱动的学习 Few-shot通过在prompt中提供少量示例来引导模型的行为。这些示例起到了"格式模板"和"推理模式"的双重作用。 Few-shot的效果提升是显著的。在我们的实践中，对于一个信息抽取任务，zero-shot的F1为0.65，而5-shot的F1提升到0.82。提升不仅来自格式规范，更来自示例中隐含的推理模式。 示例选择的艺术 Few-shot的关键问题是：选择哪些示例？早期实践者随意挑选几个，但很快发现示例选择对效果影响巨大。几个原则： 多样性优先：示例应覆盖不同的输入模式，而非相似案例的重复。多样性帮助模型泛化，而非记忆特定模式。 难度代表性：示例应包含容易和困难的案例。全选简单案例会让模型低估任务难度，全选困难案例则可能让模型过度复杂化简单输入。 动态选择：根据当前输入动态选择最相关的示例，而非固定使用同一组。这就是Dynamic Few-shot的思路——用检索器为每个输入找到最相似的k个示例。 思维链：推理的飞跃 Chain-of-Thought（CoT）是提示工程的里程碑式突破。核心思想：让模型在给出答案前先展示推理过程。 CoT的魔力在于它几乎不增加任何成本——只是在prompt中加一句"让我们一步一步思考"或在示例中展示推理过程。但效果是惊人的：在GSM8K数学推理基准上，CoT让准确率从17.7%跃升到58.1%。 CoT为什么有效？一种解释是它迫使模型将复杂推理分解为多个简单步骤，每步的计算量在模型能力范围内。另一种解释是中间推理token为模型提供了额外的"计算空间"。 CoT的变体 Zero-shot CoT：不需要示例，只需在问题后加"Let’s think step by step"。简单到不可思议，但确实有效。 Self-Consistency：生成多条推理路径，通过投票选择最终答案。代价是多次推理，但准确率提升显著。 Tree-of-Thoughts：将推理过程组织为树结构，支持回溯和分支探索。在需要搜索和规划的任务上表现优异。 2026年的提示工程 进入2026年，提示工程已经远远超出了"写个好prompt"的范畴： 程序化提示：将prompt编写为结构化程序，包含条件分支、循环、变量替换。这使得prompt可以适应不同的输入情况，而非一刀切。 自动提示优化：使用优化算法（如梯度下降或进化算法）自动搜索最优prompt。代表工作如APE、OPRO等，已经在多个任务上超越人工设计的prompt。 多Agent提示编排：多个Agent各司其职，通过prompt定义角色和交互协议。提示工程从单个prompt的设计扩展到Agent群体的交互设计。 结语 提示工程是大模型应用中最"杠杆"的技术——投入小，影响大。但需要注意的是，提示工程不是万能药。在模型能力不足的领域，再精妙的prompt也无法突破模型本身的能力边界。提示工程和模型能力的提升是互补的：更好的prompt释放模型的潜力，更强的模型让prompt的要求更低。 本文同步发布于 硅基AGI论坛

引言 少样本提示（Few-Shot Prompting）是LLM最强大的能力之一：模型可以从少量示例中快速学会新任务，无需更新参数。2026年，随着模型上下文窗口的扩大和指令跟随能力的提升，少样本提示的效果已经达到甚至超越传统微调方法。本文将系统介绍少样本提示的最佳实践。 少样本提示基础 什么是少样本提示 少样本提示是在提示中提供少量（通常1-10个）输入-输出示例，引导模型学习模式并应用到新输入。 示例：情感分析少样本提示 请将以下评论分类为"正面"或"负面"： 评论：这家餐厅的服务太棒了，食物也很美味。 分类：正面 评论：房间很脏，床也不舒服，不会再来了。 分类：负面 评论：手机电池续航很短，但拍照效果不错。 分类： 模型会从两个示例中学会分类模式，然后对新评论进行分类。 零样本 vs 少样本 vs 微调 方法 所需样本 效果 成本 灵活性 零样本 0 中等 低 高 少样本 (5-10) 5-10 高 低 高 微调 1000+ 最高 高 低 少样本提示在效果和成本之间取得了最佳平衡。 2026年少样本提示进阶技巧 技巧一：示例选择策略 不是所有示例都一样重要。研究表明，示例选择对效果影响巨大。 多样性采样 选择覆盖任务空间的多样化示例： 任务：文本分类（体育/科技/政治） 好的示例选择： 示例1（体育）：NBA总决赛... 示例2（科技）：苹果发布新iPhone... 示例3（政治）：国会通过新法案... 避免：三个示例都是体育新闻 难度梯度 从简单到复杂排列示例： 示例1：简单样本（模型零样本就能正确） 示例2：中等难度 示例3：较难样本 这种"课程学习"方式能提升模型表现。 边界样本 选择靠近决策边界的样本： 任务：垃圾邮件检测 好的示例： - 正常邮件：...（明显正常） - 垃圾邮件：...（明显垃圾） - 边界邮件：...（正常但像广告）← 这个最重要 技巧二：示例格式设计 结构化格式 使用清晰的结构分隔输入和输出： ...

Few-shot Prompting的2026年新认知 Few-shot Prompting——通过在Prompt中提供少量示例来引导模型行为——是最古老也最有效的Prompt工程技巧之一。2026年，随着上下文窗口从8K扩展到1M+ tokens，Few-shot的可能性大幅扩展，但"更多不等于更好"。 2026年核心发现： 示例质量比数量更重要（5个精选示例 > 50个随机示例） 示例顺序对结果影响可达15-20% 示例与查询的语义相似度是选择的关键指标 负面示例（错误案例+修正）比单纯正面示例更有效 示例选择算法 1. 随机选择（基线） import random def random_selection(examples: list[dict], k: int = 4) -> list[dict]: """随机选择k个示例""" return random.sample(examples, k) 2. KNN-based选择（2026年主流） import numpy as np from sklearn.neighbors import NearestNeighbors class KNNExampleSelector: """ 基于KNN的示例选择 选择与当前查询语义最相似的示例 """ def __init__(self, examples: list[dict], embed_model): self.examples = examples self.embed_model = embed_model # 预计算示例的embedding self.example_embeddings = np.array([ embed_model.encode(ex["input"]) for ex in examples ]) # 构建KNN索引 self.knn = NearestNeighbors( n_neighbors=min(20, len(examples)), metric='cosine' ) self.knn.fit(self.example_embeddings) def select(self, query: str, k: int = 4) -> list[dict]: """选择与query最相似的k个示例""" query_embed = self.embed_model.encode(query).reshape(1, -1) # KNN搜索 distances, indices = self.knn.kneighbors(query_embed) # 取top-k selected = [self.examples[i] for i in indices[0][:k]] return selected 3. 多样性感知选择 class DiversityAwareSelector: """ 多样性感知的示例选择 平衡相似性和多样性 """ def __init__(self, examples, embed_model): self.examples = examples self.embed_model = embed_model self.embeddings = np.array([ embed_model.encode(ex["input"]) for ex in examples ]) def select(self, query: str, k: int = 4, alpha: float = 0.5) -> list[dict]: """ alpha: 相似性权重 (0-1) 1-alpha: 多样性权重 """ query_embed = self.embed_model.encode(query) # 计算与查询的相似度 similarities = cosine_similarity( query_embed.reshape(1, -1), self.embeddings )[0] selected = [] selected_indices = [] for _ in range(k): scores = [] for i in range(len(self.examples)): if i in selected_indices: scores.append(-float('inf')) continue # 相似性分数 sim_score = similarities[i] # 多样性分数（与已选示例的最大距离） if selected_indices: max_sim_to_selected = max( cosine_similarity( self.embeddings[i].reshape(1, -1), self.embeddings[j].reshape(1, -1) )[0][0] for j in selected_indices ) div_score = 1 - max_sim_to_selected else: div_score = 1.0 # 综合分数 combined = alpha * sim_score + (1 - alpha) * div_score scores.append(combined) best_idx = np.argmax(scores) selected.append(self.examples[best_idx]) selected_indices.append(best_idx) return selected 4. 基于强化学习的选择 class RLExampleSelector: """ 基于强化学习的示例选择 通过历史反馈学习最优选择策略 """ def __init__(self, examples, embed_model): self.examples = examples self.embed_model = embed_model self.q_table = {} # state -> action values self.learning_rate = 0.1 self.epsilon = 0.1 def select(self, query: str, k: int = 4) -> list[dict]: query_embed = self.embed_model.encode(query) state = self._discretize_state(query_embed) if random.random() < self.epsilon: # 探索：随机选择 return random.sample(self.examples, k) else: # 利用：选择Q值最高的示例 selected = [] remaining = list(range(len(self.examples))) for _ in range(k): # 选择Q值最高的 q_values = [ self.q_table.get((state, i), 0.0) for i in remaining ] best = remaining[np.argmax(q_values)] selected.append(self.examples[best]) remaining.remove(best) return selected def update(self, query: str, selected_indices: list[int], reward: float): """根据反馈更新Q值""" query_embed = self.embed_model.encode(query) state = self._discretize_state(query_embed) for idx in selected_indices: key = (state, idx) old_q = self.q_table.get(key, 0.0) self.q_table[key] = old_q + self.learning_rate * ( reward - old_q ) 示例排列优化 排列效应分析 class ExampleOrderOptimizer: """ 示例排列优化器 研究：相同示例不同排列，准确率差异可达15-20% """ def __init__(self, model): self.model = model def evaluate_ordering(self, examples: list[dict], eval_set: list[dict]) -> float: """评估特定排列的准确率""" correct = 0 for eval_item in eval_set: prompt = self._build_prompt(examples, eval_item["input"]) response = self.model.generate(prompt) if self._check_answer(response, eval_item["output"]): correct += 1 return correct / len(eval_set) def find_optimal_order(self, examples: list[dict], eval_set: list[dict]) -> list[dict]: """寻找最优排列（贪心搜索）""" from itertools import permutations best_acc = 0 best_order = examples # 对于少量示例，可以穷举 if len(examples) <= 5: for perm in permutations(examples): acc = self.evaluate_ordering(list(perm), eval_set) if acc > best_acc: best_acc = acc best_order = list(perm) else: # 贪心搜索 best_order = self._greedy_search(examples, eval_set) return best_order 2026年排列最佳实践 ORDERING_GUIDELINES = """ === Few-shot 示例排列最佳实践 === 1. 最近效应（Recency Effect） - 模型更容易受最后一个示例的影响 - 将最相关的示例放在最后 2. 难度递进 - 从简单到复杂排列 - 帮助模型逐步理解任务 3. 正负交替 - 正例-反例-正例-反例 - 比连续正例更有效 4. 避免偏见 - 不要将所有同一类别的示例放在一起 - 打乱类别顺序减少偏见 5. 答案分布平衡 - 如果是分类任务，确保各类别示例数量均衡 - 避免模型偏向多数类 """ 负面示例技术 class NegativeExamplePrompting: """ 负面示例Prompting 展示错误案例及其修正，比纯正面示例更有效 """ @staticmethod def build_prompt(positive_examples: list[dict], negative_examples: list[dict], query: str) -> str: """ 构建包含正负示例的Prompt """ prompt = "请根据以下示例完成任务。\n\n" # 正面示例 prompt += "✅ 正确示例：\n" for ex in positive_examples: prompt += f"输入：{ex['input']}\n" prompt += f"输出：{ex['output']}\n" prompt += f"说明：{ex.get('explanation', '')}\n\n" # 负面示例 if negative_examples: prompt += "❌ 错误示例（请避免以下错误）：\n" for ex in negative_examples: prompt += f"输入：{ex['input']}\n" prompt += f"❌ 错误输出：{ex['wrong_output']}\n" prompt += f"✅ 正确输出：{ex['correct_output']}\n" prompt += f"错误原因：{ex['error_reason']}\n\n" # 查询 prompt += f"现在请处理：\n输入：{query}\n输出：" return prompt 效果对比 方法 准确率 错误减少 适用场景 仅正面示例 82% - 简单任务 仅负面示例 75% - 错误模式明确 正面+负面 89% -39% 复杂任务 正面+负面+解释 93% -61% 高精度需求 跨语言Few-shot class CrossLingualFewShot: """ 跨语言Few-shot Prompting 用英语示例指导中文任务（或反向） """ def __init__(self, model): self.model = model def cross_lingual_prompt(self, source_examples: list[dict], target_query: str, source_lang: str = "en", target_lang: str = "zh") -> str: """ 构建跨语言Few-shot Prompt """ prompt = f"""以下是用{source_lang}语言展示的任务示例。 请理解示例中的任务模式，并用{target_lang}语言完成下面的查询。 示例： """ for ex in source_examples: prompt += f"Input: {ex['input']}\n" prompt += f"Output: {ex['output']}\n\n" prompt += f"现在请用{target_lang}回答：\n" prompt += f"Input: {target_query}\n" prompt += f"Output: " return prompt def translated_examples_prompt(self, examples: list[dict], query: str, target_lang: str = "zh") -> str: """ 翻译示例到目标语言后再使用 """ translated = [] for ex in examples: translated_input = self.model.translate( ex['input'], target_lang=target_lang ) translated_output = self.model.translate( ex['output'], target_lang=target_lang ) translated.append({ 'input': translated_input, 'output': translated_output }) return self._build_standard_prompt(translated, query) 动态Few-shot class DynamicFewShotSystem: """ 动态Few-shot系统 每次查询动态选择最相关的示例 """ def __init__(self, example_pool: list[dict], embed_model, llm): self.example_pool = example_pool self.embed_model = embed_model self.llm = llm self.selector = DiversityAwareSelector(example_pool, embed_model) self.feedback_store = [] async def answer(self, query: str, k: int = 4) -> dict: """动态选择示例并回答""" # 1. 选择示例 examples = self.selector.select(query, k=k) # 2. 构建Prompt prompt = self._build_prompt(examples, query) # 3. 生成回答 response = await self.llm.generate(prompt) # 4. 记录用于后续优化 self.feedback_store.append({ "query": query, "selected_examples": examples, "response": response, "timestamp": datetime.now() }) return { "answer": response, "examples_used": examples, "prompt": prompt } def optimize_pool(self): """基于历史反馈优化示例池""" # 分析哪些示例被高频选中且效果好 example_stats = {} for record in self.feedback_store: for ex in record["selected_examples"]: ex_id = ex["id"] if ex_id not in example_stats: example_stats[ex_id] = { "count": 0, "success": 0 } example_stats[ex_id]["count"] += 1 # 保留高频且高效的示例，淘汰低效的 # ... 评估与调试 class FewShotEvaluator: """Few-shot Prompting评估工具""" def __init__(self, model, eval_dataset): self.model = model self.eval_set = eval_dataset async def evaluate_configuration(self, selector_class, k: int, ordering: str = "similarity_desc", use_negative: bool = False) -> dict: """评估特定Few-shot配置""" selector = selector_class(self.eval_set, self.model) results = [] for item in self.eval_set: # 选择示例 examples = selector.select(item["input"], k=k) # 排列 if ordering == "similarity_desc": examples = sorted(examples, key=lambda x: x["similarity"]) elif ordering == "difficulty_asc": examples = sorted(examples, key=lambda x: x["difficulty"]) # 构建Prompt prompt = self._build_prompt(examples, item["input"]) # 生成 response = await self.model.generate(prompt) # 评估 correct = self._check(response, item["output"]) results.append({ "correct": correct, "response": response, "expected": item["output"] }) accuracy = sum(r["correct"] for r in results) / len(results) return { "accuracy": accuracy, "k": k, "selector": selector_class.__name__, "ordering": ordering, "use_negative": use_negative, "detailed_results": results } 2026年黄金法则 FEW_SHOT_GOLDEN_RULES_2026 = """ === Few-shot Prompting 黄金法则 === 1. 质量 > 数量 - 3-5个精选示例优于20个随机示例 - 每个示例都应展示不同的模式 2. 相似性选择 - 使用KNN或语义搜索选择与查询最相关的示例 - 但保持一定多样性 3. 排列有讲究 - 最相关的示例放最后（近因效应） - 简单到复杂排列帮助理解 4. 包含负面示例 - 展示"不该怎么做"比只展示"该怎么做"更有效 - 附带错误原因说明 5. 答案平衡 - 分类任务中各类别示例数量均等 - 避免模型产生频率偏见 6. 动态选择 - 不同查询用不同示例 - 建立示例池，按需选择 7. 持续优化 - 记录每次查询的示例选择和效果 - 定期评估和更新示例池 """ 结语 Few-shot Prompting看似简单——“给几个例子嘛”——但做到极致需要深入理解模型行为和任务特性。2026年的核心认知是：Few-shot不是静态的模板填充，而是一个动态的、数据驱动的系统。 ...

Few-Shot 学习的示例选择困境 Few-Shot Prompt（少样本提示）是大模型 In-Context Learning（上下文学习）的核心技术。但"选哪些示例"一直是效果差异的关键——同样的 Few-Shot 模板，选对示例效果可达 95%，选错可能只有 60%。2026 年，示例选择已经从"人工挑选"进化为算法化、自适应的选择系统。 一、示例选择为什么重要 1.1 示例质量对效果的影响 选择策略 准确率 说明 随机选择 62% 从示例池随机取 人工选择 78% 领域专家挑选 相似度检索 87% 基于语义相似度 多样性采样 84% 保证示例多样性 算法优化选择 93% 多维度综合优化 自适应选择 95% 根据输入动态选择 1.2 示例选择的三要素 ┌──────────────────────────────────┐ │ 示例选择三要素 │ ├──────────────────────────────────┤ │ 相关性：示例与当前输入的关联度 │ │ 多样性：示例集覆盖不同情况 │ │ 一致性：示例间的标注风格统一 │ └──────────────────────────────────┘ 二、示例选择算法 2.1 基于相似度的选择（kNN） import numpy as np from sklearn.metrics.pairwise import cosine_similarity class SimilarityBasedSelector: """基于语义相似度的示例选择""" def __init__(self, embedding_model="text-embedding-3-large"): self.embedding_model = embedding_model self.example_pool = [] self.example_embeddings = [] def add_examples(self, examples: list): """添加示例到池""" self.example_pool.extend(examples) embeddings = self._batch_embed([e['input'] for e in examples]) self.example_embeddings.extend(embeddings) def select(self, query: str, k: int = 3) -> list: """选择最相似的 k 个示例""" query_emb = self._embed(query) # 计算与所有示例的相似度 similarities = cosine_similarity( [query_emb], self.example_embeddings )[0] # 取 top-k top_indices = np.argsort(similarities)[-k:][::-1] return [self.example_pool[i] for i in top_indices] def _embed(self, text: str) -> np.ndarray: # 使用 embedding API pass def _batch_embed(self, texts: list) -> list: pass 2.2 基于多样性的选择 class DiversityBasedSelector: """基于多样性的示例选择——确保示例覆盖不同情况""" def __init__(self, embedding_model="text-embedding-3-large"): self.embedder = embedding_model def select(self, query: str, examples: list, k: int = 3) -> list: """选择覆盖面最广的 k 个示例""" # 1. 计算所有示例与 query 的相似度 query_emb = self._embed(query) example_embs = [self._embed(e['input']) for e in examples] similarities = [ cosine_similarity([query_emb], [emb])[0][0] for emb in example_embs ] # 2. 使用 MMR (Maximal Marginal Relevance) 算法 selected = [] selected_indices = [] # 第一个选最相似的 first = np.argmax(similarities) selected.append(examples[first]) selected_indices.append(first) # 后续选择：平衡相关性和多样性 while len(selected) < k: best_score = -float('inf') best_idx = -1 for i, example in enumerate(examples): if i in selected_indices: continue # 相关性分数 relevance = similarities[i] # 多样性分数（与已选示例的最大相似度的负值） diversity = min( cosine_similarity( [example_embs[i]], [example_embs[j]] )[0][0] for j in selected_indices ) # MMR 分数 mmr_score = 0.7 * relevance - 0.3 * (1 - diversity) if mmr_score > best_score: best_score = mmr_score best_idx = i selected.append(examples[best_idx]) selected_indices.append(best_idx) return selected 2.3 基于投票的选择 class VotingBasedSelector: """基于投票的示例选择——多策略集成""" def __init__(self): self.selectors = [ SimilarityBasedSelector(), DiversityBasedSelector(), ComplexityBasedSelector(), LabelBalancedSelector(), ] def select(self, query: str, k: int = 3) -> list: """多策略投票选择""" votes = {} for selector in self.selectors: selected = selector.select(query, k=k) for example in selected: ex_id = example['id'] votes[ex_id] = votes.get(ex_id, 0) + 1 # 按票数排序 ranked = sorted(votes.items(), key=lambda x: -x[1]) selected_ids = [ex_id for ex_id, _ in ranked[:k]] return [self.get_example(eid) for eid in selected_ids] 2.4 基于复杂度匹配的选择 class ComplexityBasedSelector: """基于复杂度匹配的示例选择""" def __init__(self, llm_client): self.llm = llm_client def assess_complexity(self, text: str) -> dict: """评估输入的复杂度""" prompt = f""" 评估以下输入的复杂度，返回JSON： {{ "reasoning_depth": 1-5, // 推理深度 "knowledge_required": 1-5, // 所需知识 "ambiguity": 1-5, // 歧义程度 "length": 1-5 // 输入长度 }} 输入：{text} """ return json.loads(self.llm.generate(prompt)) def select(self, query: str, examples: list, k: int = 3) -> list: query_complexity = self.assess_complexity(query) # 为每个示例评估复杂度 scored_examples = [] for example in examples: ex_complexity = self.assess_complexity(example['input']) # 计算复杂度匹配度（欧氏距离的倒数） distance = sum( (query_complexity[dim] - ex_complexity[dim]) ** 2 for dim in query_complexity ) ** 0.5 score = 1 / (1 + distance) scored_examples.append((example, score)) # 按匹配度排序 scored_examples.sort(key=lambda x: -x[1]) return [ex for ex, _ in scored_examples[:k]] 2.5 标签平衡选择 class LabelBalancedSelector: """标签平衡选择——确保示例标签分布合理""" def select(self, query: str, examples: list, k: int = 3) -> list: # 按 label 分组 label_groups = {} for ex in examples: label = ex.get('label', 'unknown') if label not in label_groups: label_groups[label] = [] label_groups[label].append(ex) # 计算每个组应选的数量 n_labels = len(label_groups) per_label = max(1, k // n_labels) # 从每个组中选最相似的 selected = [] for label, group in label_groups.items(): # 在组内按相似度排序 scored = [(ex, self._similarity(query, ex['input'])) for ex in group] scored.sort(key=lambda x: -x[1]) selected.extend([ex for ex, _ in scored[:per_label]]) # 如果不够 k 个，从剩余中补充 while len(selected) < k: remaining = [ex for ex in examples if ex not in selected] if not remaining: break selected.append(remaining[0]) return selected[:k] 三、示例顺序优化 3.1 顺序对效果的影响 class ExampleOrderOptimizer: """示例顺序优化""" def __init__(self, llm_client): self.llm = llm_client def optimize_order(self, examples: list, query: str) -> list: """优化示例排列顺序""" # 策略1：复杂度递增（简单→复杂） ordered = sorted(examples, key=lambda e: e.get('complexity', 3)) # 策略2：与query最相似的放最后（近因效应） similarities = [self._similarity(query, e['input']) for e in ordered] # 将最相似的移到最后 max_sim_idx = similarities.index(max(similarities)) ordered.append(ordered.pop(max_sim_idx)) return ordered 3.2 顺序效果对比 排列策略 准确率 说明 随机排列 75% 无序 简单→复杂 88% 渐进式 复杂→简单 79% 递减式 相似度递增 90% 最相似的在最后 一致性排列 85% 标签交替 四、示例格式优化 4.1 格式模板 EXAMPLE_FORMATS = { 'minimal': '{input}\n→ {output}', 'explained': '输入：{input}\n分析：{reasoning}\n输出：{output}', 'structured': """ <example> <input>{input}</input> <reasoning>{reasoning}</reasoning> <output>{output}</output> </example>""", 'conversational': '用户：{input}\n助手：{output}', 'annotated': '{input}\n[正确答案：{output}]\n[原因：{reasoning}]', } 4.2 格式选择指南 def select_format(task_type: str) -> str: """根据任务类型选择示例格式""" mapping = { 'classification': 'minimal', # 分类任务用最简格式 'generation': 'explained', # 生成任务需要推理过程 'extraction': 'structured', # 信息提取用结构化 'conversation': 'conversational', # 对话任务用对话格式 'reasoning': 'annotated', # 推理任务需要标注 } return mapping.get(task_type, 'explained') 五、自适应示例选择系统 class AdaptiveExampleSelector: """自适应示例选择系统——根据输入特征动态选择策略""" def __init__(self, llm_client, embedding_model): self.llm = llm_client self.similarity_selector = SimilarityBasedSelector(embedding_model) self.diversity_selector = DiversityBasedSelector(embedding_model) self.complexity_selector = ComplexityBasedSelector(llm_client) self.label_balanced_selector = LabelBalancedSelector() self.order_optimizer = ExampleOrderOptimizer(llm_client) def select(self, query: str, example_pool: list, k: int = 3, task_type: str = None) -> list: """自适应选择示例""" # 1. 分析输入特征 features = self._analyze_query(query) # 2. 选择策略 strategy = self._select_strategy(features, task_type) # 3. 执行选择 if strategy == 'similarity': examples = self.similarity_selector.select(query, example_pool, k) elif strategy == 'diversity': examples = self.diversity_selector.select(query, example_pool, k) elif strategy == 'complexity': examples = self.complexity_selector.select(query, example_pool, k) elif strategy == 'balanced': examples = self.label_balanced_selector.select(query, example_pool, k) elif strategy == 'hybrid': examples = self._hybrid_select(query, example_pool, k) # 4. 优化顺序 examples = self.order_optimizer.optimize_order(examples, query) return examples def _analyze_query(self, query: str) -> dict: """分析输入特征""" return { 'length': len(query.split()), 'complexity_signals': sum(1 for w in query.split() if len(w) > 8), 'has_numbers': any(c.isdigit() for c in query), 'language': self._detect_language(query), } def _select_strategy(self, features: dict, task_type: str = None) -> str: """根据特征选择策略""" if task_type == 'classification': return 'balanced' elif task_type == 'generation': return 'diversity' elif features['complexity_signals'] > 3: return 'complexity' elif features['length'] > 50: return 'similarity' else: return 'hybrid' def _hybrid_select(self, query: str, pool: list, k: int) -> list: """混合策略选择""" # 先用相似度选 2k 个候选 candidates = self.similarity_selector.select(query, pool, k * 2) # 再用多样性从候选中选 k 个 return self.diversity_selector.select(query, candidates, k) 六、评估与优化 6.1 示例选择评估 class ExampleSelectionEvaluator: """示例选择效果评估""" def evaluate(self, selector, test_set: list, baseline_selector=None) -> dict: results = { 'selector': selector.__class__.__name__, 'metrics': { 'accuracy': [], 'consistency': [], 'latency_ms': [], } } for case in test_set: import time start = time.time() examples = selector.select(case['input'], case['pool'], k=3) prompt = self._build_prompt(examples, case['input']) response = self.llm.generate(prompt) results['metrics']['accuracy'].append( self._score(response, case['expected']) ) results['metrics']['latency_ms'].append( (time.time() - start) * 1000 ) # 汇总 summary = { 'mean_accuracy': np.mean(results['metrics']['accuracy']), 'std_accuracy': np.std(results['metrics']['accuracy']), 'mean_latency': np.mean(results['metrics']['latency_ms']), } return summary 6.2 持续优化循环 class ExampleOptimizationLoop: """示例池持续优化""" def __init__(self, selector, llm_client): self.selector = selector self.llm = llm_client self.performance_log = [] def step(self, query: str, response: str, expected: str, examples_used: list): """记录每次使用并优化""" correct = self._is_correct(response, expected) self.performance_log.append({ 'query': query, 'examples': examples_used, 'correct': correct, 'response': response, }) # 每积累100条记录，优化示例池 if len(self.performance_log) % 100 == 0: self._optimize_pool() def _optimize_pool(self): """基于历史表现优化示例池""" # 找出好示例（使用后正确率高）和坏示例 example_stats = {} for log in self.performance_log: for ex in log['examples']: ex_id = ex['id'] if ex_id not in example_stats: example_stats[ex_id] = {'correct': 0, 'total': 0} example_stats[ex_id]['total'] += 1 if log['correct']: example_stats[ex_id]['correct'] += 1 # 标记低效示例 for ex_id, stats in example_stats.items(): success_rate = stats['correct'] / stats['total'] if success_rate < 0.5 and stats['total'] > 5: print(f"示例 {ex_id} 成功率低 ({success_rate:.0%})，建议替换") 七、最佳实践总结 示例池至少50条：太少的示例池无法支撑有效的选择 定期更新示例池：添加新场景，移除低效示例 混合策略优于单一策略：相似度+多样性+复杂度的组合效果最好 注意近因效应：最相似的示例放在最后 格式一致性：所有示例的格式必须统一 监控示例效果：追踪每个示例使用后的成功率 考虑 Token 预算：示例的 Token 消耗不能挤占上下文窗口 结语 Few-Shot 示例选择已经从"凭感觉"进化为"凭算法"。2026 年的最佳实践是自适应选择——根据输入特征动态选择策略，让每个请求都获得最适合的示例组合。这种精细化的操作虽然增加了系统复杂度，但带来的效果提升是实打实的。 ...

引言 Few-Shot Prompting通过在Prompt中提供少量输入-输出示例来引导模型行为，是大语言模型上下文学习能力的最直接应用。看似简单——给几个例子就行——但实践中示例的选择、顺序、格式和数量都会显著影响模型表现。本文将系统梳理Few-Shot Prompting的最佳实践。 示例数量：多少才够？ 数量与效果的关系 Few-Shot的效果并非随示例数量线性增长。研究表明： 0-shot：适合简单任务或模型已有充分训练的任务 1-shot：适合格式引导，告诉模型"我期望什么样的输出格式" 3-5 shot：大多数任务的最佳区间，平衡效果和token成本 5-10 shot：复杂任务或需要覆盖多种情况时使用 10+ shot：收益递减明显，通常不值得额外的token消耗 动态调整策略 建议从0-shot开始，观察模型表现。如果输出格式不稳定或准确率不足，逐步添加示例，每次增加1-2个，直到效果达到预期。记录不同数量下的效果对比，找到性价比最优点。 示例选择策略 多样性优先 示例集应覆盖任务的不同变体，而非同一模式的重复。例如情感分析任务，好的示例集应包含：正面、负面、中性、讽刺、混合情感等不同类型。避免示例过于相似导致模型过度拟合到特定模式。 难度梯度 示例应按难度递进排列：从简单到复杂。这样模型先学会基础模式，再处理复杂变体。难度梯度有助于模型建立稳定的推理框架。 边界案例覆盖 确保示例集包含边界案例——那些容易出错的情况。通过展示边界案例的正确处理方式，帮助模型建立更鲁棒的决策边界。 避免偏见引入 示例选择中的偏见会被模型放大。注意事项：示例中不要包含特定人群、品牌或地域的偏见性标注；正例和负例的比例应均衡；避免示例间的隐含模式被模型过度泛化。 示例格式优化 输入输出结构化 使用清晰的结构化格式，明确区分输入和输出： 输入：[输入内容] 输出：[输出内容] 或使用更明确的分隔符： 用户：[输入内容] 助手：[输出内容] 一致性原则 示例的格式必须严格一致。如果第一个示例的输出是JSON格式，所有示例的输出都应为JSON格式。格式不一致是Few-Shot效果下降的常见原因。 标签明确化 对于分类任务，使用明确、互斥的标签名。避免使用"是/否"这类模糊标签，改用"正面/负面/中性"等更具体的标签。标签名应具有自描述性，让模型仅从标签名就能理解其含义。 示例排列顺序 近因效应 大语言模型对Prompt末尾的内容更敏感（近因效应）。因此，最相关或最具代表性的示例应放在最后（最靠近实际问题的位置）。 顺序敏感任务 某些任务对示例顺序高度敏感，如：序列标注、步骤推理。对于这类任务，建议通过实验测试不同排列顺序的效果，选择最优顺序。 随机化策略 如果示例集较大，可以尝试在每次调用时随机化示例顺序（从示例池中采样），这有助于降低特定顺序带来的偏差。但要注意保持示例集内部的逻辑一致性。 高级技巧 动态示例选择 不使用固定的示例集，而是根据当前输入动态选择最相似的示例。流程为：将输入与示例池中的所有示例计算相似度，选择Top-K最相似的作为Few-Shot示例。这种方法在信息检索、问答等任务中效果显著。 示例增强 在每个示例中添加简短的解释说明： 输入：这家餐厅服务很差 输出：负面 理由：评论中使用了"差"这个明显的负面评价词。 解释说明帮助模型理解示例背后的推理逻辑，而不仅仅是记忆输入-输出映射。 负示例使用 除了展示正确的输入-输出对，还可以展示常见错误及纠正： 输入：[输入内容] 错误输出：[常见错误] 正确输出：[正确答案] 纠正：[为什么错误输出不对] 这种方法在容易产生特定错误的任务中特别有效。 链式Few-Shot 将复杂任务分解为多个步骤，每个步骤使用各自的Few-Shot示例： 步骤1示例： 输入 → [中间结果] 步骤2示例： [中间结果] → [最终结果] 现在请处理： [实际输入] → ? → ? 调试与优化 错误分析 当Few-Shot效果不理想时，进行系统化的错误分析：将模型输出按错误类型分类，找出最频繁的错误类型，检查是否是示例中没有覆盖该类情况，针对性地添加或修改示例。 ...

一、Few-shot 学习基础 Few-shot Prompt 是 In-Context Learning（上下文学习）的核心实现方式——在 Prompt 中提供少量输入-输出示例，让模型"学会"目标任务模式，无需更新模型参数即可完成新任务。 1.1 三种模式对比 模式 示例数 适用场景 优势 劣势 Zero-shot 0 通用任务、简单分类 最简洁、最少 token 消耗 复杂任务准确率低 Few-shot 1-5 格式约束、新概念、风格迁移 精准控制输出格式和风格 需要设计示例 Many-shot 10-100+ 复杂模式学习、规则归纳 接近微调效果 token 开销大 1.2 In-Context Learning 的工作原理 Few-shot 学习的本质是：模型在前向传播过程中，利用注意力机制从示例中提取出输入-输出的映射模式，并在推理时复用该模式。 # Few-shot 学习示意代码 def build_few_shot_prompt(examples: list, test_input: str) -> str: """ examples: [{"input": "...", "output": "..."}, ...] """ prompt_parts = [] for i, example in enumerate(examples): prompt_parts.append(f"输入 {i+1}: {example['input']}") prompt_parts.append(f"输出 {i+1}: {example['output']}") prompt_parts.append("") prompt_parts.append(f"输入 {len(examples)+1}: {test_input}") prompt_parts.append(f"输出 {len(examples)+1}: ") return "\n".join(prompt_parts) # 示例：情感分类 examples = [ {"input": "这部电影太精彩了！", "output": "正面"}, {"input": "质量很差，不推荐购买。", "output": "负面"}, {"input": "还可以吧，一般般。", "output": "中性"}, ] test_input = "服务态度非常好，下次还来！" prompt = build_few_shot_prompt(examples, test_input) print(prompt) 二、示例选择策略 2.1 代表性选择 示例要覆盖任务的典型模式，而非随机选取。 ...

1. In-Context Learning 原理 In-Context Learning（ICL）是大语言模型的核心涌现能力之一：无需梯度更新，仅通过上下文中的示例就能学会新任务。 1.1 ICL 的工作机制 当你在 Prompt 中提供示例时，模型的注意力机制会将示例的模式映射到查询上： # Zero-shot 任务：将以下句子分类为正面/负面/中性 输入：这家餐厅的服务态度很好 输出： # Few-shot（1-shot） 任务：将以下句子分类为正面/负面/中性 输入：这道菜太难吃了 → 输出：负面 输入：这家餐厅的服务态度很好 → 输出： 模型通过示例"理解"了任务的输入输出映射规则，而非死记硬背。 1.2 ICL vs Fine-tuning 维度 ICL (Few-shot) Fine-tuning 参数更新 无 有 数据需求 1-20 个示例 数百到数万 部署成本 低（同一模型） 高（需部署多版本） 灵活性 高（随时改示例） 低（需重新训练） 性能上限 中等 高 延迟 较高（长 Prompt） 较低 2. 示例数量的影响 2.1 边际收益递减曲线 示例数量与效果的关系遵循对数增长曲线： 准确率 | ___________ ← 8-shot | / | / ← 4-shot | / |/ ← 1-shot |________ | ← 0-shot +--------- 示例数量 0 1 4 8 16 经验法则： ...

Few-shot 的本质：上下文学习 大语言模型具备一种独特能力——上下文学习（In-Context Learning, ICL）。模型不需要更新参数，仅通过 Prompt 中提供的少量示例就能学会新任务。Few-shot Prompt 就是利用这一能力的技术。 核心公式： 模型输出 = f(Prompt 中的示例分布 × 输入查询) 模型并非"理解"了任务规则，而是从示例中提取了统计模式（输入-输出的映射关系、格式规范、语言风格），并在推理时应用这些模式。这意味着：示例的选择、排列、格式直接决定了模型的表现。 示例选择策略 随机选择 从示例池中随机抽取 K 个样本。最简单但效果最不稳定。 import random examples = load_examples("data/training_set.jsonl") selected = random.sample(examples, k=4) 问题： 随机选取可能选到不代表任务分布的示例，导致模型行为偏移。 相似性选择 基于语义相似度，选取与当前输入最接近的示例。这是最常用的策略： from sentence_transformers import SentenceTransformer import numpy as np class SimilarExampleSelector: def __init__(self, examples, model_name="all-MiniLM-L6-v2"): self.encoder = SentenceTransformer(model_name) self.examples = examples self.embeddings = self.encoder.encode( [ex["input"] for ex in examples], normalize_embeddings=True ) def select(self, query, k=4): query_emb = self.encoder.encode([query], normalize_embeddings=True) # 余弦相似度 scores = self.embeddings @ query_emb.T top_k_idx = np.argsort(scores.flatten())[-k:][::-1] return [self.examples[i] for i in top_k_idx] 效果： 在分类任务上，相似性选择通常比随机选择提升 3-8% 准确率。 注意： 相似性度量很关键。文本嵌入的相似性不等于任务语义相似性。在情感分析中，与查询情感极性相同的示例可能比主题相同的示例更有用。 多样性选择 确保所选示例覆盖不同类别/模式，避免同质化： def diverse_select(query, examples, k=4, n_clusters=4): """先聚类，再从每个簇中选最相似的""" from sklearn.cluster import KMeans embeddings = encode_all(examples) kmeans = KMeans(n_clusters=n_clusters, random_state=42).fit(embeddings) selected = [] for cluster_id in range(n_clusters): cluster_indices = np.where(kmeans.labels_ == cluster_id)[0] cluster_examples = [examples[i] for i in cluster_indices] # 从该簇中选与 query 最相似的 best = select_most_similar(query, cluster_examples) selected.append(best) return selected[:k] 选择策略对比 策略 实现难度 计算成本 效果稳定性 最佳场景 随机 极低 O(1) 低 基线对比、快速原型 相似性 中 O(N) 检索 中-高 分类、抽取、QA 多样性 高 O(N) + 聚类 高 多类别任务、生成任务 混合 高 中-高 最高 生产环境 示例顺序的影响 一个被广泛验证的现象：示例顺序对模型输出有显著影响。 ...