拒绝死记硬背！Ctx2Skill：让大模型像人类专家一样从文档中“悟”出真技能

RAG/ICL是在消耗模型的“阅读理解能力”，上限受限于上下文窗口（Context Window）的注意力分配。Ctx2Skill是在构建模型的“逻辑建模能力”。它把冗长的、充满噪声的文档，压缩成了高纯度、可迁移的规则（Rules）。这种从“Finding Information” (找信息)到“Acquiring Skills” (获技能)的转变，正是大模型通往真正“专家系统”的关键一步。有趣的

AI资源库

241人浏览 · 2026-05-08 18:29:24

AI资源库 · 2026-05-08 18:29:24 发布

文章目录

@[toc]

拒绝死记硬背！Ctx2Skill：让大模型像人类专家一样从文档中“悟”出真技能

1. 痛点分析：为什么 RAG 和传统的 ICL 触到了“天花板”？ ✋🛡️

1.1 机制缺陷：检索不等于理解 🧑‍💻

1.2 逻辑架构对比：从“搬运”到“建模” 🚀

1.3 代码视角：逻辑断层的具体表现 💻

1.4 总结：从“存量知识”到“增量技能”的跨越 📈

2. 核心创新：Ctx2Skill 是如何“炼”成技能的？🔄🎭

2.1 框架拓扑：多智能体自博弈流水线 🕸️

2.2 三大角色：谁在“卷”谁？🧑‍🏫🧑‍💻👨‍⚖️

① Challenger (挑战者)：逻辑“找茬”专家 🎭

② Reasoner (推理者)：技能驱动的执行器 🚀

③ Judge (裁判)：冷酷的二元打分器 ⚖️

2.3 代码级深度解析：技能是如何“进化”的？💻

2.4 为什么这种结构很有用？💡

3. 三大杀手锏机制：确保技能“不跑偏、不退化” 🚀

3.1 技能发现与精炼（Discovery & Refinement）：精准的“术后总结” 🛠️

3.2 跨时空回放（Cross-time Replay）：对抗“自负”与“遗忘” ⏳🛡️

3.3 技能的一致性约束与剪枝（Consistency & Pruning） ✂️

3.4 为什么这套机制对学术/工业界有用？ 💡

4. 实验结果：它是大模型的“逻辑外挂” 📊🚀

4.1 核心优势：零成本、无痛叠加 🛡️

4.2 战绩复盘：CL-bench 上的惊人跳跃 📈

4.3 拓扑结构：从“原始上下文”到“技能引导推理” 🕸️

4.4 代码实现：如何“挂载”提炼出的技能？ 💻

4.5 为什么这很重要？ 💡

5. 跨行业应用：Ctx2Skill 如何让 AI 真正“入行”？ 🌍🚀

5.1 法律行业：从“卷宗海洋”到“判决逻辑树” ⚖️🏛️

5.2 工业制造：从“硬件手册”到“实时故障排查专家” 🛠️⚙️

5.3 医疗科研：从“实验论文”到“标准化操作规程” 🧪🧬

5.4 为什么这种转变是“降维打击”？ 🚀

6. 深入研究：还有哪些“金矿”坑位可以抢占？💎🚀

6.1 效率优化：从“暴力博弈”到“轻量级演化” ⚡🧑‍💻

6.2 多模态技能提取：让 AI 看懂流程图 📊🖼️

6.3 技能冲突检测：解决“认知失调” 🛡️🤯

6.4 跨模型技能迁移：大带小，小帮大 🚀🔄

结语：从“搜索引擎”到“思维工厂” 🏭🧠

🔗 资源链接快速直达

拒绝死记硬背！Ctx2Skill：让大模型像人类专家一样从文档中“悟”出真技能

摘要：你是否遇到过这样的情况：给大模型丢一份几万字的专业技术手册，它虽然能检索到信息，但一旦涉及复杂的推理就容易“露馅”？传统的上下文学习（ICL）更像是“开卷考试找答案”，而最新的研究 Ctx2Skill 则更进一步——它让模型具备了从阅读中“提炼技能”的能力。本文将带你深度拆解这一自演化框架，看模型如何通过“左右互搏”成为领域专家。

1. 痛点分析：为什么 RAG 和传统的 ICL 触到了“天花板”？ ✋🛡️

