决策模块

如果说感知模块是智能体的"眼睛和耳朵"，那么决策模块就是智能体的"大脑"。决策模块负责基于感知到的信息，分析当前形势、评估可选方案并选择最优行动路径。决策的质量直接决定了智能体的行为是否有效、是否可靠。本章将深入探讨三种主要的决策范式：基于规则的决策、基于机器学习的决策和基于大语言模型的决策，分析它们各自的优势、局限性和适用场景。

基于规则的决策

基于规则的决策（Rule-based Decision Making）是最古老也是最直观的决策方式。它的核心思想是将人类专家的知识编码为一系列"如果-那么"（if-then）规则，智能体根据当前状态匹配规则并执行对应的行动。

规则决策系统的关键组成部分包括：

• 规则库（Rule Base）：存储所有决策规则的集合。每条规则由条件部分（前件）和动作部分（后件）组成。例如："如果CPU使用率超过90%且持续时间超过5分钟，那么触发扩容操作"。
• 推理引擎（Inference Engine）：负责将当前状态与规则库进行匹配，找出所有满足条件的规则。当多条规则同时被触发时，推理引擎需要解决冲突——决定哪条规则优先执行。
• 工作内存（Working Memory）：存储当前环境状态和中间推理结果。推理引擎基于工作内存中的信息进行规则匹配。

规则决策的优势在于透明性和可预测性——每一条决策都可以追溯到具体的规则，便于审计和调试。但它也有明显的局限：规则库的维护成本高，规则之间可能产生冲突，且无法处理未曾编码的新情况。

# 基于规则的决策引擎示例

class RuleBasedDecisionEngine:
    """基于规则的决策引擎"""

    def __init__(self):
        self.rules = []
        self.facts = {}  # 工作内存

    def add_rule(self, name, condition, action, priority=0):
        """添加决策规则"""
        self.rules.append({
            "name": name,
            "condition": condition,   # 条件函数
            "action": action,         # 动作函数
            "priority": priority,     # 优先级（越高越优先）
            "fired": False
        })

    def update_facts(self, new_facts):
        """更新工作内存"""
        self.facts.update(new_facts)

    def evaluate(self):
        """评估所有规则并执行"""
        # 1. 找出所有满足条件的规则
        triggered = []
        for rule in self.rules:
            if rule["condition"](self.facts):
                triggered.append(rule)

        if not triggered:
            return "no_rule_matched"

        # 2. 按优先级排序，解决冲突
        triggered.sort(key=lambda r: r["priority"], reverse=True)

        # 3. 执行最高优先级的规则
        selected = triggered[0]
        result = selected["action"](self.facts)

        return {
            "rule": selected["name"],
            "result": result,
            "alternatives": [r["name"] for r in triggered[1:]]
        }

# 使用示例
engine = RuleBasedDecisionEngine()

# 添加规则
engine.add_rule(
    name="紧急扩容",
    condition=lambda f: f.get("cpu", 0) > 95 and f.get("duration", 0) > 300,
    action=lambda f: f"立即扩容：当前CPU={f['cpu']}%",
    priority=10
)

engine.add_rule(
    name="普通告警",
    condition=lambda f: f.get("cpu", 0) > 80,
    action=lambda f: f"发送告警：CPU={f['cpu']}%",
    priority=5
)

engine.add_rule(
    name="日志记录",
    condition=lambda f: f.get("cpu", 0) > 60,
    action=lambda f: f"记录日志：CPU={f['cpu']}%",
    priority=1
)

# 更新状态并决策
engine.update_facts({"cpu": 97, "duration": 360})
decision = engine.evaluate()
print(f"决策: {decision}")
# 输出: 决策: {'rule': '紧急扩容', 'result': '立即扩容：当前CPU=97%', ...}

基于机器学习的决策

基于机器学习的决策方式让智能体从历史数据中学习决策模式，而不是依赖人工编写的规则。这种方法特别适合那些规则难以显式表达、但存在大量历史数据的场景。

常见的ML决策方法包括：

分类决策：将当前状态分类到预定义的类别中，每个类别对应一种行动。例如，将客户投诉分类为"退款"、"换货"或"补偿"类别，然后自动执行对应的处理流程。常用的分类算法包括决策树、随机森林、SVM和神经网络。

回归预测：预测某个连续值，然后基于预测值做出决策。例如，预测未来一小时的用户请求量，然后据此调整服务器资源。回归模型可以捕捉数据中的复杂非线性关系。

