第204章　DiagnosisEngine

204.1 DiagnosisEngine概述

在 ICAI 中，系统执行行为以后可能出现：

实际结果与预期结果不一致；
当前状态与目标状态不一致；
Action 执行失败；
Behavior 执行失败；
Method 无法完成；
Capability 无法满足；
Object 状态异常；
Environment 发生异常变化；
Relation 出现冲突；
Resource 不可用；
Rule 与实际状态不一致。

这些情况不能简单统一为：

Failed

因为：

$Failure≠DiagnosisFailure\neq Diagnosis$

Failure 表示：

实际发生了失败或异常结果。

Diagnosis 表示：

对异常为什么发生进行结构化原因分析。

因此，本章定义：

$DiagnosisEngine=AbnormalityCalculation+CauseAnalysis+DiagnosisResultDiagnosisEngine = AbnormalityCalculation + CauseAnalysis + DiagnosisResult$

即：

DiagnosisEngine 是 ICAI 中负责异常计算、原因分析、诊断候选生成、原因验证以及诊断结果输出的确定性认知计算引擎。

204.2 Abnormality、Failure与Diagnosis

三个概念必须严格区分。

Abnormality

Abnormality 表示：

当前实际情况偏离了预期、正常状态或者约束条件。

定义：

$A=(O,E,X,C,S,T)A=(O,E,X,C,S,T)$

其中：

$AA$ ：Abnormality；
$OO$ ：Object；
$EE$ ：Expected；
$XX$ ：Actual；
$CC$ ：Condition；
$SS$ ：State；
$TT$ ：Time。

Failure

Failure 是一种更明确的异常结果。

例如：

$Expected=SuccessExpected=Success$ $Actual=FailedActual=Failed$

则：

$Failure=TrueFailure=True$

但异常不一定都是 Failure。

例如：

$ExpectedTemperature=50ExpectedTemperature=50$ $ActualTemperature=65ActualTemperature=65$

系统可能先得到：

$Abnormality=DetectedAbnormality=Detected$

而不立即判定整个行为失败。

因此：

$Abnormality⊃FailureAbnormality \supset Failure$

Diagnosis

Diagnosis 负责解释：

为什么出现这个异常？

因此：

$Result→Abnormality→DiagnosisResult \rightarrow Abnormality \rightarrow Diagnosis$

而不是：

$Result→DiagnosisResult \rightarrow Diagnosis$

必须先确认存在异常事实。

204.3 Diagnosis模型

第165章定义：

$Diagnosis=(P,E,C,R,S)Diagnosis=(P,E,C,R,S)$

其中：

$PP$ ：Problem，问题；
$EE$ ：Evidence，证据；
$CC$ ：Cause，原因；
$RR$ ：Recommendation，处理建议；
$SS$ ：State，诊断状态。

因此：

$Diagnosis=Problem+Evidence+Cause+Recommendation+StateDiagnosis = Problem + Evidence + Cause + Recommendation + State$

DiagnosisEngine 在此基础上增加：

Runtime；
History；
Memory；
Experience；
Rule；
Condition；
Candidate Causes；
Verification。

204.4 DiagnosisEngine核心模型

定义：

$DE=(A,P,E,C,R,S,H,M,X,V,T)DE=(A,P,E,C,R,S,H,M,X,V,T)$

其中：

$DEDE$ ：DiagnosisEngine；
$AA$ ：Abnormality；
$PP$ ：Problem；
$EE$ ：Evidence；
$CC$ ：Cause；
$RR$ ：Recommendation；
$SS$ ：State；
$HH$ ：History；
$MM$ ：Memory；
$XX$ ：Experience；
$VV$ ：Verification；
$TT$ ：Time。

核心计算：

$Ac=CalculateAbnormality(Expected,Actual,State,Condition)A_c=CalculateAbnormality(Expected,Actual,State,Condition)$

原因分析：

$Cc=AnalyzeCause(A,E,H,M,X,Ru,Co)C_c=AnalyzeCause(A,E,H,M,X,Ru,C_o)$

诊断结果：

$Dr=BuildDiagnosis(A,C,E,R,V,S,T)D_r=BuildDiagnosis(A,C,E,R,V,S,T)$

因此：

$DiagnosisEngine=AbnormalityCalculation+CauseAnalysis+DiagnosisResultDiagnosisEngine = AbnormalityCalculation + CauseAnalysis + DiagnosisResult$

204.5 DiagnosisEngine输入

DiagnosisEngine 的完整输入可以定义：

$InputD=(Ex,Re,R,S,Co,Ru,Ev,H,M,X,Env,T)Input_D= (E_x,R_e,R,S,Co,Ru,Ev,H,M,X,Env,T)$

其中：

$ExE_x$ ：Execution，实际执行过程；
$ReR_e$ ：Expected Result，预期结果；
$RR$ ：Actual Result，实际结果；
$SS$ ：当前状态；
$CoCo$ ：Condition；
$RuRu$ ：Rule；
$EvEv$ ：Evidence；
$HH$ ：History；
$MM$ ：Memory；
$XX$ ：Experience；
$EnvEnv$ ：Environment；
$TT$ ：Time。

这里特别避免使用同一个 E 同时表示 Execution、Expected、Evidence，保持与第201章补充后的公式变量体系一致。

204.6 异常计算

DiagnosisEngine 的第一步不是猜原因，而是：

$Expected↔ActualExpected \leftrightarrow Actual$

进行比较。

基本模型：

$Ac=Compare(Re,R,S,Co)A_c=Compare(R_e,R,S,Co)$

其中：

$ReR_e$ ：Expected Result；
$RR$ ：Actual Result；
$SS$ ：当前 State；
$CoCo$ ：Condition；
$AcA_c$ ：Abnormality Calculation。

204.7 异常判断

可以定义：

$Abnormal=Expected∧Actual∧Comparison∧EvidenceAbnormal = Expected \land Actual \land Comparison \land Evidence$

如果：

$Actual=ExpectedActual=Expected$

则：

$Abnormal=FalseAbnormal=False$

