首页 理论 架构 工程 规划 文档 白皮书 著作 研究 案例 下载 博客 关于 联系 开始使用 →

第198章 DecisionEngine

第198章 DecisionEngine

198.1 DecisionEngine概述

在 ICAI(Individual Cognitive AI)体系中,DecisionEngine 是连接“可行候选”与“实际执行”的核心计算引擎。

前面的 MatchingEngine 负责判断候选是否满足要求,MethodEngine 负责计算方法及其适用条件,RiskEngine 负责计算风险,ConflictEngine 负责计算冲突,而 DecisionEngine 则在这些计算结果基础上回答一个核心问题:

当前条件下,应该选择哪个候选方案?

因此:

DecisionEngine = 候选方案 + 条件计算 + 决策计算 + 决策输出

可以表示为:

DE=(C,G,O,S,M,K,R,F,D,Ot)DE=(C,G,O,S,M,K,R,F,D,O_t)

其中:

  • CC:Candidate,候选方案;
  • GG:Goal,目标;
  • OO:Object,对象;
  • SS:State,当前状态;
  • MM:Method,可执行方法;
  • KK:Knowledge,知识;
  • RR:Rule,决策规则;
  • FF:Factor,决策因素;
  • DD:Decision Calculation,决策计算;
  • OtO_t:Output,决策输出。

DecisionEngine 不负责执行最终方案。

完整关系是:

候选方案 → 条件计算 → 决策计算 → 决策输出 → DecisionService → Behavior → Action → Execution

因此:

DecisionEngine≠BehaviorEngineDecisionEngine \neq BehaviorEngine DecisionEngine≠ActionEngineDecisionEngine \neq ActionEngine DecisionEngine≠ExecutionEngineDecisionEngine \neq ExecutionEngine

DecisionEngine 只负责完成“选择”。


198.2 Decision的基本定义

Decision 的中文含义是“决策”。

在 ICAI 中,Decision 不是简单的 Boolean 判断,也不是随机选择。

Decision 是在多个候选方案中,根据当前目标、状态、条件、能力、资源、风险、冲突、优先级和规则进行确定性计算后形成的选择结果。

可以定义:

Decision=(C,Co,R,H)Decision=(C,Co,R,H)

其中:

  • CC:Candidate,候选方案集合;
  • CoCo:Condition,决策条件;
  • RR:Result,决策结果;
  • HH:History,决策历史。

DecisionEngine 的任务则是:

DecisionEngine(C,Co,R)→DecisionResultDecisionEngine(C,Co,R)\rightarrow DecisionResult


198.3 候选方案

198.3.1 Candidate定义

Candidate 的中文含义是“候选方案”。

候选方案是已经进入当前决策范围、具备被比较和选择资格的对象。

候选方案可以是:

  • Method;
  • Capability;
  • Behavior;
  • Action;
  • Object;
  • Resource;
  • Route;
  • Strategy;
  • Protection;
  • Repair;
  • Goal;
  • 其他经过合法注册的决策对象。

因此:

Candidate={C1,C2,…,Cn}Candidate=\{C_1,C_2,\ldots,C_n\}

其中:

n≥0n\geq0

特别重要的是:

候选数量可以为0。

如果没有任何候选满足当前条件,DecisionEngine 不应该强制选择一个方案。


198.4 候选方案的结构

一个完整 Candidate 可以定义为:

Ci=(I,T,S,Co,R,E)C_i=(I,T,S,Co,R,E)

其中:

  • II:候选对象 ID;
  • TT:候选类型;
  • SS:候选当前状态;
  • CoCo:候选条件;
  • RR:候选所需资源;
  • EE:候选证据。

例如一个 Method Candidate:

C1=(MethodID,MethodType,Ready,Condition,Resource,Evidence)C_1= (MethodID, MethodType, Ready, Condition, Resource, Evidence)

DecisionEngine 不应该只拿一个 ID 进行选择。

它必须知道:

这个候选是什么、当前能不能执行、为什么能够执行、需要什么资源、有什么限制。


198.5 候选方案的来源