强化学习决策：智能体通过与环境交互来学习最优决策策略。强化学习不需要标注数据，而是通过奖励信号来指导学习。它特别适合序列决策问题，如游戏AI、机器人控制和资源调度。

基于大语言模型的决策

大语言模型（LLM）的出现为智能体决策带来了革命性的变化。LLM具备强大的自然语言理解、逻辑推理和知识运用能力，使其成为一种全新的决策引擎。

LLM决策的核心优势包括：

• 零样本/少样本决策：LLM无需针对特定任务进行训练，仅通过提示词（Prompt）就能做出合理决策。这极大地降低了决策系统的开发成本。
• 上下文理解：LLM能够理解复杂的上下文信息，包括用户的隐含意图、历史对话背景和多源信息的关联关系。
• 推理链：通过思维链（Chain of Thought）等技术，LLM可以展示其决策的推理过程，提高决策的可解释性。
• 创造性解决方案：面对新颖的问题，LLM能够综合已有知识生成创新性的解决方案，而不是局限于预定义的规则或已见的模式。

# 基于LLM的决策模块示例

class LLMDecisionEngine:
    """基于大语言模型的决策引擎"""

    def __init__(self, llm_client):
        self.llm = llm_client
        self.decision_history = []

    def decide(self, context, options, criteria=None):
        """
        基于LLM进行决策
        context: 当前环境信息
        options: 可选方案列表
        criteria: 评估标准
        """
        # 构建决策提示
        prompt = f"""你是一个决策分析专家。请基于以下信息做出决策。

## 当前情况
{context}

## 可选方案
{self._format_options(options)}

## 评估标准
{criteria or '综合考虑效率、风险和可行性'}

请按以下格式输出：
1. 逐一分析每个方案的优缺点
2. 给出推荐方案及理由
3. 给出备选方案及触发条件
"""
        # 调用LLM
        response = self.llm.generate(prompt)

        # 解析决策结果
        decision = self._parse_decision(response, options)

        # 记录决策历史
        self.decision_history.append({
            "context": context,
            "options": options,
            "decision": decision
        })

        return decision

    def decide_with_reflection(self, context, options):
        """带反思机制的决策 - 提高决策质量"""
        # 第一轮：初步决策
        initial = self.decide(context, options)

        # 第二轮：自我反思
        reflection_prompt = f"""请审视你刚才的决策：
初步方案: {initial['recommendation']}
理由: {initial['reasoning']}

请思考：
1. 是否遗漏了重要因素？
2. 风险评估是否充分？
3. 是否有更好的方案？
"""
        reflection = self.llm.generate(reflection_prompt)

        # 第三轮：修正决策
        final = self.decide(
            context=f"{context}\n\n反思结果: {reflection}",
            options=options
        )
        final["reflection"] = reflection
        return final

    def _format_options(self, options):
        formatted = ""
        for i, opt in enumerate(options, 1):
            formatted += f"{i}. {opt['name']}: {opt['description']}\n"
        return formatted

    def _parse_decision(self, response, options):
        return {
            "recommendation": options[0]["name"] if options else None,
            "reasoning": response,
            "confidence": 0.85,
            "timestamp": __import__("time").time()
        }

决策模块的工程挑战

在实际项目中实现决策模块，需要解决几个关键的工程挑战：

决策延迟：LLM决策通常需要数秒时间，对于实时性要求高的场景可能不可接受。解决方案包括：缓存常见决策、使用小模型做初步筛选、异步决策等。

决策一致性：相同的输入在不同时间可能产生不同的决策结果（尤其是LLM）。在需要确定性的场景中，需要通过温度参数控制、结果验证或回退到规则决策来保证一致性。

决策安全：错误的决策可能导致严重后果。决策模块需要内置安全检查机制，包括决策边界约束（不允许某些危险操作）、人工确认环节（高风险决策需人工审批）和回滚能力（决策执行后可以撤销）。

本章小结

决策模块是智能体的核心"大脑"，负责将感知信息转化为行动方案。基于规则的决策透明可预测但缺乏灵活性；基于机器学习的决策具备泛化能力但可解释性差；基于LLM的决策灵活强大但存在延迟和一致性问题。在实际项目中，混合决策策略往往是最优选择——用规则处理常规情况，用LLM处理复杂场景。下一章我们将探讨执行模块，看看决策如何转化为实际行动。