在处理芯片寄存器手册、自动驾驶规控协议或高精尖算法文档时，开发者常发现模型虽然“读了”，但并没“懂”。

1.1 机制缺陷：检索不等于理解 🧑‍💻

RAG (Retrieval-Augmented Generation) 🔍：

本质上是“关键词/向量搬运工”。它通过余弦相似度把相关片段喂给模型。
- 死穴：当答案隐藏在文档第 5 页的“前提条件”和第 50 页的“边界处理”之间的隐式逻辑中时，RAG 往往会断章取义。
ICL (In-Context Learning) 📝：

本质上是“近朱者赤”。给模型 3 个例子（Few-shot），让它模仿概率分布。
- 死穴：它学到的是“形”（格式、语气），而不是“神”（底层的算法逻辑）。一旦任务稍作变动，模型就会产生严重的“逻辑幻觉”。

1.2 逻辑架构对比：从“搬运”到“建模” 🚀

我们可以通过下面的拓扑逻辑图看到 Ctx2Skill 与传统方案在知识处理路径上的本质区别：

代码段

1.3 代码视角：逻辑断层的具体表现 💻

假设我们正在处理一个嵌入式硬件的初始化逻辑。传统的 ICL/RAG 代码实现与 Ctx2Skill 的提炼逻辑对比如下：

❌ 传统模式（Naive LLM + RAG）：

模型只是在堆砌文档中看到的术语，没有逻辑校验。

def naive_reasoning(context, user_query):
    # RAG 只是把相关的寄存器描述找出来丢进去
    prompt = f"根据以下手册片段：{context}，回答：{user_query}"
    # 模型输出：由于 A 寄存器在第 5 页提到过，我认为应该先写 A 再写 B (其实手册第 10 页写了顺序依赖，但没被检索到)
    return llm.generate(prompt)

✅ Ctx2Skill 模式（提炼出的“技能”函数化）：

它将文档转化为可执行、可验证的“逻辑程序”。

# Ctx2Skill 演化出的技能库（Skill Set）伪代码
SKILL_LIBRARY = {
    "RK3588_NPU_INIT": {
        "rule": "必须先拉高电平延时 20ms，再写入寄存器 0x400，最后校验 ACK 位",
        "procedure": [step1, step2, step3],
        "edge_case": "如果 ACK 未置位，需重置 PLL 频率"
    }
}

def skill_based_reasoning(query):
    # 模型不再直接翻书，而是检索自己“悟”出来的技能库
    skill = SKILL_LIBRARY.get("RK3588_NPU_INIT")
    # Reasoner 根据技能引导进行推理，极大地减少了因长文本干扰导致的逻辑错误
    return reasoner.execute(skill, query)

1.4 总结：从“存量知识”到“增量技能”的跨越 📈

RAG/ICL 是在消耗模型的“阅读理解能力”，上限受限于上下文窗口（Context Window）的注意力分配。
Ctx2Skill 是在构建模型的“逻辑建模能力”。它把冗长的、充满噪声的文档，压缩成了高纯度、可迁移的规则（Rules）。

这种从 “Finding Information” (找信息) 到 “Acquiring Skills” (获技能) 的转变，正是大模型通往真正“专家系统”的关键一步。

有趣的小发现：这种自演化机制非常像我们做算法题目（如 LeetCode）。看答案（RAG）只能解出这一道题，但通过举一反三、总结出“滑动窗口”或“动态规划”的模板（Skills），你才能解决一类题。Ctx2Skill 就是那个在后台拼命刷题并总结模板的“学霸版”大模型。

2. 核心创新：Ctx2Skill 是如何“炼”成技能的？🔄🎭

Ctx2Skill 的核心逻辑不是简单的“读后感”，而是一场“基于文档的生存游戏”。它通过三个角色的“左右互搏”，强迫模型将零散的信息内化为可执行的“技能点”。

2.1 框架拓扑：多智能体自博弈流水线 🕸️

我们可以将 Ctx2Skill 的工作流程看作一个“闭环反馈控制系统”。每一个环节都在为提升“技能库”的熵减做贡献：

代码段

2.2 三大角色：谁在“卷”谁？🧑‍🏫🧑‍💻👨‍⚖️

① Challenger (挑战者)：逻辑“找茬”专家 🎭