如果：

$Actual≠ExpectedActual\neq Expected$

则：

$Abnormal=TrueAbnormal=True$

但如果实际信息不足：

$Actual=UnknownActual=Unknown$

则不能直接判定：

$Abnormal=TrueAbnormal=True$

而应该：

$Abnormal=UnknownAbnormal=Unknown$

因此异常状态至少包括：

$NormalNormal$ $WarningWarning$ $AbnormalAbnormal$ $FailureFailure$ $UnknownUnknown$

204.8 异常等级

为了避免所有异常都进入同一处理路径，可以定义：

$Severity∈{0,1,2,3,4}Severity\in \{ 0,1,2,3,4 \}$

例如：

等级	含义
0	Normal
1	Notice
2	Warning
3	Abnormal
4	Critical

Severity 必须通过规则计算，而不是由模型自由生成。

例如：

$Severity=f(Deviation,Impact,State,Risk)Severity = f(Deviation,Impact,State,Risk)$

其中：

Deviation：偏差程度；
Impact：影响程度；
State：当前状态；
Risk：风险等级。

204.9 偏差计算

对于数值型结果：

$ΔX=Xactual−Xexpected\Delta X=X_{actual}-X_{expected}$

相对偏差：

$D=∣Xactual−Xexpected∣∣Xexpected∣D= \frac{|X_{actual}-X_{expected}|} {|X_{expected}|}$

当：

$Xexpected≠0X_{expected}\neq0$

可以使用相对偏差。

如果：

$Xexpected=0X_{expected}=0$

则不能直接进行除法，而应该采用绝对偏差：

$D=∣Xactual∣D=|X_{actual}|$

204.10 状态异常

异常不只来自 Result，也可能来自 State。

例如：

$ExpectedState=ReadyExpectedState=Ready$

当前：

$ActualState=BlockedActualState=Blocked$

则：

$StateAbnormal=TrueStateAbnormal=True$

可以定义：

$StateDeviation=Compare(Sexpected,Sactual)StateDeviation = Compare(S_{expected},S_{actual})$

如果当前状态无法进入目标状态：

$StateTransition=InvalidStateTransition = Invalid$

则 DiagnosisEngine 可以生成：

$AbnormalityCandidateAbnormalityCandidate$

204.11 条件异常

如果：

$Conditionexpected≠ConditionactualCondition_{expected} \neq Condition_{actual}$

也可能造成异常。

例如：

$Expected:Temperature<50Expected: Temperature<50$

实际：

$Temperature=80Temperature=80$

则：

$ConditionViolation=TrueConditionViolation=True$

此时不能立即把 Method 判定为错误。

因为真正原因可能是：

$EnvironmentChangeEnvironmentChange$

或者：

$ObjectStateChangeObjectStateChange$

因此：

$ConditionViolation→CauseCandidateConditionViolation \rightarrow CauseCandidate$

而不是：

$ConditionViolation→FinalCauseConditionViolation \rightarrow FinalCause$

204.12 异常证据

DiagnosisEngine 必须使用 Evidence。

定义：

$Ev=(Source,Type,Value,T)Ev=(Source,Type,Value,T)$

其中：

Source：证据来源；
Type：证据类型；
Value：证据内容；
T：时间。

例如：

Execution Result
State History
Sensor Value
Action Result
Environment Event
Rule Evaluation
Previous Diagnosis

因此：

$Diagnosis≠GuessDiagnosis \neq Guess$

必须：

$Diagnosis=EvidenceBasedAnalysisDiagnosis = EvidenceBasedAnalysis$

204.13 原因分析

异常确定以后进入：

$CauseAnalysisCauseAnalysis$

基本模型：

$Cc=Analyze(A,Ev,H,M,X,Ru,Co)C_c = Analyze(A,Ev,H,M,X,Ru,Co)$

其中：

$AA$ ：异常；
$EvEv$ ：证据；
$HH$ ：历史；
$MM$ ：记忆；
$XX$ ：经验；
$RuRu$ ：规则；
$CoCo$ ：条件。

204.14 原因候选

DiagnosisEngine 不应该一开始就输出唯一原因。

应该建立：

$CauseCandidateCauseCandidate$

定义：

$CC=(P,E,C,S,Q,T)CC=(P,E,C,S,Q,T)$

其中：

$PP$ ：Problem；
$EE$ ：Evidence；
$CC$ ：Cause；
$SS$ ：State；
$QQ$ ：Score；
$TT$ ：Time。

可能原因例如：

$C1=ResourceUnavailableC_1=ResourceUnavailable$ $C2=ConditionChangedC_2=ConditionChanged$ $C3=ObjectStateChangedC_3=ObjectStateChanged$ $C4=MethodInvalidC_4=MethodInvalid$ $C5=ActionFailureC_5=ActionFailure$ $C6=EnvironmentChangedC_6=EnvironmentChanged$ $C7=CapabilityUnavailableC_7=CapabilityUnavailable$ $C8=RuleConflictC_8=RuleConflict$

204.15 原因分类

原因可以按照认知层次分类：

Object Cause

对象本身异常。

State Cause

状态异常。

Condition Cause

条件不满足。

Capability Cause

能力不可用。

Method Cause

方法不适用。

Action Cause

动作执行异常。

Resource Cause

资源不足或不可用。

Relation Cause

关系异常。

Environment Cause

环境发生变化。

Rule Cause

规则冲突或者规则不适用。

因此：

$CauseType∈{Object,State,Condition,Capability,Method,Action,Resource,Relation,Environment,Rule}CauseType \in \{ Object, State, Condition, Capability, Method, Action, Resource, Relation, Environment, Rule \}$

204.16 原因计算

可以定义：

$CauseScore(Ci)=WeEi+WhHi+WmMi+WxXi+WrRi+WcCiCauseScore(C_i) = W_eE_i + W_hH_i + W_mM_i + W_xX_i + W_rR_i + W_cC_i$

其中：