DecisionEngine 通常不会自己创建所有候选方案。

候选可以来自:

MethodEngine → Method Candidates

MatchingEngine → Matched Candidates

CapabilityEngine → Available Capabilities

RiskEngine → Handling Candidates

ConflictEngine → Conflict Handling Candidates

DiagnosisEngine → Repair Candidates

因此:

CandidateSource={Method,Matching,Capability,Risk,Conflict,Diagnosis}CandidateSource= \{ Method, Matching, Capability, Risk, Conflict, Diagnosis \}

DecisionEngine 将这些候选统一进入决策计算。


198.6 候选方案预过滤

在进入正式决策计算之前,需要先排除明显不具备选择资格的候选。

可以定义:

Eligible(Ci)=State∧Condition∧Capability∧Resource∧ValidityEligible(C_i)= State \land Condition \land Capability \land Resource \land Validity

如果:

Eligible(Ci)=falseEligible(C_i)=false

则:

Ci∉CvalidC_i\notin C_{valid}

因此:

Cvalid={Ci∣Eligible(Ci)=true}C_{valid} = \{C_i\mid Eligible(C_i)=true\}

这一步可以由 MatchingEngine、MethodEngine 等提前完成,也可以由 DecisionEngine 再次进行最终条件检查。


198.7 候选状态

Candidate 必须具有明确状态。

基础状态可以定义为:

  • Unknown;
  • Available;
  • Unavailable;
  • Blocked;
  • Eligible;
  • Selected;
  • Rejected;
  • Failed;
  • Expired;
  • Conflicted。

状态变化可以表示:

Unknown→Evaluated→Eligible→SelectedUnknown \rightarrow Evaluated \rightarrow Eligible \rightarrow Selected

或者:

Evaluated→RejectedEvaluated \rightarrow Rejected

以及:

Eligible→BlockedEligible \rightarrow Blocked

Candidate State 与 Decision Result 必须分离。

候选本身可以是 Available,但最终不一定被选择。

因此:

Available≠SelectedAvailable \neq Selected


198.8 条件计算

198.8.1 Decision Condition

Decision Condition 是决策计算时使用的条件集合。

可以定义:

DC=(G,C,M,O,E,R,P)DC=(G,C,M,O,E,R,P)

其中:

  • GG:Goal;
  • CC:Current Condition;
  • MM:Method;
  • OO:Object;
  • EE:Environment;
  • RR:Resource;
  • PP:Priority。

DecisionEngine 根据这些条件判断候选方案是否满足当前决策要求。


198.9 条件计算与方法条件的区别

必须区分:

Method Condition

回答:

“这个方法能不能执行?”

Decision Condition

回答:

“当前多个可执行方案中,应该如何比较和选择?”

例如:

Method A 要求:

Temperature<20Temperature<20

这是 Method Condition。

如果 Method A 和 Method B 都满足执行条件,而:

Method A 成本低;

Method B 风险低;

那么比较成本和风险就是 Decision Condition / Decision Factor。

因此:

MethodCondition≠DecisionConditionMethodCondition \neq DecisionCondition


198.10 条件计算过程

DecisionEngine 可以按照以下过程进行条件计算:

Load Candidate

↓

Load Goal

↓

Load Current State

↓

Load Capability

↓

Load Method

↓

Load Resource

↓

Load Risk

↓

Load Conflict

↓

Load Rule

↓

Evaluate Condition

↓

Candidate Eligibility

↓

Decision Factors

↓

Decision Calculation

这样可以确保决策不是脱离 Runtime 的静态选择。


198.11 条件结果

条件计算不能只返回 true / false。

可以定义:

ConditionResult=(C,V,R,E,S,T)ConditionResult=(C,V,R,E,S,T)

其中:

  • CC:Condition;
  • VV:Value;
  • RR:Comparison Result;
  • EE:Evidence;
  • SS:Status;
  • TT:Time。

条件结果可以为:

  • Pass;
  • Partial;
  • Fail;
  • Unknown;
  • Blocked;
  • Conflicted;
  • Expired。

例如:

Cost<100→PassCost<100 \rightarrow Pass ResourceAvailable=false→FailResourceAvailable=false \rightarrow Fail CurrentState=Unknown→UnknownCurrentState=Unknown \rightarrow Unknown

如果关键条件为 Unknown,则不能强行认为候选可用。


198.12 决策因素

DecisionEngine 可以将多个因素转换为离散计算指标。

例如:

  • Goal Priority;
  • Capability Match;
  • Method Validity;
  • Resource Availability;
  • Risk;
  • Conflict;
  • Cost;
  • Time;
  • Reliability;
  • Historical Experience;
  • Verification;
  • State Compatibility。

可以定义:

F={F1,F2,…,Fn}F=\{F_1,F_2,\ldots,F_n\}

每个因素都必须具有明确来源和计算方式。

例如:

Frisk=RiskScoreF_{risk}=RiskScore Fpriority=GoalPriorityF_{priority}=GoalPriority Fresource=ResourceAvailabilityF_{resource}=ResourceAvailability

这样决策结果能够解释“为什么选择”。


198.13 决策计算

决策计算是 DecisionEngine 的核心。

其基本模型为:

D(C1,C2,…,Cn,F,R)→DrD(C_1,C_2,\ldots,C_n,F,R)\rightarrow D_r

其中:

  • CiC_i:候选方案;
  • FF:决策因素;
  • RR:决策规则;
  • DrD_r:Decision Result。

在确定性系统中,可以使用离散规则和加权计算。

例如:

Score(Ci)=∑j=1mWjVijScore(C_i) = \sum_{j=1}^{m}W_jV_{ij}

其中:

  • WjW_j:第 jj 个因素的权重;
  • VijV_{ij}:候选 CiC_i 在因素 jj 上的评价值;
  • mm:因素数量。

这些权重不是神经网络权重。

它们是:

人工定义、规则定义、配置定义或经过明确统计验证的离散决策参数。


198.14 决策计算示例

假设存在三个候选:

C1,C2,C3C_1,C_2,C_3

考虑三个因素:

  • Goal Priority;
  • Risk;
  • Resource Availability。

可以定义:

Score(Ci)=WpPi+WrRi+WaAiScore(C_i) = W_pP_i + W_rR_i + W_aA_i

其中:

  • PiP_i:优先级值;
  • RiR_i:风险评价值;
  • AiA_i:资源可用性值。

如果:

Score(C1)=82Score(C_1)=82 Score(C2)=74Score(C_2)=74 Score(C3)=61Score(C_3)=61

则:

C1>C2>C3C_1>C_2>C_3

但还不能直接输出 C1。

因为还必须检查:

Eligible(C1)=trueEligible(C_1)=true

如果 C1 当前被 Blocked,那么即使 Score 最高,也不能选择。

因此:

SelectedCandidate=argmax(Score(Ci))SelectedCandidate = argmax(Score(C_i))

必须建立在:

Ci∈CvalidC_i\in C_{valid}

的基础上。


198.15 决策不是单纯最高分

ICAI 的 DecisionEngine 不应该把所有决策简化成:

HighestScore=SelectedHighestScore=Selected

因为某些条件属于硬约束。

例如:

Safety=falseSafety=false

即使:

Score=100Score=100

也不能选择。

因此决策可以分成:

第一层:硬条件

必须满足:

HardCondition(Ci)=trueHardCondition(C_i)=true

第二层:软因素

在满足硬条件的候选中比较:

SoftScore(Ci)SoftScore(C_i)

最终:

Selected=argmax(SoftScore(Ci))Selected = argmax \left( SoftScore(C_i) \right)

其中:

Ci∈Chard−validC_i\in C_{hard-valid}

这样可以避免“高分覆盖硬约束”的错误。


198.16 决策优先级

DecisionEngine 可以建立多层优先级:

合法性

→

安全性

→

目标满足程度

→

资源可用性

→

风险

→

成本

→

时间

→

历史经验

具体优先级必须由系统规则定义,而不能由 Engine 自行产生。

因此:

PriorityRule→DecisionEnginePriorityRule \rightarrow DecisionEngine

而不是:

DecisionEngine→RandomPriorityDecisionEngine \rightarrow RandomPriority


198.17 无候选决策

一个成熟的决策系统必须允许:

∣Cvalid∣=0|C_{valid}|=0

即:

没有任何合法候选方案。

此时不能强行选择。

Decision Result 应输出:

DecisionStatus=NoCandidateDecisionStatus=NoCandidate

并说明:

  • 为什么没有候选;
  • 哪些条件失败;
  • 哪些候选被 Blocked;
  • 是否存在 Conflict;
  • 是否存在 Risk;
  • 是否需要重新生成 Method;
  • 是否需要修改 Goal;
  • 是否需要人工介入。

因此:

NoCandidateNoCandidate

也是一个合法决策结果。


198.18 候选并列

如果:

Score(C1)=Score(C2)Score(C_1)=Score(C_2)

不能随机选择。

系统必须进一步使用确定性规则。

例如:

TieBreak=Priority→Risk→Cost→Time→IDTieBreak= Priority \rightarrow Risk \rightarrow Cost \rightarrow Time \rightarrow ID

最后使用唯一 ID 作为稳定排序条件。

因此:

Tie→DeterministicTieBreakTie \rightarrow DeterministicTieBreak

而不是:

Tie→RandomChoiceTie \rightarrow RandomChoice

这样可以保证同样输入得到稳定结果。


198.19 决策输出

198.19.1 DecisionResult

DecisionEngine 的最终输出可以定义为:

DR=(D,C,S,R,F,E,T)DR=(D,C,S,R,F,E,T)

其中:

  • DD:Decision ID;
  • CC:Selected Candidate;
  • SS:Decision Status;
  • RR:Reason;
  • FF:Factors;
  • EE:Evidence;
  • TT:Time。

Decision Result 至少应包含:

  1. Decision ID;
  2. Candidate List;
  3. Selected Candidate;
  4. Candidate State;
  5. Decision Conditions;
  6. Calculation;
  7. Reason;
  8. Evidence;
  9. Risk;
  10. Conflict;
  11. Decision Status;
  12. Time。

198.20 决策状态

Decision 本身也应该拥有生命周期。

可以定义:

Created→Evaluating→Calculated→Selected→ConfirmedCreated \rightarrow Evaluating \rightarrow Calculated \rightarrow Selected \rightarrow Confirmed

异常情况下:

Evaluating→FailedEvaluating \rightarrow Failed

或者:

Calculated→NoCandidateCalculated \rightarrow NoCandidate

也可以:

Selected→BlockedSelected \rightarrow Blocked

因为候选在选择之后仍然可能由于 Runtime 变化而失效。

因此:

Selected≠ExecutedSelected \neq Executed Executed≠SuccessfulExecuted \neq Successful Successful≠VerifiedSuccessful \neq Verified


198.21 决策输出与执行的边界

DecisionEngine 输出:

选择什么。

BehaviorEngine 负责:

如何组织执行。

ActionEngine 负责:

具体执行什么动作。

ExecutionEngine 负责:

实际运行。

因此完整关系为:

Decision→Behavior→Action→ExecutionDecision \rightarrow Behavior \rightarrow Action \rightarrow Execution

例如 DecisionEngine 输出:

SelectedMethod=M3SelectedMethod=M_3

并不意味着 M3 已经执行。

必须经过:

DecisionEngine → DecisionService → BehaviorService → BehaviorEngine → ActionEngine → ExecutionEngine

才能进入实际执行。


198.22 决策证据

DecisionEngine 必须具有可解释性。

决策结果应该能够回答:

为什么选择这个方案?

因此:

DecisionEvidence=Condition+Candidate+Calculation+Rule+ResultDecisionEvidence= Condition + Candidate + Calculation + Rule + Result

例如:

Candidate: Method-003
Condition: Capability available
Resource: Available
Risk: Low
Conflict: None
Goal Priority: High
Score: 86
Decision: Selected
Reason: Highest valid score under current constraints