它不仅是出题人，更是漏洞探测器。它会扫描文档中那些模棱两可、具有复合逻辑的地方，设计出“陷阱”。

输入：Raw Context（原始文档）。
输出：Task $T$ + Rubric $R$ （评估标准）。
有趣点：它会刻意针对 Reasoner 表现薄弱的地方出题，这种对抗性生成确保了技能库的“抗压性”。

② Reasoner (推理者)：技能驱动的执行器 🚀

它是真正干活的人，但它被套上了“紧箍咒”——它必须参考当前的 Skill Set 来解题。

逻辑函数： $\text{Model}(T, Context, \text{SkillSet})$
核心逻辑：如果技能库里写着“处理此类寄存器冲突时需先置零”，Reasoner 就必须严格执行这一逻辑，而不是靠直觉。

③ Judge (裁判)：冷酷的二元打分器 ⚖️

不同于以往 LLM 给出的冗长评价，Judge 只给 0 或 1。

为什么要二元反馈？ 避免模型在“废话”中迷失，强制系统面对真实的失败，从而触发后续的“技能重构”。

2.3 代码级深度解析：技能是如何“进化”的？💻

在 Ctx2Skill 内部，最关键的动作是根据失败更新技能（Update Skill）。我们可以将其逻辑抽象为以下伪代码，这能帮你理解其算法严谨性：

class SkillEvolution:
    def __init__(self, context):
        self.skill_set = []  # 初始技能库为空
        self.context = context

    def self_play_round(self):
        # 1. Challenger 出题：针对当前技能库还没覆盖的逻辑
        task, rubric = challenger.generate_adversarial_task(self.context, self.skill_set)
        
        # 2. Reasoner 答题：利用现有技能进行推理
        solution = reasoner.solve(task, self.context, self.skill_set)
        
        # 3. Judge 判定
        is_correct = judge.evaluate(solution, rubric)
        
        # 4. 如果错了，触发【技能精炼】逻辑 (Refinement)
        if not is_correct:
            # Proposer 分析：为什么错了？是技能遗漏还是技能描述有误？
            error_analysis = proposer.analyze(task, solution, rubric)
            
            # Generator 更新：生成一条新的自然语言规则
            new_skill = generator.propose_new_rule(error_analysis)
            self.skill_set.append(new_skill)
            
            # 5. 跨时空回放校验 (Cross-time Replay)
            # 确保新技能不会让以前能做对的题目现在做错了
            self.skill_set = self.validate_and_prune(self.skill_set)

# 最终产出的 Skill Set 就像一个高效的“操作手册补丁”

2.4 为什么这种结构很有用？💡

从“暗知识”到“明规则”：大模型的参数知识是“黑盒”，但 Ctx2Skill 提炼出的 Skill Set 是纯自然语言。你可以直接打印出来看，比如：“规则 1：当输入电压 > 5V 时，必须在 10ms 内触发中断”。这种可解释性对安全敏感行业（如航空、医疗）至关重要。
对抗性坍缩的防护机制：为了防止 Challenger 出题太偏导致模型“学废了”，论文引入了 Cross-time Replay。这相当于给模型准备了一个“错题集”，每当学到新技能时，都要回去刷一遍错题集，确保新技能具有普适性而不是“歪门邪道”。

学长笔记：如果你在做多智能体（Multi-agent）相关的研究，Ctx2Skill 提供了一个绝佳的思路：不要指望一个强大的 Prompt 解决所有问题，要通过角色分工和反馈闭环，让模型在“犯错-纠错-总结”中自我进化。 这种“以赛代练”的方式，远比单纯增加模型规模更有效。

3. 三大杀手锏机制：确保技能“不跑偏、不退化” 🚀

3.1 技能发现与精炼（Discovery & Refinement）：精准的“术后总结” 🛠️

当 Reasoner 挑战失败时，系统不会简单地重来，而是启动一套“深度诊断程序”。这由两个专门的代理协作完成：

Proposer (提议者) 🧐：它像是一个经验丰富的导师，对比“正确答案评分标准”与“学生的错误推理”，指出逻辑断层。
Generator (生成者) ✍️：它负责将这些抽象的诊断转化为原子化的自然语言规则。

【代码逻辑解析：技能更新函数】

我们可以将这个过程抽象为一个高阶逻辑函数，它体现了“错误驱动”的学习本质：