$EiE_i$ ：证据支持程度；
$HiH_i$ ：历史支持程度；
$MiM_i$ ：记忆支持程度；
$XiX_i$ ：经验支持程度；
$RiR_i$ ：规则支持程度；
$CiC_i$ ：条件一致程度。

这不是机器学习预测分数。

它是：

根据明确证据维度进行的离散规则评分。

204.17 原因排序

多个原因候选：

$C1,C2,…,CnC_1,C_2,\ldots,C_n$

经过：

$CauseScore→SortCauseScore \rightarrow Sort$

得到：

$Crank1,Crank2,…,CranknC_{rank1},C_{rank2},\ldots,C_{rankn}$

但是：

$Rank1≠ConfirmedCauseRank_1 \neq ConfirmedCause$

排名第一只能表示：

当前证据下最优先检查的原因。

仍然需要验证。

204.18 原因验证

定义：

$ValidCause=Evidence∧Condition∧Consistency∧VerificationValidCause = Evidence \land Condition \land Consistency \land Verification$

验证流程：

$CauseCandidate→EvidenceCheck→ConditionCheck→CauseVerificationCauseCandidate \rightarrow EvidenceCheck \rightarrow ConditionCheck \rightarrow CauseVerification$

如果验证成功：

$CauseState=ConfirmedCauseState=Confirmed$

如果证据不足：

$CauseState=UnknownCauseState=Unknown$

如果被证明错误：

$CauseState=RejectedCauseState=Rejected$

如果存在多个可能：

$CauseState=MultipleCandidatesCauseState=MultipleCandidates$

204.19 多原因诊断

实际系统中，一个异常可能由多个原因共同造成。

例如：

$EnvironmentChange+ResourceUnavailable→ActionFailureEnvironmentChange + ResourceUnavailable \rightarrow ActionFailure$

因此 DiagnosisEngine 必须允许：

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

而不是强制：

$Cause=C1Cause=C_1$

可以定义原因关系：

$C1→C2C_1\rightarrow C_2$

表示：

C1 可能导致 C2。

例如：

$EnvironmentChange→ConditionViolation→ActionFailureEnvironmentChange \rightarrow ConditionViolation \rightarrow ActionFailure$

最终：

$Diagnosis=RootCause+IntermediateCause+ObservedFailureDiagnosis = RootCause + IntermediateCause + ObservedFailure$

204.20 根因与直接原因

需要区分：

Direct Cause

直接造成异常的原因。

Root Cause

更上层的根本原因。

例如：

$EnvironmentTemperatureIncreaseEnvironmentTemperatureIncrease$

导致：

$ConditionViolationConditionViolation$

导致：

$ActionFailureActionFailure$

那么：

Root Cause:
EnvironmentTemperatureIncrease

Intermediate Cause:
ConditionViolation

Direct Cause:
ActionFailure

DiagnosisEngine 应该保留整个原因链。

204.21 原因链模型

定义：

$CauseChain=C1→C2→C3→ProblemCauseChain= C_1 \rightarrow C_2 \rightarrow C_3 \rightarrow Problem$

例如：

$EnvironmentChange→StateChange→ConditionViolation→ActionFailureEnvironmentChange \rightarrow StateChange \rightarrow ConditionViolation \rightarrow ActionFailure$

这样 DiagnosisEngine 不只是回答：

出错了。

而是回答：

哪一个事实变化，经过什么中间状态，最终造成了什么异常。

204.22 Diagnosis结果

诊断结果：

$Dr=(P,Ev,C,R,S,V,T)D_r=(P,Ev,C,R,S,V,T)$

其中：

$PP$ ：Problem；
$EvEv$ ：Evidence；
$CC$ ：Cause；
$RR$ ：Recommendation；
$SS$ ：Diagnosis State；
$VV$ ：Verification；
$TT$ ：Time。

因此：

$DiagnosisResult=Problem+Evidence+Cause+Recommendation+VerificationDiagnosisResult = Problem + Evidence + Cause + Recommendation + Verification$

204.23 Diagnosis状态

诊断状态：

$SD∈{Unknown,Detected,Analyzing,CauseFound,Confirmed,MultipleCandidates,Rejected,Resolved,Unrecoverable}S_D\in \{ Unknown, Detected, Analyzing, CauseFound, Confirmed, MultipleCandidates, Rejected, Resolved, Unrecoverable \}$

完整生命周期：

$Unknown→Detected→Analyzing→CauseFound→ConfirmedUnknown \rightarrow Detected \rightarrow Analyzing \rightarrow CauseFound \rightarrow Confirmed$

如果原因不唯一：

$Analyzing→MultipleCandidatesAnalyzing \rightarrow MultipleCandidates$

如果原因被否定：

$Analyzing→RejectedAnalyzing \rightarrow Rejected$

如果问题处理完成：

$Confirmed→ResolvedConfirmed \rightarrow Resolved$

204.24 Recommendation

DiagnosisEngine 可以产生：

$RecommendationRecommendation$

但不直接执行 Repair。

例如：

Retry
ChangeMethod
RecoverState
ReplaceResource
RecalculateCondition
HumanReview

因此：

$DiagnosisEngine→RepairCandidateDiagnosisEngine \rightarrow RepairCandidate$

而：

$RepairEngine→RepairExecutionRepairEngine \rightarrow RepairExecution$

必须保持边界。

204.25 DiagnosisEngine完整PHP实现

基础 Engine：

<?php

abstract class Engine
{
    public function calculate($input)
    {
        return array();
    }
}

定义 DiagnosisEngine：

class DiagnosisEngine extends Engine
{
    protected $rules;

    public function __construct($rules = array())
    {
        $this->rules = $rules;
    }

    public function calculate($input)
    {
        $abnormality =
            $this->calculateAbnormality(
                $input
            );

        if ($abnormality['status'] === 'normal') {
            return array(
                'abnormality' => $abnormality,
                'diagnosis' => array(
                    'status' => 'not_required'
                ),
                'time' => time()
            );
        }

        $causes =
            $this->analyzeCauses(
                $input,
                $abnormality
            );

        $diagnosis =
            $this->buildDiagnosisResult(
                $input,
                $abnormality,
                $causes
            );

        return array(
            'abnormality' => $abnormality,
            'causes' => $causes,
            'diagnosis' => $diagnosis,
            'time' => time()
        );
    }
}