这样决策可以被 History、Memory、Experience 和 LearningEngine 使用。


198.23 DecisionEngine与MatchingEngine

MatchingEngine 和 DecisionEngine 的边界必须明确。

MatchingEngine:

这个候选是否匹配要求?

DecisionEngine:

多个匹配候选中选择哪个?

因此:

MatchingEngine→MatchedCandidatesMatchingEngine \rightarrow MatchedCandidates

然后:

MatchedCandidates→DecisionEngineMatchedCandidates \rightarrow DecisionEngine

例如:

三个 Method:

M1,M2,M3M_1,M_2,M_3

MatchingEngine 得到:

M1=MatchedM_1=Matched M2=MatchedM_2=Matched M3=PartialM_3=Partial

DecisionEngine 再在符合决策条件的候选中进行选择。

所以:

Matching≠DecisionMatching \neq Decision


198.24 DecisionEngine与MethodEngine

MethodEngine 可以计算:

  • 方法结构;
  • 方法条件;
  • 方法过程;
  • Action;
  • Capability;
  • Resource;
  • Expected Result;
  • Method Verification。

DecisionEngine 则比较多个 Method。

因此:

MethodEngine→MethodCandidatesMethodEngine \rightarrow MethodCandidates DecisionEngine→SelectedMethodDecisionEngine \rightarrow SelectedMethod

MethodEngine 不应该因为某个方法 Score 高就直接执行。


198.25 DecisionEngine与RiskEngine

RiskEngine 提供:

RiskScoreRiskScore

DecisionEngine 使用:

RiskScoreRiskScore

参与候选比较。

例如:

Risk(C1)=20Risk(C_1)=20 Risk(C2)=60Risk(C_2)=60

如果其他条件相近,则 C1 可能具有更高决策优先级。

但:

RiskEngine≠DecisionEngineRiskEngine \neq DecisionEngine

RiskEngine 只计算风险。

DecisionEngine 决定如何使用风险结果。


198.26 DecisionEngine与ConflictEngine

ConflictEngine 提供:

  • Conflict Type;
  • Conflict Level;
  • Blocking State;
  • Handling Candidate。

DecisionEngine 决定:

  • 是否改变方案;
  • 是否暂停;
  • 是否重新排序;
  • 是否更换 Method;
  • 是否重新规划;
  • 是否人工介入。

因此:

ConflictEngine→HandlingCandidatesConflictEngine \rightarrow HandlingCandidates DecisionEngine→SelectedHandlingDecisionEngine \rightarrow SelectedHandling


198.27 DecisionEngine与KnowledgeEngine

KnowledgeEngine 提供经过验证的知识。

DecisionEngine 使用这些知识作为条件或证据。

例如:

Knowledge:ResourceX→ExclusiveKnowledge: Resource_X \rightarrow Exclusive

DecisionEngine 可以据此判断两个候选是否可以同时执行。

但:

KnowledgeEngine≠DecisionEngineKnowledgeEngine \neq DecisionEngine

KnowledgeEngine 计算知识。

DecisionEngine 使用知识进行决策计算。


198.28 DecisionEngine与Memory、Experience

Memory 和 Experience 可以提供历史依据。

例如:

历史记录显示:

M1M_1

在某类条件下曾经成功完成。

Experience 可以形成:

Condition_X \rightarrow Method_M_1

DecisionEngine 可以把这种经验作为一个因素。

但是:

Experience≠DecisionExperience \neq Decision

过去成功不能保证当前一定成功。

当前 Runtime、State、Condition 和 Verification 仍然具有优先权。


198.29 决策重新计算

Decision 不是一次永久结果。

当 Runtime 发生变化时:

Runtimet≠Runtimet+1Runtime_t\neq Runtime_{t+1}

原来的 Decision 可能失效。

因此:

Decisiont→StateChange→Recalculate→Decisiont+1Decision_t \rightarrow StateChange \rightarrow Recalculate \rightarrow Decision_{t+1}

例如:

原来:

M1=SelectedM_1=Selected

随后:

ResourceX=UnavailableResource_X=Unavailable

则:

M1=BlockedM_1=Blocked

DecisionEngine 必须重新计算候选:

M2,M3M_2,M_3

形成新的:

Decisiont+1Decision_{t+1}

这就是动态决策。


198.30 决策历史

每一次决策都必须保存历史。

Decision History 可以定义为:

DH=(D,C,F,R,S,T)DH=(D,C,F,R,S,T)

其中:

  • DD:Decision;
  • CC:Candidates;
  • FF:Factors;
  • RR:Result;
  • SS:Status;
  • TT:Time。

History 保存的是:

当时发生了什么决策。

Experience 保存的是:

从多个历史中形成了什么结构性经验。

因此:

DecisionHistory≠ExperienceDecisionHistory \neq Experience


198.31 PHP OOP工程实现

DecisionEngine 不应该直接操作数据库。

基础结构可以定义:

class DecisionEngine extends Engine
{
    public function calculate($input)
    {
        $candidates = $this->getCandidates($input);
        $eligible = array();

        foreach ($candidates as $candidate) {
            $condition = $this->calculateCondition(
                $candidate,
                $input
            );

            if ($condition['status'] === 'Pass') {
                $eligible[] = $candidate;
            }
        }

        if (count($eligible) === 0) {
            return new EngineResult(
                $input,
                null,
                array(
                    'status' => 'NoCandidate'
                ),
                'decision_calculation'
            );
        }

        $calculated = array();

        foreach ($eligible as $candidate) {
            $calculated[] = $this->calculateCandidateScore(
                $candidate,
                $input
            );
        }

        $selected = $this->selectBestCandidate(
            $calculated,
            $input
        );

        return new EngineResult(
            $input,
            $selected,
            $calculated,
            'decision_calculation'
        );
    }

    protected function getCandidates($input)
    {
        return isset($input['candidates'])
            ? $input['candidates']
            : array();
    }

    protected function calculateCondition($candidate, $input)
    {
        return array(
            'status' => 'Pass'
        );
    }

    protected function calculateCandidateScore($candidate, $input)
    {
        return array(
            'candidate' => $candidate,
            'score' => 0
        );
    }

    protected function selectBestCandidate($candidates, $input)
    {
        $best = null;

        foreach ($candidates as $candidate) {
            if ($best === null ||
                $candidate['score'] > $best['score']) {
                $best = $candidate;
            }
        }

        return $best;
    }
}

这个结构体现的是 DecisionEngine 的工程职责:

输入候选 → 条件计算 → 候选计算 → 选择 → EngineResult

其中具体项目中的条件、评分、权重、约束和验证规则必须由实际系统规则实现,不能把示例代码中的默认值直接视为已经完成的生产规则。


198.32 DecisionService与DecisionEngine

DecisionService 负责流程组织。

DecisionEngine 负责计算。

可以定义:

DecisionService=OrchestrationDecisionService=Orchestration DecisionEngine=ComputationDecisionEngine=Computation

例如:

class DecisionService
{
    protected $engine;
    protected $repository;

    public function __construct($engine, $repository)
    {
        $this->engine = $engine;
        $this->repository = $repository;
    }

    public function decide($context)
    {
        $result = $this->engine->calculate($context);

        $this->repository->save($result);

        return $result;
    }
}

调用关系:

Controller → DecisionService → DecisionEngine → EngineResult → DecisionRepository → MySQL


198.33 数据库结构

DecisionEngine 的计算结果可以通过 Repository 保存。

基础表可以包括:

decisions

保存决策主体:

  • id
  • individual_id
  • goal_id
  • selected_candidate_id
  • selected_candidate_type
  • status
  • reason
  • created_at
  • updated_at

decision_candidates

保存参与决策的候选:

  • id
  • decision_id
  • candidate_id
  • candidate_type
  • state
  • eligibility
  • score
  • rank
  • reason

decision_conditions

保存决策条件:

  • id
  • decision_id
  • condition_type
  • condition_value
  • result
  • evidence
  • created_at

decision_results