def refine_skill(context, task, solution, feedback, current_skills):
    """
    精炼技能的逻辑算子
    """
    if feedback == "FAIL":
        # 1. 提取错误根源 (Proposer 逻辑)
        # 分析：是因为缺少了 context 中的某条隐含规则，还是对现有规则理解有误？
        gap_analysis = proposer.analyze_failure(task, solution, context)
        
        # 2. 生成新规则或修订旧规则 (Generator 逻辑)
        # 结果可能是一条新技能，例如："在处理电压突变时，必须先检查寄存器 0x01 的中断位"
        updated_skill_set = generator.update_skill_pool(gap_analysis, current_skills)
        
        return updated_skill_set
    return current_skills

3.2 跨时空回放（Cross-time Replay）：对抗“自负”与“遗忘” ⏳🛡️

在自博弈（Self-Play）中，模型极容易陷入对抗性坍缩（Adversarial Collapse）：

挑战者：为了赢，出的题越来越钻牛角尖，脱离了实际文档。
推理者：为了得分，总结出的“技能”只对这些偏题有效，失去了泛化性。

Ctx2Skill 的绝招：引入一个历史任务缓冲区（Task Buffer）。

代码段

有趣的比喻：这就像你在准备期末考试。你不能只刷今天刚出的新模拟题（当前任务），你必须定期回头去做月考题和期中题（历史回放）。如果学了新方法后反而把以前能做对的题做错了，说明你“学歪了”，这套新方法必须舍弃。

3.3 技能的一致性约束与剪枝（Consistency & Pruning） ✂️

这是第三个隐藏的杀手锏。随着博弈进行，技能库会变得臃肿。Ctx2Skill 会执行“奥卡姆剃刀”原则：

去冗余：如果技能 A 包含在技能 B 的逻辑内，合并它们。
去冲突：如果新技能与现有高置信度技能矛盾，通过 Judge 进行多轮投票。
原子化：确保每条技能只描述一个核心逻辑点。

【网络结构拓扑：技能库的形态】

技能库不再是杂乱的文本块，而是一个树形逻辑结构：

Root (根节点)：通用领域准则（如：安全第一原则）
- Branch (分支)：特定模块逻辑（如：电源管理模块）
  - Leaf (叶子/原子技能)：具体的寄存器操作顺序 ✋

3.4 为什么这套机制对学术/工业界有用？ 💡

对于本科生和研究生来说，最值得学习的是其“闭环思维”：

✋ 实时纠偏：不依赖人类标注，而是利用模型自身的逻辑一致性来纠错。
🧑‍💻 结构化知识转化：它证明了 LLM 不仅能做“阅读理解”，还能做“知识蒸馏”。
🚀 工业级应用：这套机制可以完美适配到私有化部署中。你只需要给它文档，让它自己在后台跑几个小时的“自演化”，就能得到一个比直接调用 GPT-4 还要懂你业务的“专家助手”。

学长点评：很多同学做实验发现模型不听话，就去拼命改 Prompt。但这篇论文告诉我们：建立一个让模型自我博弈、自我验证的机制，比写 100 个复杂的 Prompt 都要管用。 这种“程序化处理 Prompt 演化”的思想，就是目前 AI Agent 领域最前沿的玩法。

4. 实验结果：它是大模型的“逻辑外挂” 📊🚀

很多提升模型能力的方法需要动辄数周的 Fine-tuning (微调)，但 Ctx2Skill 另辟蹊径。它证明了：逻辑的进化，不一定要改动神经元的权重，改动“思考方式”同样有效。

4.1 核心优势：零成本、无痛叠加 🛡️

Zero-Weight Update (零参数修改) ✋：你不需要 A100 集群去跑训练，也不需要改动模型的一行参数。它运行在 Inference (推理) 侧，这意味着你可以把它套在 GPT-4、Claude 3.5 甚至你本地的 Llama 3 上。
Plug-and-Play (即插即用) 🧑‍💻：它产出的“技能库”本质上是一组高度浓缩的 System Prompt。

4.2 战绩复盘：CL-bench 上的惊人跳跃 📈

在专门针对长文本推理的 CL-bench 评测中，Ctx2Skill 表现出了极强的普适性：