204.26 异常计算PHP实现

protected function calculateAbnormality($input)
{
    $expected = isset($input['expected'])
        ? $input['expected']
        : null;

    $actual = isset($input['actual'])
        ? $input['actual']
        : null;

    $state = isset($input['state'])
        ? $input['state']
        : array();

    $condition = isset($input['condition'])
        ? $input['condition']
        : array();

    if ($expected === null ||
        $actual === null) {

        return array(
            'status' => 'unknown',
            'reason' => 'insufficient_evidence'
        );
    }

    $comparison =
        $this->compareValue(
            $expected,
            $actual
        );

    if ($comparison['equal']) {

        return array(
            'status' => 'normal',
            'comparison' => $comparison,
            'severity' => 0,
            'reason' => 'actual_matches_expected'
        );
    }

    $severity =
        $this->calculateSeverity(
            $expected,
            $actual,
            $state,
            $condition
        );

    return array(
        'status' => 'abnormal',
        'comparison' => $comparison,
        'severity' => $severity,
        'reason' => 'actual_differs_from_expected'
    );
}

204.27 实际值比较

protected function compareValue(
    $expected,
    $actual
) {
    if (is_numeric($expected) &&
        is_numeric($actual)) {

        $difference =
            (float)$actual -
            (float)$expected;

        $absolute =
            abs($difference);

        if ((float)$expected != 0) {
            $relative =
                $absolute /
                abs((float)$expected);
        } else {
            $relative = $absolute;
        }

        return array(
            'equal' =>
                $absolute == 0,

            'difference' =>
                $difference,

            'absolute_difference' =>
                $absolute,

            'relative_difference' =>
                $relative
        );
    }

    return array(
        'equal' =>
            serialize($expected) ===
            serialize($actual),

        'difference' =>
            null,

        'absolute_difference' =>
            null,

        'relative_difference' =>
            null
    );
}

204.28 异常严重程度计算

protected function calculateSeverity(
    $expected,
    $actual,
    $state,
    $condition
) {
    $comparison =
        $this->compareValue(
            $expected,
            $actual
        );

    $deviation =
        isset(
            $comparison['relative_difference']
        )
        ? $comparison['relative_difference']
        : 1.0;

    if ($deviation <= 0.05) {
        return 1;
    }

    if ($deviation <= 0.20) {
        return 2;
    }

    if ($deviation <= 0.50) {
        return 3;
    }

    return 4;
}

这里：

$SeveritySeverity$

只是根据偏差规则计算。

实际项目中可以进一步加入：

$Impact+Risk+State+ConditionImpact + Risk + State + Condition$

204.29 原因分析PHP实现

protected function analyzeCauses(
    $input,
    $abnormality
) {
    $candidates = array();

    $evidence =
        isset($input['evidence'])
            ? $input['evidence']
            : array();

    $history =
        isset($input['history'])
            ? $input['history']
            : array();

    $memory =
        isset($input['memory'])
            ? $input['memory']
            : array();

    $experience =
        isset($input['experience'])
            ? $input['experience']
            : array();

    $candidates[] =
        $this->checkConditionCause(
            $input,
            $evidence
        );

    $candidates[] =
        $this->checkStateCause(
            $input,
            $history
        );

    $candidates[] =
        $this->checkResourceCause(
            $input,
            $evidence
        );

    $candidates[] =
        $this->checkMethodCause(
            $input,
            $experience
        );

    $candidates[] =
        $this->checkEnvironmentCause(
            $input,
            $history
        );

    $candidates =
        $this->removeEmptyCauses(
            $candidates
        );

    foreach ($candidates as $key => $candidate) {

        $candidates[$key]['score'] =
            $this->calculateCauseScore(
                $candidate
            );
    }

    usort(
        $candidates,
        array($this, 'sortCause')
    );

    return $candidates;
}

204.30 Condition原因检测

protected function checkConditionCause(
    $input,
    $evidence
) {
    $expected =
        isset($input['condition'])
            ? $input['condition']
            : array();

    $actual =
        isset($input['actual_condition'])
            ? $input['actual_condition']
            : array();

    if (!$expected || !$actual) {
        return array();
    }

    if (!$this->sameValue(
        $expected,
        $actual
    )) {

        return array(
            'type' => 'condition',
            'cause' =>
                'condition_changed',
            'evidence' =>
                $evidence,
            'state' =>
                'candidate'
        );
    }

    return array();
}

204.31 State原因检测

protected function checkStateCause(
    $input,
    $history
) {
    $expectedState =
        isset($input['expected_state'])
            ? $input['expected_state']
            : null;

    $actualState =
        isset($input['actual_state'])
            ? $input['actual_state']
            : null;

    if ($expectedState === null ||
        $actualState === null) {

        return array();
    }

    if ($expectedState != $actualState) {

        return array(
            'type' => 'state',
            'cause' =>
                'state_changed',
            'expected' =>
                $expectedState,
            'actual' =>
                $actualState,
            'history' =>
                $history,
            'state' =>
                'candidate'
        );
    }

    return array();
}

204.32 Resource原因检测

protected function checkResourceCause(
    $input,
    $evidence
) {
    if (!isset(
        $input['resource_status']
    )) {
        return array();
    }

    if ($input['resource_status'] ===
        'unavailable') {

        return array(
            'type' => 'resource',
            'cause' =>
                'resource_unavailable',
            'evidence' =>
                $evidence,
            'state' =>
                'candidate'
        );
    }

    return array();
}

204.33 Method原因检测

protected function checkMethodCause(
    $input,
    $experience
) {
    if (!isset(
        $input['method_status']
    )) {
        return array();
    }

    if ($input['method_status'] ===
        'invalid') {

        return array(
            'type' => 'method',
            'cause' =>
                'method_invalid',
            'experience' =>
                $experience,
            'state' =>
                'candidate'
        );
    }

    return array();
}