保存最终结果:

  • id
  • decision_id
  • selected_candidate_id
  • result_status
  • calculation
  • reason
  • verification
  • created_at

decision_history

保存决策生命周期:

  • id
  • decision_id
  • old_state
  • new_state
  • reason
  • created_at

数据库负责保存事实和历史。

DecisionEngine 负责计算。


198.34 决策完整工程流程

DecisionEngine 的完整流程可以表示为:

Load Runtime

↓

Load Goal

↓

Load Current State

↓

Load Candidates

↓

Load Capability

↓

Load Method

↓

Load Resource

↓

Load Knowledge

↓

Load Risk

↓

Load Conflict

↓

Load Decision Rules

↓

Candidate Validation

↓

Condition Calculation

↓

Eligibility Calculation

↓

Factor Calculation

↓

Candidate Scoring

↓

Candidate Ranking

↓

Tie Breaking

↓

Candidate Selection

↓

Decision Verification

↓

DecisionResult

↓

DecisionService

↓

BehaviorService

↓

BehaviorEngine

↓

ActionEngine

↓

ExecutionEngine


198.35 决策完整闭环

DecisionEngine 的动态闭环可以表示为:

Goal→Candidate→Condition→Calculation→Selection→Decision→Behavior→Action→Execution→Result→Feedback→StateUpdate→ReDecisionGoal \rightarrow Candidate \rightarrow Condition \rightarrow Calculation \rightarrow Selection \rightarrow Decision \rightarrow Behavior \rightarrow Action \rightarrow Execution \rightarrow Result \rightarrow Feedback \rightarrow StateUpdate \rightarrow ReDecision

如果执行成功:

Decision→Execution→Result→VerificationDecision \rightarrow Execution \rightarrow Result \rightarrow Verification

如果执行失败:

Decision→Failure→Diagnosis→Repair→Verification→ReDecisionDecision \rightarrow Failure \rightarrow Diagnosis \rightarrow Repair \rightarrow Verification \rightarrow ReDecision

如果执行过程中出现新的风险:

Decision→Risk→Handling→ReDecisionDecision \rightarrow Risk \rightarrow Handling \rightarrow ReDecision

如果出现新的冲突:

Decision→Conflict→ConflictHandling→ReDecisionDecision \rightarrow Conflict \rightarrow ConflictHandling \rightarrow ReDecision

因此 DecisionEngine 是 ICAI 动态认知循环中的重要重新计算节点。


198.36 决策的确定性原则

ICAI 的 DecisionEngine 必须满足确定性原则。

相同输入:

Inputt=Inputt+1Input_t=Input_{t+1}

以及相同:

Rulet=Rulet+1Rule_t=Rule_{t+1}

则:

Decisiont=Decisiont+1Decision_t=Decision_{t+1}

除非时间、状态、环境或其他显式输入发生变化。

因此:

SameInput+SameRule→SameDecisionSameInput+SameRule \rightarrow SameDecision

而不是:

SameInput→RandomDecisionSameInput \rightarrow RandomDecision

这也是 ICAI 与基于生成式模型的随机输出机制的重要工程区别。


198.37 决策计算的可解释性

任何最终决策都应该能够回溯:

Decision→Candidate→Condition→Factor→Rule→Calculation→EvidenceDecision \rightarrow Candidate \rightarrow Condition \rightarrow Factor \rightarrow Rule \rightarrow Calculation \rightarrow Evidence

因此系统能够回答:

为什么没有选择 Candidate A?

为什么选择 Candidate B?

Candidate C 为什么被阻塞?

哪个条件导致 Candidate A 失效?

哪个风险降低了 Candidate B 的优先级?

哪个冲突导致 Candidate C 被排除?

这种可追溯结构是 ICAI 工程认知系统的重要基础。


198.38 DecisionEngine的工程边界

DecisionEngine 必须保持明确职责。

第一,负责候选方案计算。

第二,负责决策条件计算。

第三,负责候选比较。

第四,负责决策评分或规则计算。

第五,负责候选排序。

第六,负责最终决策结果生成。

