AI决策系统：从规则引擎到模型驱动的智能决策架构

AI决策系统：从规则引擎到模型驱动的智能决策架构

一、当业务规则膨胀到无法维护：规则引擎的扩展性瓶颈

传统业务决策系统基于规则引擎：将业务策略编码为 IF-THEN 规则，输入数据匹配规则后输出决策。这种方式在规则数量较少时清晰可控，但当规则增长到数百条时，维护成本急剧上升。规则之间的冲突、优先级和例外情况让系统变得脆弱——新增一条规则可能意外影响其他规则的执行结果。

一个典型的场景：信贷审批系统有 300 条规则，覆盖了收入、负债、征信、行业等维度。每次政策调整都需要在规则丛林中找到需要修改的规则，同时确认不影响其他规则的判定。更严重的是，规则只能覆盖已知模式，对于规则之间的交互效应（如收入低但行业前景好的申请人），规则引擎无法做出综合判断。

AI 决策系统的核心思路是：用模型替代部分规则，让模型学习数据中的决策模式，同时保留关键规则作为安全护栏。这不是完全替代规则引擎，而是将确定性的规则和概率性的模型结合，形成更灵活、更可维护的决策架构。

二、AI决策系统架构：规则与模型的混合决策框架

graph TD
    A[决策请求] --> B[前置规则检查]
    B --> C{规则命中?}
    C -->|明确拒绝| D[返回拒绝决策]
    C -->|明确通过| E[返回通过决策]
    C -->|需综合判断| F[特征工程]

    F --> G[模型推理]
    G --> H[决策分数]

    H --> I[后置规则校验]
    I --> J{分数在边界?}
    J -->|是| K[人工审核]
    J -->|否| L[自动决策]

    K --> M[最终决策]
    L --> M

    M --> N[决策记录]
    N --> O[反馈数据收集]
    O --> P[模型重训练]

    subgraph 规则层
        B
        C
        D
        E
        I
        J
        K
    end

    subgraph 模型层
        F
        G
        H
    end

    subgraph 闭环层
        N
        O
        P
    end

前置规则处理确定性高的场景：黑名单直接拒绝、白名单直接通过、必填字段缺失直接退回。这些场景不需要模型判断，规则执行更快且结果确定。

模型处理需要综合判断的场景：多个因素交叉影响、规则无法覆盖的边界情况、以及需要根据历史数据做出概率性判断的决策。

后置规则作为安全护栏：模型输出的分数在决策边界附近时，转人工审核；模型输出与业务常识矛盾时，用规则覆盖模型决策。

三、AI决策系统实现

3.1 混合决策引擎

# decision_engine.py 混合决策引擎

from dataclasses import dataclass
from typing import List, Optional
from enum import Enum

class DecisionType(Enum):
    APPROVE = "通过"
    REJECT = "拒绝"
    REVIEW = "人工审核"

@dataclass
class DecisionResult:
    """决策结果"""
    decision: DecisionType
    confidence: float        # 决策置信度 0-1
    reasons: List[str]       # 决策原因
    rule_hits: List[str]     # 命中的规则
    model_score: Optional[float]  # 模型分数
    requires_review: bool    # 是否需要人工审核

class HybridDecisionEngine:
    """混合决策引擎：规则+模型"""

    def __init__(self, rule_engine, model, config):
        self.rule_engine = rule_engine
        self.model = model
        self.config = config

    def decide(self, application: dict) -> DecisionResult:
        """执行混合决策流程"""

        # Step 1: 前置规则检查
        rule_result = self.rule_engine.evaluate(application)

        if rule_result.decisive:
            # 规则给出确定性结论，直接返回
            return DecisionResult(
                decision=rule_result.decision,
                confidence=1.0,
                reasons=rule_result.reasons,
                rule_hits=rule_result.matched_rules,
                model_score=None,
                requires_review=False,
            )

        # Step 2: 特征工程
        features = self._extract_features(application)

        # Step 3: 模型推理
        model_score = self.model.predict(features)
        model_confidence = self.model.predict_proba(features)

        # Step 4: 后置规则校验
        review_needed = self._check_review_conditions(
            model_score, model_confidence, application
        )

        # Step 5: 确定最终决策
        if review_needed:
            decision = DecisionType.REVIEW
        elif model_score >= self.config.approve_threshold:
            decision = DecisionType.APPROVE
        elif model_score <= self.config.reject_threshold:
            decision = DecisionType.REJECT
        else:
            decision = DecisionType.REVIEW

        return DecisionResult(
            decision=decision,
            confidence=model_confidence,
            reasons=self._generate_reasons(
                rule_result, model_score, features
            ),
            rule_hits=rule_result.matched_rules,
            model_score=model_score,
            requires_review=review_needed,
        )

    def _check_review_conditions(self, score: float,
                                  confidence: float,
                                  application: dict) -> bool:
        """检查是否需要人工审核"""
        # 条件1：模型置信度低
        if confidence < self.config.min_confidence:
            return True

        # 条件2：分数在决策边界附近
        boundary = self.config.approve_threshold - self.config.reject_threshold
        if abs(score - (self.config.approve_threshold + self.config.reject_threshold) / 2) < boundary * 0.1:
            return True

        # 条件3：特定业务场景强制审核
        if application.get("amount", 0) > self.config.large_amount_threshold:
            return True

        return False