204.34 Environment原因检测

protected function checkEnvironmentCause(
    $input,
    $history
) {
    if (!isset(
        $input['environment_changed']
    )) {
        return array();
    }

    if ($input['environment_changed'] === true) {

        return array(
            'type' => 'environment',
            'cause' =>
                'environment_changed',
            'history' =>
                $history,
            'state' =>
                'candidate'
        );
    }

    return array();
}

204.35 空原因过滤

protected function removeEmptyCauses(
    $candidates
) {
    $result = array();

    foreach ($candidates as $candidate) {

        if (!empty($candidate)) {
            $result[] = $candidate;
        }
    }

    return $result;
}

204.36 原因评分

protected function calculateCauseScore(
    $candidate
) {
    $score = 0.0;

    if (isset($candidate['evidence']) &&
        !empty($candidate['evidence'])) {

        $score += 0.4;
    }

    if (isset($candidate['history']) &&
        !empty($candidate['history'])) {

        $score += 0.2;
    }

    if (isset($candidate['experience']) &&
        !empty($candidate['experience'])) {

        $score += 0.2;
    }

    if (isset($candidate['state']) &&
        $candidate['state'] ===
        'candidate') {

        $score += 0.2;
    }

    return $this->normalize($score);
}

204.37 原因排序

protected function sortCause(
    $a,
    $b
) {
    $scoreA =
        isset($a['score'])
            ? $a['score']
            : 0;

    $scoreB =
        isset($b['score'])
            ? $b['score']
            : 0;

    if ($scoreA == $scoreB) {
        return 0;
    }

    return ($scoreA > $scoreB)
        ? -1
        : 1;
}

204.38 诊断结果生成

protected function buildDiagnosisResult(
    $input,
    $abnormality,
    $causes
) {
    $state = 'detected';

    if (count($causes) > 0) {
        $state = 'cause_found';
    }

    if (count($causes) > 1) {
        $state = 'multiple_candidates';
    }

    $primaryCause =
        count($causes) > 0
            ? $causes[0]
            : null;

    return array(
        'problem' =>
            isset($input['problem'])
                ? $input['problem']
                : 'unknown_problem',

        'abnormality' =>
            $abnormality,

        'primary_cause' =>
            $primaryCause,

        'causes' =>
            $causes,

        'recommendation' =>
            $this->buildRecommendation(
                $primaryCause
            ),

        'state' =>
            $state,

        'verification' =>
            false,

        'time' =>
            time()
    );
}

204.39 处理建议计算

protected function buildRecommendation(
    $cause
) {
    if (!$cause) {
        return array(
            'type' => 'manual_review'
        );
    }

    switch ($cause['type']) {

        case 'condition':
            return array(
                'type' =>
                    'recalculate_condition'
            );

        case 'state':
            return array(
                'type' =>
                    'recover_or_recalculate_state'
            );

        case 'resource':
            return array(
                'type' =>
                    'replace_resource'
            );

        case 'method':
            return array(
                'type' =>
                    'change_method'
            );

        case 'environment':
            return array(
                'type' =>
                    'recalculate_environment'
            );

        default:
            return array(
                'type' =>
                    'manual_review'
            );
    }
}

注意：

$Recommendation≠RepairExecutionRecommendation \neq RepairExecution$

这里只产生诊断后的处理候选。

204.40 诊断验证

DiagnosisEngine 还必须支持原因验证。

public function verifyCause(
    $cause,
    $verification
) {
    if (!is_array($cause) ||
        !is_array($verification)) {

        return array(
            'status' => 'unknown'
        );
    }

    if (isset(
        $verification['confirmed']
    )) {

        if ($verification['confirmed'] === true) {

            return array(
                'status' => 'confirmed',
                'cause' =>
                    $cause,
                'evidence' =>
                    $verification,
                'time' =>
                    time()
            );
        }

        return array(
            'status' => 'rejected',
            'cause' =>
                $cause,
            'evidence' =>
                $verification,
            'time' =>
                time()
        );
    }

    return array(
        'status' => 'unknown',
        'cause' =>
            $cause,
        'evidence' =>
            $verification
    );
}

204.41 DiagnosisEngine辅助函数

protected function sameValue(
    $a,
    $b
) {
    return serialize($a) ===
        serialize($b);
}

protected function normalize($value)
{
    $value = (float)$value;

    if ($value < 0) {
        return 0.0;
    }

    if ($value > 1) {
        return 1.0;
    }

    return $value;
}

204.42 一个完整异常诊断输入

例如：

$input = array(
    'expected' => array(
        'status' => 'success'
    ),

    'actual' => array(
        'status' => 'failed'
    ),

    'expected_state' =>
        'ready',

    'actual_state' =>
        'blocked',

    'condition' => array(
        'temperature' => 'normal'
    ),

    'actual_condition' => array(
        'temperature' => 'high'
    ),

    'resource_status' =>
        'available',

    'method_status' =>
        'valid',

    'environment_changed' =>
        true,

    'evidence' => array(
        array(
            'source' => 'execution',
            'type' => 'result',
            'value' => 'failed',
            'time' => time()
        ),
        array(
            'source' => 'environment',
            'type' => 'temperature',
            'value' => 'high',
            'time' => time()
        )
    ),

    'history' => array(
        array(
            'event' =>
                'temperature_increase'
        )
    ),

    'memory' => array(),

    'experience' => array(
        array(
            'pattern' =>
                'high_temperature'
        )
    ),

    'problem' =>
        'action_execution_failed'
);

执行：

$engine =
    new DiagnosisEngine();

$result =
    $engine->calculate($input);

其计算过程：

$Expected→Actual→AbnormalityExpected \rightarrow Actual \rightarrow Abnormality$

然后：

$Abnormality→Condition+State+Environment+Resource+MethodAbnormality \rightarrow Condition + State + Environment + Resource + Method$

再：

$CauseCandidate→CauseScore→CauseRankingCauseCandidate \rightarrow CauseScore \rightarrow CauseRanking$