第七,负责输出决策理由和证据。

但 DecisionEngine:

不直接执行 Action。

不直接运行 Behavior。

不直接修改外部对象。

不负责数据库持久化。

不负责诊断实际故障。

不负责修复故障。

不负责生成知识。

不负责经验学习。

它只负责:

Candidate→Condition→Calculation→DecisionCandidate \rightarrow Condition \rightarrow Calculation \rightarrow Decision


198.39 DecisionEngine核心公式

本章可以将 DecisionEngine 的核心计算归纳为:

候选集合

C={C1,C2,…,Cn}C=\{C_1,C_2,\ldots,C_n\}

候选有效性

Eligible(Ci)=State∧Condition∧Capability∧Resource∧ValidityEligible(C_i) = State \land Condition \land Capability \land Resource \land Validity

有效候选集合

Cv={Ci∣Eligible(Ci)=true}C_v= \{C_i\mid Eligible(C_i)=true\}

决策评分

Score(Ci)=∑j=1mWjVijScore(C_i) = \sum_{j=1}^{m}W_jV_{ij}

候选选择

Selected=argmaxCi∈CvScore(Ci)Selected = argmax_{C_i\in C_v} Score(C_i)

无候选

∣Cv∣=0⇒DecisionStatus=NoCandidate|C_v|=0 \Rightarrow DecisionStatus=NoCandidate

决策输出

DecisionResult=Selected+Reason+Condition+Calculation+Evidence+StatusDecisionResult = Selected + Reason + Condition + Calculation + Evidence + Status

最终形成:

Candidate→Condition→Calculation→Ranking→Selection→DecisionOutputCandidate \rightarrow Condition \rightarrow Calculation \rightarrow Ranking \rightarrow Selection \rightarrow DecisionOutput


198.40 本章总结

DecisionEngine 是 ICAI 中负责候选方案、条件计算、决策计算和决策输出的核心 Engine。

它不是简单的“选择器”,而是建立在 Object、State、Goal、Capability、Method、Knowledge、Resource、Risk、Conflict、Memory、Experience 和 Rule 等结构化信息之上的确定性计算机制。

其核心流程是:

候选方案 → 条件计算 → 有效性判断 → 决策因素 → 决策计算 → 候选排序 → 最终选择 → 决策输出

DecisionEngine 必须允许:

有多个候选。

只有一个候选。

没有候选。

多个候选并列。

候选被阻塞。

候选条件未知。

候选之间存在冲突。

这些情况都必须通过明确状态和规则进行处理,而不能通过随机选择解决。

在 ICAI 的完整工程体系中:

MatchingEngine 判断是否匹配。

MethodEngine 计算方法。

RiskEngine 计算风险。

ConflictEngine 计算冲突。

DecisionEngine 负责最终选择。

随后:

Decision → Behavior → Action → Execution → Result → Feedback → State Update → ReDecision

由此形成动态决策闭环。

DecisionEngine 的核心原则可以归纳为:

候选必须可解释,条件必须可计算,选择必须有依据,结果必须可追溯,没有合法候选时必须允许“不决策”,决策完成后必须经过实际执行与结果验证。

最终:

ICAI Decision=Candidate+Condition+Calculation+Selection+OutputICAI\ Decision = Candidate + Condition + Calculation + Selection + Output

这使 DecisionEngine 成为 ICAI 从“能够识别对象、状态和方法”进一步进入“能够在当前条件下进行确定性选择”的核心认知计算层。

Leave a Reply

Your email address will not be published. Required fields are marked *

客服咨询
● 欢迎咨询与合作
您好!欢迎咨询。 我可以帮助您了解人工智能技术研发、智能软件系统开发、网站建设、搜索优化及项目定制等相关信息。 请问有什么可以帮您?
免费申请
请填写以下信息,方便我们进一步沟通。
欢迎咨询 AI 系统开发、网站建设、搜索优化、项目定制合作
电话:15089196448
邮箱:1602401899@qq.com
地址:陕西省渭南市
服务时间:周一至周五 09:00 - 18:00 | 7×24小时技术值守