模型底座 (Backbone)	原始胜率 (Base)	Ctx2Skill 加持后	相对提升幅度
GPT-4.1	11.1%	16.5%	+48.6%
Llama-3-70B	8.4%	12.2%	+45.2%
Qwen-2-72B	9.2%	13.5%	+46.7%

深入解析：虽然绝对值看起来从 11% 到 16% 只有几个百分点，但在复杂的逻辑推理领域（这类题目往往极难，随机猜测成功率为 0），近 50% 的相对增长意味着模型跨越了从“完全无法理解”到“能够处理复杂逻辑”的门槛。

4.3 拓扑结构：从“原始上下文”到“技能引导推理” 🕸️

我们可以通过下面的拓扑图看到 Ctx2Skill 是如何作为“逻辑过滤器”介入推理过程的：

代码段

4.4 代码实现：如何“挂载”提炼出的技能？ 💻

当 Ctx2Skill 完成了“闭关修炼”，它会产出一个 JSON 格式的技能清单。在实际生产环境（Inference）中，我们这样调用它：

# Ctx2Skill 产出的结构化技能示例
SKILLS_JSON = {
    "module": "Embedded_Kernel_Boot",
    "skills": [
        {"id": "S1", "rule": "初始化 NPU 前必须校验复位寄存器 0x10 的第 3 位为 1"},
        {"id": "S2", "rule": "如果返回值为 0xFFFF，说明硬件超时，需触发重试逻辑"}
    ]
}

def skill_wrapped_inference(query, document):
    """
    使用提炼出的技能库进行“外挂式”推理
    """
    # 1. 动态构建带有技能指引的上下文
    skill_prompt = "\n".join([f"- {s['rule']}" for s in SKILLS_JSON['skills']])
    
    final_prompt = f"""
    你现在是一名专家。在处理以下文档时，请务必遵循以下已验证的技能规则：
    {skill_prompt}
    
    文档内容：{document}
    用户问题：{query}
    请根据技能规则给出严谨的推理步骤。
    """
    
    # 2. 调用原始模型（无需微调）
    response = llm.call(final_prompt)
    return response

4.5 为什么这很重要？ 💡

对于正在做毕业设计或科研项目的同学，这提供了一个极佳的低成本提分思路：

突破 Context Window 限制：如果你有 100 万字的文档，模型不可能全看完。但如果你用 Ctx2Skill 把 100 万字提炼成 100 条核心技能，模型就能瞬间“掌握”整本书的精髓。
可解释性与确定性：在工业应用中，我们最怕大模型“一本正经地胡说八道”。Ctx2Skill 通过显式的规则引导，强迫模型按照既定逻辑思考，极大地增强了可靠性 (Robustness)。

有趣的小发现：这就像给大模型装了一个**“错题集”+“学霸笔记”**。模型不再是拿着整本书在考场上现翻，而是带着精简后的“公式小抄”进场，效率和准确率自然双双起飞！ 🚀🔥

5. 跨行业应用：Ctx2Skill 如何让 AI 真正“入行”？ 🌍🚀

目前的 AI 在行业应用中最大的障碍是“逻辑不可靠”。Ctx2Skill 的落地，意味着 AI 不再只是一个会说话的聊天机器人，而是一个能将行业文档自动转化为标准化作业程序（SOP）的资深专家。

5.1 法律行业：从“卷宗海洋”到“判决逻辑树” ⚖️🏛️

律师和法官最怕的不是找不到法律条文，而是如何在复杂的案件细节中应用这些条文。

痛点：同案不同判，或者在长达数千页的卷宗中忽略了关键的量刑细节。
Ctx2Skill 方案：它能从历史判例中提炼出“证据-定罪映射技能”。

【法律逻辑树结构图】

代码段

5.2 工业制造：从“硬件手册”到“实时故障排查专家” 🛠️⚙️

假设你在调试一块高性能的 RK3588 开发板，NPU 突然报错。翻阅 3000 页的技术手册简直是噩梦。✋

痛点：手册逻辑分散（如：寄存器 A 的配置在第 100 页，但其依赖项在第 2500 页）。
Ctx2Skill 方案：它可以预先对整个硬件文档进行“自博弈”，总结出一套硬件状态机维护技能。

【代码逻辑解析：工业 SOP 转化函数】