最终：

$DiagnosisResultDiagnosisResult$

204.43 完整诊断结果结构

结果可以保持如下结构：

array(
    'abnormality' => array(
        'status' => 'abnormal',
        'severity' => 4,
        'comparison' => array(
            'equal' => false
        )
    ),

    'causes' => array(
        array(
            'type' => 'environment',
            'cause' =>
                'environment_changed',
            'score' => 0.8
        ),

        array(
            'type' => 'state',
            'cause' =>
                'state_changed',
            'score' => 0.6
        ),

        array(
            'type' => 'condition',
            'cause' =>
                'condition_changed',
            'score' => 0.6
        )
    ),

    'diagnosis' => array(
        'state' =>
            'multiple_candidates'
    ),

    'time' => time()
);

真正系统中还应继续加入：

Evidence；
Cause Chain；
Verification；
Diagnosis History；
Related Execution；
Related Behavior；
Related Method；
Related Object。

204.44 Cause Chain PHP结构

为了表达：

$Environment→Condition→Action→FailureEnvironment \rightarrow Condition \rightarrow Action \rightarrow Failure$

可以定义：

class CauseChain
{
    protected $nodes;
    protected $relations;

    public function __construct()
    {
        $this->nodes = array();
        $this->relations = array();
    }

    public function addNode($node)
    {
        $this->nodes[] = $node;
    }

    public function addRelation(
        $source,
        $relation,
        $target
    ) {
        $this->relations[] = array(
            'source' => $source,
            'relation' => $relation,
            'target' => $target
        );
    }

    public function toArray()
    {
        return array(
            'nodes' => $this->nodes,
            'relations' => $this->relations
        );
    }
}

例如：

$chain =
    new CauseChain();

$chain->addNode(
    'environment_changed'
);

$chain->addNode(
    'condition_violation'
);

$chain->addNode(
    'action_failure'
);

$chain->addRelation(
    'environment_changed',
    'causes',
    'condition_violation'
);

$chain->addRelation(
    'condition_violation',
    'causes',
    'action_failure'
);

最终形成：

$EnvironmentChange→ConditionViolation→ActionFailureEnvironmentChange \rightarrow ConditionViolation \rightarrow ActionFailure$

204.45 DiagnosisEngine与RepairEngine

DiagnosisEngine 不直接修复。

正确关系：

$Abnormality→DiagnosisEngine→Cause→RepairCandidate→DecisionEngine→RepairEngineAbnormality \rightarrow DiagnosisEngine \rightarrow Cause \rightarrow RepairCandidate \rightarrow DecisionEngine \rightarrow RepairEngine$

因此：

$DiagnosisEngine≠RepairEngineDiagnosisEngine \neq RepairEngine$

DiagnosisEngine 回答：

为什么出现问题？

RepairEngine 回答：

如何恢复？

DecisionEngine 回答：

多个修复方案中选择哪个？

204.46 DiagnosisEngine与RiskEngine

RiskEngine：

计算可能发生的问题。

DiagnosisEngine：

分析已经发生的问题。

因此：

$Risk=PotentialProblemRisk = PotentialProblem$ $Diagnosis=ActualProblemAnalysisDiagnosis = ActualProblemAnalysis$

完整关系：

$RiskEngine→ProtectionRiskEngine \rightarrow Protection$

而：

$Failure→DiagnosisEngineFailure \rightarrow DiagnosisEngine$

如果实际异常出现：

$Risk→ActualFailure→DiagnosisRisk \rightarrow ActualFailure \rightarrow Diagnosis$

204.47 DiagnosisEngine与ConflictEngine

ConflictEngine 负责：

$ConflictDetectionConflictDetection$

例如：

$GoalConflictGoalConflict$ $MethodConflictMethodConflict$ $ResourceConflictResourceConflict$

DiagnosisEngine 则进一步分析：

这个冲突是否导致了当前异常？

因此：

$ConflictEngine→DiagnosisEngineConflictEngine \rightarrow DiagnosisEngine$

204.48 DiagnosisEngine与FeedbackEngine

完整关系：

$Execution→Result→Feedback→Abnormality→DiagnosisExecution \rightarrow Result \rightarrow Feedback \rightarrow Abnormality \rightarrow Diagnosis$

FeedbackEngine 负责结构化反馈。

DiagnosisEngine 负责解释反馈中发现的异常。

所以：

$FeedbackEngine≠DiagnosisEngineFeedbackEngine \neq DiagnosisEngine$

204.49 DiagnosisEngine与ExperienceEngine

过去的 Experience 可以作为原因分析依据。

例如：

$Experience:C1→M1→FailureExperience: C_1 \rightarrow M_1 \rightarrow Failure$

当前：

$C1→M1→FailureC_1 \rightarrow M_1 \rightarrow Failure$

则 DiagnosisEngine 可以提高：

$MethodFailureMethodFailure$

原因候选的支持程度。

因此：

$Experience→CauseEvidenceExperience \rightarrow CauseEvidence$

但 Experience 只能提供历史依据，不能替代当前证据。

204.50 DiagnosisEngine与MemoryEngine

Memory 可以提供过去的：

状态；
结果；
处理记录；
环境变化；
对象变化。

因此：

$Memory→HistoricalEvidence→DiagnosisMemory \rightarrow HistoricalEvidence \rightarrow Diagnosis$

但：

$Memory≠CurrentEvidenceMemory \neq CurrentEvidence$

当前事实仍然必须优先。

204.51 DiagnosisEngine与LearningEngine

诊断结果经过验证以后，可以进入 LearningEngine。

例如：

$MethodM1→RepeatedFailure→Diagnosis→MethodConditionTooBroadMethodM1 \rightarrow RepeatedFailure \rightarrow Diagnosis \rightarrow MethodConditionTooBroad$

LearningEngine 可以形成：

$MethodUpdateCandidateMethodUpdateCandidate$

因此：

$DiagnosisEngine→LearningEngineDiagnosisEngine \rightarrow LearningEngine$