3.2 规则引擎实现

# rule_engine.py 规则引擎

from dataclasses import dataclass
from typing import List, Callable, Optional

@dataclass
class Rule:
    """决策规则"""
    id: str
    name: str
    condition: Callable[[dict], bool]  # 条件函数
    decision: DecisionType             # 命中时的决策
    priority: int                      # 优先级（数值越小越高）
    reason: str                        # 决策原因描述

@dataclass
class RuleResult:
    """规则评估结果"""
    decisive: bool                     # 是否给出确定性结论
    decision: Optional[DecisionType]
    reasons: List[str]
    matched_rules: List[str]

class RuleEngine:
    """规则引擎"""

    def __init__(self):
        self.rules: List[Rule] = []

    def add_rule(self, rule: Rule):
        """添加规则"""
        self.rules.append(rule)
        # 按优先级排序
        self.rules.sort(key=lambda r: r.priority)

    def evaluate(self, application: dict) -> RuleResult:
        """评估所有规则"""
        matched_rules = []
        reasons = []

        for rule in self.rules:
            try:
                if rule.condition(application):
                    matched_rules.append(rule.id)
                    reasons.append(f"[{rule.name}] {rule.reason}")

                    # 拒绝规则立即返回
                    if rule.decision == DecisionType.REJECT:
                        return RuleResult(
                            decisive=True,
                            decision=DecisionType.REJECT,
                            reasons=reasons,
                            matched_rules=matched_rules,
                        )
            except Exception as e:
                # 规则执行异常，记录但不中断
                reasons.append(f"[{rule.name}] 规则执行异常: {e}")

        # 如果有通过规则命中，且无拒绝规则
        approve_rules = [
            r for r in self.rules
            if r.id in matched_rules and r.decision == DecisionType.APPROVE
        ]
        if approve_rules and not any(
            r.decision == DecisionType.REJECT for r in self.rules
            if r.id in matched_rules
        ):
            return RuleResult(
                decisive=True,
                decision=DecisionType.APPROVE,
                reasons=reasons,
                matched_rules=matched_rules,
            )

        # 规则无法给出确定性结论，需要模型判断
        return RuleResult(
            decisive=False,
            decision=None,
            reasons=reasons,
            matched_rules=matched_rules,
        )

# 注册业务规则
engine = RuleEngine()

# 黑名单规则（最高优先级）
engine.add_rule(Rule(
    id="R001",
    name="黑名单检查",
    condition=lambda app: app.get("user_id") in BLACKLIST,
    decision=DecisionType.REJECT,
    priority=1,
    reason="用户在黑名单中",
))

# 必填字段检查
engine.add_rule(Rule(
    id="R002",
    name="必填字段检查",
    condition=lambda app: not app.get("income") or not app.get("credit_score"),
    decision=DecisionType.REJECT,
    priority=2,
    reason="缺少必填字段（收入或信用分）",
))

# 信用分硬性下限
engine.add_rule(Rule(
    id="R003",
    name="信用分下限",
    condition=lambda app: app.get("credit_score", 0) < 400,
    decision=DecisionType.REJECT,
    priority=3,
    reason="信用分低于最低要求(400)",
))

# VIP客户快速通道
engine.add_rule(Rule(
    id="R004",
    name="VIP快速通道",
    condition=lambda app: app.get("vip_level", 0) >= 3 and app.get("credit_score", 0) >= 700,
    decision=DecisionType.APPROVE,
    priority=10,
    reason="VIP客户且信用分优秀，快速通过",
))

四、AI决策系统的可解释性与合规挑战

AI 决策系统在金融、医疗等受监管行业中，必须满足可解释性要求。用户有权知道"为什么被拒绝"，监管机构要求决策逻辑可审计。纯模型决策（尤其是深度学习）是黑盒，无法提供可解释的决策原因。解决方案是：使用可解释模型（如逻辑回归、决策树）作为主模型，复杂模型作为辅助；或者使用 SHAP/LIME 等事后解释工具为模型决策提供特征贡献度分析。

模型漂移是长期运行的风险。训练数据分布随时间变化（如经济环境变化导致违约率上升），模型预测的准确性会逐渐下降。需要建立模型监控体系：定期评估模型在最新数据上的表现，当性能低于阈值时触发重训练。

规则与模型的冲突处理需要明确策略。当规则判定拒绝但模型判定通过时，应该以哪个为准？生产环境中的常见策略是：拒绝规则优先（安全第一），通过规则可以与模型分数加权融合。

五、总结

AI 决策系统的核心架构是"规则+模型"的混合框架：前置规则处理确定性场景，模型处理需要综合判断的场景，后置规则作为安全护栏。工程实现中需要重点关注的三个问题：可解释性（受监管行业必须提供决策原因）、模型漂移（定期评估和重训练）、规则与模型的冲突策略（拒绝规则优先）。AI 决策不是替代规则，而是将规则无法覆盖的灰色地带交给模型处理，同时用规则为模型决策划定安全边界。