class IndustrialExpertAgent:
    def __init__(self, manual_path):
        # 预加载经过 Ctx2Skill 演化的技能库
        self.skill_set = ctx2skill.evolve(manual_path)

    def troubleshoot(self, error_code, log_data):
        # 1. 根据错误代码匹配“诊断技能”
        relevant_skill = self.skill_set.find("NPU_ERROR_0xAF")
        
        # 2. 执行技能中定义的检查程序（Procedure）
        # 技能描述可能包含：先查电平 -> 再看中断掩码 -> 最后重置 PLL
        diagnosis_path = relevant_skill.execute_logic(log_data)
        
        return f"诊断结论：{diagnosis_path['root_cause']}\n操作建议：{diagnosis_path['sop']}"

# 结果示例：不再是模棱两可的建议，而是具体的硬件操作序列

5.3 医疗科研：从“实验论文”到“标准化操作规程” 🧪🧬

面对最新的 Nature 论文，研究生最头疼的是如何复现实验步骤。论文往往为了篇幅省略了大量的“暗知识”。

痛点：实验参数微调（如：离心转速、温控梯度）在文中分布散乱。
Ctx2Skill 方案：它能通过对多篇同类论文的“跨时空回放（Cross-time Replay）”，提取出稳健的“实验协议合成技能”。

【科研协议提炼拓扑图】

代码段

5.4 为什么这种转变是“降维打击”？ 🚀

知识沉淀 (Knowledge Retention) ✋：老员工离职带走的往往是“经验技能”，而 Ctx2Skill 能把这种难以捕捉的经验从文档中强行“榨取”并留存下来。
降低门槛 (Lowering Barriers) 🧑‍💻：初级工程师或本科生不再需要死记硬背手册，只需要掌握如何调用 AI 提炼出的“技能库”。
零成本演化 (Zero-Cost Evolution) 🛡️：当行业标准或设备手册更新时，不需要重新训练大模型，只需要让 Ctx2Skill 针对新文档“闭关修炼”几个小时，技能库就会自动完成升级。

学长总结：Ctx2Skill 解决的是 AI 落地的最后 1 公里问题——“专业性”。它让 AI 拥有了从“通用闲聊”向“行业专家”转化的逻辑引擎。如果你以后从事 AI + 行业（如智能制造、数字法律），这种自动化提炼 SOP 的思路将是你手里的核心武器。

6. 深入研究：还有哪些“金矿”坑位可以抢占？💎🚀

如果你正在寻找本科毕设题目，或者刚入研一需要开题，Ctx2Skill 留下的这几个技术空白点，每一个都值得深挖。

6.1 效率优化：从“暴力博弈”到“轻量级演化” ⚡🧑‍💻

现状：目前的自博弈循环需要成百上千次的 LLM 调用。如果你用的是 GPT-4，提炼一个文档可能需要几十美金。

挖坑方向：如何实现“早停机制（Early Exit）”？即当系统发现技能库已经趋于稳定，或者新任务不再能触发错误时，自动结束演化。

【优化逻辑流图】

代码段

6.2 多模态技能提取：让 AI 看懂流程图 📊🖼️

现状：Ctx2Skill 目前主要处理的是文本（Textual Context）。但真正的专家手册里充满了 Mermaid 流程图、CAD 图纸、电路拓扑图。

挖坑方向：结合 VLM（多模态大模型），让 Reasoner 能够理解图表中的逻辑顺序。

有趣点：能否将图片中的逻辑直接转化为 if-else 的自然语言技能？例如从电路图里总结出“技能：若 VCC 无输出，优先检查电容 C10”。

6.3 技能冲突检测：解决“认知失调” 🛡️🤯

现状：当输入多个版本的文档（比如版本 A 和版本 B 的手册）时，规则可能冲突。

挖坑方向：开发一个“逻辑仲裁器（Arbitrator）”。

【代码逻辑：冲突检测函数解析】

def resolve_skill_conflict(skill_a, skill_b, judge_model):
    """
    当两条技能规则矛盾时的处理逻辑
    """
    # 1. 语义相似度检测
    if semantic_conflict(skill_a, skill_b):
        # 2. 溯源校验：看哪条规则在 Cross-time Replay 中表现更稳健
        score_a = historical_evaluator.get_score(skill_a)
        score_b = historical_evaluator.get_score(skill_b)
        
        # 3. 动态投票决定留存
        winner = judge_model.vote(skill_a, skill_b, context="最新的硬件补丁包")
        return winner