但 DiagnosisEngine 不直接修改 Method。

204.52 DiagnosisEngine与DecisionEngine

如果存在多个原因：

$C1,C2,C3C_1,C_2,C_3$

DiagnosisEngine 可以排序。

但如果不同原因对应不同处理方式，则最终方案选择仍然属于 DecisionEngine：

$Diagnosis→RepairCandidates→DecisionEngineDiagnosis \rightarrow RepairCandidates \rightarrow DecisionEngine$

例如：

$C1→RetryC_1 \rightarrow Retry$ $C2→ChangeMethodC_2 \rightarrow ChangeMethod$ $C3→ReplaceResourceC_3 \rightarrow ReplaceResource$

最终：

$DecisionEngine→SelectedRepairDecisionEngine \rightarrow SelectedRepair$

204.53 DiagnosisEngine数据库映射

建议建立：

abnormalities
diagnoses
diagnosis_evidence
diagnosis_causes
diagnosis_cause_chain
diagnosis_verifications
diagnosis_history

abnormalities

记录：

expected；
actual；
deviation；
severity；
state；
time。

diagnoses

记录：

problem；
primary cause；
diagnosis state；
recommendation；
verification；
time。

diagnosis_evidence

记录诊断依据。

diagnosis_causes

记录原因候选。

diagnosis_cause_chain

记录原因关系。

diagnosis_verifications

记录原因验证。

diagnosis_history

记录诊断过程变化。

204.54 DiagnosisEngine完整生命周期

完整流程：

$Execution→Result→Feedback→AbnormalityDetectionExecution \rightarrow Result \rightarrow Feedback \rightarrow AbnormalityDetection$

然后：

$Abnormality→EvidenceCollection→CauseCandidatesAbnormality \rightarrow EvidenceCollection \rightarrow CauseCandidates$

然后：

$CauseCandidates→CauseScoring→CauseRankingCauseCandidates \rightarrow CauseScoring \rightarrow CauseRanking$

然后：

$Cause→Verification→DiagnosisResultCause \rightarrow Verification \rightarrow DiagnosisResult$

最终：

$DiagnosisResult→RepairCandidate→DecisionDiagnosisResult \rightarrow RepairCandidate \rightarrow Decision$

204.55 正常路径

如果：

$Expected=ActualExpected=Actual$

则：

$Comparison=EqualComparison=Equal$

最终：

$Abnormality=NormalAbnormality=Normal$

因此：

$DiagnosisEngine→NoDiagnosisRequiredDiagnosisEngine \rightarrow NoDiagnosisRequired$

正常路径：

$Execution→Result→Feedback→NormalExecution \rightarrow Result \rightarrow Feedback \rightarrow Normal$

无需进入诊断。

204.56 异常路径

异常路径：

$Execution→Result→Feedback→AbnormalityExecution \rightarrow Result \rightarrow Feedback \rightarrow Abnormality$

然后：

$Abnormality→CauseAnalysis→DiagnosisAbnormality \rightarrow CauseAnalysis \rightarrow Diagnosis$

如果原因确定：

$Diagnosis→RepairCandidateDiagnosis \rightarrow RepairCandidate$

如果原因不确定：

$Diagnosis→AdditionalEvidenceDiagnosis \rightarrow AdditionalEvidence$

如果没有足够证据：

$DiagnosisState=UnknownDiagnosisState=Unknown$

不能虚构原因。

204.57 完整Engine关系

到第204章，相关 Engine 已形成：

$ObjectEngine→StateEngine→RelationEngine→SceneEngineObjectEngine \rightarrow StateEngine \rightarrow RelationEngine \rightarrow SceneEngine$ $KnowledgeEngine→CapabilityEngine→MatchingEngine→MethodEngineKnowledgeEngine \rightarrow CapabilityEngine \rightarrow MatchingEngine \rightarrow MethodEngine$ $RiskEngine→ConflictEngine→DecisionEngineRiskEngine \rightarrow ConflictEngine \rightarrow DecisionEngine$ $BehaviorEngine→ActionEngine→ExecutionEngine→FeedbackEngineBehaviorEngine \rightarrow ActionEngine \rightarrow ExecutionEngine \rightarrow FeedbackEngine$

然后：

$MemoryEngine→ExperienceEngineMemoryEngine \rightarrow ExperienceEngine$

异常处理：

$FeedbackEngine→DiagnosisEngineFeedbackEngine \rightarrow DiagnosisEngine$

最终：

$DiagnosisEngine→RepairEngine→Verification→LearningEngineDiagnosisEngine \rightarrow RepairEngine \rightarrow Verification \rightarrow LearningEngine$

204.58 完整ICAI异常闭环

完整异常认知循环：

$Goal→Capability→Method→Decision→Behavior→Action→Execution→ResultGoal \rightarrow Capability \rightarrow Method \rightarrow Decision \rightarrow Behavior \rightarrow Action \rightarrow Execution \rightarrow Result$

然后：

$Result→Feedback→AbnormalityResult \rightarrow Feedback \rightarrow Abnormality$

继续：

$Abnormality→Evidence→CauseAnalysis→DiagnosisAbnormality \rightarrow Evidence \rightarrow CauseAnalysis \rightarrow Diagnosis$

然后：

$Diagnosis→RepairCandidate→Decision→Repair→ExecutionDiagnosis \rightarrow RepairCandidate \rightarrow Decision \rightarrow Repair \rightarrow Execution$

再：

$Result→Feedback→VerificationResult \rightarrow Feedback \rightarrow Verification$

最终：

$Verification→Memory→Experience→LearningVerification \rightarrow Memory \rightarrow Experience \rightarrow Learning$

形成完整闭环：

$Execution→Result→Feedback→Diagnosis→Repair→Verification→Learning→DecisionExecution \rightarrow Result \rightarrow Feedback \rightarrow Diagnosis \rightarrow Repair \rightarrow Verification \rightarrow Learning \rightarrow Decision$

204.59 确定性原则

DiagnosisEngine 不采用概率生成式猜测。

它使用：

$Evidence+Rule+Condition+History+Memory+ExperienceEvidence + Rule + Condition + History + Memory + Experience$

进行离散计算。

对于相同输入：

$Input+RuleInput+Rule$

得到：

$DiagnosisResultDiagnosisResult$

应该具有确定性。

因此：

$DiagnosisEngine≠LLMDiagnosisEngine \neq LLM$

也不使用：

Transformer；
Embedding；
Vector Search；
Prompt Engineering；
Neural Network；
LLM API。

原因分析必须能够回答：

哪条规则？

哪个事实？

哪个证据？

哪段历史？

哪个状态？

共同支持这个诊断结果。

204.60 可解释性模型

每一次诊断都应该可以表示为：

$Problem→Evidence→Comparison→CauseCandidate→CauseScore→Verification→DiagnosisProblem \rightarrow Evidence \rightarrow Comparison \rightarrow CauseCandidate \rightarrow CauseScore \rightarrow Verification \rightarrow Diagnosis$

例如：

Problem:
Action execution failed

Evidence:
Resource status = available
Environment = changed
Actual state = blocked

Comparison:
Expected state = ready
Actual state = blocked

Cause Candidate:
Environment Changed

Supporting Evidence:
Environment event detected

Diagnosis:
Environment change caused condition violation,
which caused state transition to blocked.

这样诊断过程不是黑盒。

204.61 本章总结

DiagnosisEngine 的核心不是简单判断“成功还是失败”，而是：

从实际异常事实出发，通过证据、状态、条件、历史、记忆、经验和规则，对异常原因进行结构化计算，并形成可以验证、可以进入后续修复和学习流程的诊断结果。

核心模型：

$DiagnosisEngine=AbnormalityCalculation+CauseAnalysis+DiagnosisResultDiagnosisEngine = AbnormalityCalculation + CauseAnalysis + DiagnosisResult$

异常计算：

$Expected→Actual→Comparison→AbnormalityExpected \rightarrow Actual \rightarrow Comparison \rightarrow Abnormality$

原因分析：

$Abnormality+Evidence+History+Memory+Experience+Rule→CauseCandidatesAbnormality + Evidence + History + Memory + Experience + Rule \rightarrow CauseCandidates$

原因验证：

$CauseCandidate→EvidenceCheck→Verification→ConfirmedCauseCauseCandidate \rightarrow EvidenceCheck \rightarrow Verification \rightarrow ConfirmedCause$

诊断结果：

$Problem+Evidence+Cause+Recommendation+Verification→DiagnosisResultProblem + Evidence + Cause + Recommendation + Verification \rightarrow DiagnosisResult$

最终异常处理闭环：

$Execution→Result→Feedback→Abnormality→Diagnosis→Repair→Verification→Learning→DecisionExecution \rightarrow Result \rightarrow Feedback \rightarrow Abnormality \rightarrow Diagnosis \rightarrow Repair \rightarrow Verification \rightarrow Learning \rightarrow Decision$

因此：

$Result≠DiagnosisResult \neq Diagnosis$ $Abnormality≠CauseAbnormality \neq Cause$ $CauseCandidate≠ConfirmedCauseCauseCandidate \neq ConfirmedCause$ $Diagnosis≠RepairDiagnosis \neq Repair$

这几个边界构成 ICAI 异常认知系统的基本工程原则。

最终，DiagnosisEngine 使 ICAI 从“能够发现问题”进一步发展到：

能够计算问题、分析原因、保留证据、验证原因并形成结构化诊断结果。

这也是后续 RepairEngine、VerificationEngine 和 LearningEngine 能够建立在真实事实基础上的核心前提。

第204章 DiagnosisEngine

第204章 DiagnosisEngine

204.1 DiagnosisEngine概述

204.2 Abnormality、Failure与Diagnosis

Abnormality

Failure

Diagnosis

204.3 Diagnosis模型

204.4 DiagnosisEngine核心模型

204.5 DiagnosisEngine输入

204.6 异常计算

204.7 异常判断

204.8 异常等级

204.9 偏差计算

204.10 状态异常

204.11 条件异常

204.12 异常证据

204.13 原因分析

204.14 原因候选

204.15 原因分类

Object Cause

State Cause

Condition Cause

Capability Cause

Method Cause

Action Cause

Resource Cause

Relation Cause

Environment Cause

Rule Cause

204.16 原因计算

204.17 原因排序

204.18 原因验证

204.19 多原因诊断

204.20 根因与直接原因

Direct Cause

Root Cause

204.21 原因链模型

204.22 Diagnosis结果

204.23 Diagnosis状态

204.24 Recommendation

204.25 DiagnosisEngine完整PHP实现

204.26 异常计算PHP实现

204.27 实际值比较

204.28 异常严重程度计算

204.29 原因分析PHP实现

204.30 Condition原因检测

204.31 State原因检测

204.32 Resource原因检测

204.33 Method原因检测

204.34 Environment原因检测

204.35 空原因过滤

204.36 原因评分

204.37 原因排序

204.38 诊断结果生成

204.39 处理建议计算

204.40 诊断验证

204.41 DiagnosisEngine辅助函数

204.42 一个完整异常诊断输入

204.43 完整诊断结果结构

204.44 Cause Chain PHP结构

204.45 DiagnosisEngine与RepairEngine

204.46 DiagnosisEngine与RiskEngine

204.47 DiagnosisEngine与ConflictEngine

204.48 DiagnosisEngine与FeedbackEngine

204.49 DiagnosisEngine与ExperienceEngine

204.50 DiagnosisEngine与MemoryEngine

204.51 DiagnosisEngine与LearningEngine

204.52 DiagnosisEngine与DecisionEngine

204.53 DiagnosisEngine数据库映射

abnormalities

diagnoses

diagnosis_evidence

diagnosis_causes

diagnosis_cause_chain

diagnosis_verifications

diagnosis_history

204.54 DiagnosisEngine完整生命周期

204.55 正常路径

204.56 异常路径

第204章　DiagnosisEngine

第204章　DiagnosisEngine