第203章　ExperienceEngine

203.1 ExperienceEngine概述

在 ICAI 中，Memory 解决的是：

过去什么信息值得保留？

而 Experience 进一步解决：

过去发生过什么，并且在什么条件下形成了什么结果，这种历史模式是否可以用于当前认知？

因此 Experience 不是 Memory 的简单复制。

第164章定义：

$Experience=(H,M,C,R,P)Experience=(H,M,C,R,P)$

其中：

$HH$ ：History，形成经验的历史；
$MM$ ：Memory，与经验相关的记忆；
$CC$ ：Condition，经验形成条件；
$RR$ ：Result，历史结果；
$PP$ ：Pattern，从历史中形成的结构化模式。

本章定义：

$ExperienceEngine=ExperienceCalculation+ExperienceCalling+ExperienceUpdatingExperienceEngine = ExperienceCalculation + ExperienceCalling + ExperienceUpdating$

即：

ExperienceEngine 是 ICAI 中负责经验模式计算、经验调用和经验更新的确定性认知计算引擎。

其核心职责不是生成文字，而是从已有历史事实和记忆中计算：

$History→Memory→Comparison→Pattern→ExperienceHistory \rightarrow Memory \rightarrow Comparison \rightarrow Pattern \rightarrow Experience$

然后在新的 Runtime 中：

$CurrentContext→ExperienceMatching→ExperienceCalling→DecisionCurrentContext \rightarrow ExperienceMatching \rightarrow ExperienceCalling \rightarrow Decision$

最后根据新的结果：

$NewResult→ExperienceComparison→ExperienceUpdateNewResult \rightarrow ExperienceComparison \rightarrow ExperienceUpdate$

形成经验闭环。

203.2 Experience与Memory的区别

Memory：

保存过去有价值的信息。

Experience：

从多个历史事实和记忆之间的关系中形成可重复使用的结构化模式。

例如：

Memory A：

对象 O1 在状态 S1 下执行方法 M1。

Memory B：

方法 M1 执行成功。

Memory C：

相同条件下再次执行 M1 仍然成功。

这些 Memory 可以进一步形成：

$ExperienceExperience$

即：

当对象 O1 处于状态 S1，并满足条件 C1 时，方法 M1 具有较高的成功可能性。

因此：

$Memory→Comparison→Pattern→ExperienceMemory \rightarrow Comparison \rightarrow Pattern \rightarrow Experience$

所以：

$Memory≠ExperienceMemory\neq Experience$

203.3 ExperienceEngine核心模型

ExperienceEngine 可以定义为：

$EE=(H,M,C,R,P,O,S,G,K,V,T)EE=(H,M,C,R,P,O,S,G,K,V,T)$

其中：

$EEEE$ ：ExperienceEngine；
$HH$ ：History；
$MM$ ：Memory；
$CC$ ：Condition；
$RR$ ：Result；
$PP$ ：Pattern；
$OO$ ：Object；
$SS$ ：State；
$GG$ ：Goal；
$KK$ ：Knowledge；
$VV$ ：Verification；
$TT$ ：Time。

经验计算：

$P=Calculate(H,M,C,R,V)P=Calculate(H,M,C,R,V)$

经验调用：

$Er=Recall(E,O,S,G,C,T)E_r=Recall(E,O,S,G,C,T)$

经验更新：

$Et+1=Update(Et,ΔF,V,C,T)E_{t+1}=Update(E_t,\Delta F,V,C,T)$

其中：

$EE$ ：Experience；
$ErE_r$ ：Experience Recall Result；
$ΔF\Delta F$ ：新的事实变化。

203.4 ExperienceEngine三大功能

ExperienceEngine 的核心功能分为三个部分：

一、经验计算

$History+Memory→Pattern→ExperienceHistory+Memory \rightarrow Pattern \rightarrow Experience$

解决：

如何从过去形成经验？

二、经验调用

$CurrentContext→ExperienceMatching→ExperienceRecallCurrentContext \rightarrow ExperienceMatching \rightarrow ExperienceRecall$

解决：

当前是否存在可以参考的经验？

三、经验更新

$NewResult→Comparison→Verification→ExperienceUpdateNewResult \rightarrow Comparison \rightarrow Verification \rightarrow ExperienceUpdate$

解决：

新的事实是否改变已有经验？

因此：

$ExperienceEngine=Calculate+Recall+UpdateExperienceEngine = Calculate + Recall + Update$

203.5 经验候选

并不是每一次 History 都能形成 Experience。

首先产生经验候选：

$History→ExperienceCandidateHistory \rightarrow ExperienceCandidate$

ExperienceCandidate 可以定义：

$EC=(H,M,C,R,P,V,T)EC=(H,M,C,R,P,V,T)$

其中：

$HH$ ：历史集合；
$MM$ ：相关记忆；
$CC$ ：共同条件；
$RR$ ：结果；
$PP$ ：候选模式；
$VV$ ：验证程度；
$TT$ ：形成时间。

经验候选必须至少具有：

$History∧Condition∧ResultHistory \land Condition \land Result$

如果缺少必要事实：

$ExperienceCandidate=InvalidExperienceCandidate=Invalid$

203.6 经验计算

经验计算的核心不是统计“成功多少次”，而是识别：

$Condition→Action/Method→ResultCondition \rightarrow Action/Method \rightarrow Result$

之间是否存在稳定关系。

例如：

历史：

$H1:C1→M1→SuccessH_1: C_1\rightarrow M_1\rightarrow Success$ $H2:C1→M1→SuccessH_2: C_1\rightarrow M_1\rightarrow Success$ $H3:C1→M1→SuccessH_3: C_1\rightarrow M_1\rightarrow Success$

可以形成：

$P1=(C1,M1,Success)P_1=(C_1,M_1,Success)$

进一步形成：

$Experience1Experience_1$

203.7 经验模式模型

Pattern 可以定义：

$P=(C,A,R,F,V)P=(C,A,R,F,V)$

其中：

$CC$ ：Condition；
$AA$ ：Action 或 Method；
$RR$ ：Result；
$FF$ ：Frequency；
$VV$ ：Verification。

例如：

$P=(C1,M1,Success,5,Verified)P= (C_1,M_1,Success,5,Verified)$

表示：

在条件 C1 下，方法 M1 曾经形成 5 次可验证的成功结果。

这里的次数是事实统计，而不是机器学习训练参数。

因此：

$Frequency≠NeuralWeightFrequency\neq NeuralWeight$

203.8 经验成功率

在具有足够历史样本时，可以计算：

$SuccessRate=NsuccessNvalidSuccessRate= \frac{N_{success}} {N_{valid}}$

其中：

$NsuccessN_{success}$ ：成功历史数量；
$NvalidN_{valid}$ ：有效历史数量。

例如：

$Nsuccess=8N_{success}=8$ $Nvalid=10N_{valid}=10$

则：

$SuccessRate=0.8SuccessRate=0.8$

但是必须强调：

SuccessRate 只是经验中的一个计算字段，不等于经验本身。

经验仍然必须包含：

$Condition+Pattern+Result+EvidenceCondition + Pattern + Result + Evidence$

203.9 经验稳定性

经验还可以计算稳定程度：

$Stability=NconfirmedNobservedStability= \frac{N_{confirmed}} {N_{observed}}$

其中：

$NconfirmedN_{confirmed}$ ：经过验证并与经验一致的历史；
$NobservedN_{observed}$ ：观察到的相关历史。

如果：

$StabilityStability$

较高，说明经验模式具有较强的历史一致性。

如果新事实持续与经验冲突，则：

$Stability↓Stability\downarrow$

最终：

$Experience→OutdatedExperience \rightarrow Outdated$

203.10 经验状态

Experience 可以具有以下状态：

$SE∈{Candidate,Formed,Verified,Active,Used,Confirmed,Revised,Conflicted,Outdated,Archived}S_E\in \{ Candidate, Formed, Verified, Active, Used, Confirmed, Revised, Conflicted, Outdated, Archived \}$

Candidate

经验候选。

Formed

已经形成经验结构。

Verified

经过验证。

Active

可以参与经验调用。

Used

已经被当前认知过程调用。

Confirmed

新的结果进一步支持该经验。

Revised

新事实导致经验被修订。

Conflicted

出现与经验明显冲突的事实。

Outdated

经验已经不适用于当前条件。

Archived

退出普通经验调用，但保留历史。

203.11 经验验证

经验不能因为出现一次就直接成为可靠经验。

定义：

$ValidExperience=History∧Condition∧Result∧Evidence∧VerificationValidExperience = History \land Condition \land Result \land Evidence \land Verification$

即：

$ExperienceCandidate→Validation→Verification→ExperienceExperienceCandidate \rightarrow Validation \rightarrow Verification \rightarrow Experience$

因此：

$ObservedPattern≠VerifiedExperienceObservedPattern \neq VerifiedExperience$

这是 ICAI 与简单统计系统的重要区别。

203.12 经验调用

经验调用是 ExperienceEngine 的第二个核心功能。

定义：

$Er=Recall(E,C,O,S,G,T)E_r=Recall(E,C,O,S,G,T)$

其中：

$EE$ ：已有经验；
$CC$ ：当前条件；
$OO$ ：当前对象；
$SS$ ：当前状态；
$GG$ ：当前目标；
$TT$ ：当前时间；
$ErE_r$ ：经验调用结果。

调用过程：

$CurrentContext→LoadExperience→Match→Filter→Rank→RecallCurrentContext \rightarrow LoadExperience \rightarrow Match \rightarrow Filter \rightarrow Rank \rightarrow Recall$

203.13 经验匹配

经验匹配维度包括：

$ExperienceMatch=Object+State+Goal+Condition+Method+Result+TimeExperienceMatch = Object + State + Goal + Condition + Method + Result + Time$

例如当前：

$O=O1O=O_1$ $S=S1S=S_1$ $G=G1G=G_1$ $C=C1C=C_1$

已有经验：

$E1=(C1,M1,Success)E_1=(C_1,M_1,Success)$

则：

$Match(E1,CurrentContext)=MatchedMatch(E_1,CurrentContext)=Matched$

如果条件部分一致：

$PartialPartial$

如果没有相关经验：

$UnmatchedUnmatched$

如果证据不足：

$UnknownUnknown$

如果当前条件与经验明确冲突：

$ConflictedConflicted$

203.14 ExperienceMatchResult

经验匹配结果定义为：

$EMR=(E,O,S,G,C,M,R,V,T)EMR=(E,O,S,G,C,M,R,V,T)$

其中：

$EE$ ：Experience；
$OO$ ：Object Match；
$SS$ ：State Match；
$GG$ ：Goal Match；
$CC$ ：Condition Match；
$MM$ ：Method Match；
$RR$ ：Result Pattern Match；
$VV$ ：Verification；
$TT$ ：Time。

返回状态：

$MatchedMatched$ $PartialPartial$ $UnmatchedUnmatched$ $UnknownUnknown$ $ConflictedConflicted$ $OutdatedOutdated$

203.15 经验调用排序

当存在多个经验时，需要进行排序。

可以定义：

$Score(Ei)=WcCi+WsSi+WoOi+WgGi+WvVi+WrRiScore(E_i) = W_cC_i + W_sS_i + W_oO_i + W_gG_i + W_vV_i + W_rR_i$

其中：

$CiC_i$ ：条件匹配程度；
$SiS_i$ ：状态匹配程度；
$OiO_i$ ：对象匹配程度；
$GiG_i$ ：目标匹配程度；
$ViV_i$ ：验证程度；
$RiR_i$ ：结果一致性；
$Wc,Ws,Wo,Wg,Wv,WrW_c,W_s,W_o,W_g,W_v,W_r$ ：规则权重。

然后：

$Experience1,…,Experiencen→Score→Sort→RecallExperience_1,\ldots,Experience_n \rightarrow Score \rightarrow Sort \rightarrow Recall$

这仍然是确定性计算。

203.16 经验调用不是决策

这是 ExperienceEngine 最重要的工程边界之一。

ExperienceEngine：

提供历史经验参考。

DecisionEngine：

根据当前所有条件选择方案。

所以：

$ExperienceRecall≠DecisionExperienceRecall \neq Decision$

正确流程：

$ExperienceEngine→RelevantExperience→DecisionEngineExperienceEngine \rightarrow RelevantExperience \rightarrow DecisionEngine$

DecisionEngine 还必须同时考虑：

Current State；
Capability；
Method；
Risk；
Conflict；
Knowledge；
Goal；
Resource。

因此经验不能直接强制系统执行过去的方法。

203.17 当前事实优先于经验

和 Memory 一样：

$CurrentVerifiedFact>ExperienceCurrentVerifiedFact > Experience$

例如过去经验：

$E1:S1→M1→SuccessE_1: S_1\rightarrow M_1\rightarrow Success$

但是当前：

$State=S2State=S_2$

并且：

$S2S_2$

与经验条件冲突。

那么：

$ExperienceMatch=ConflictedExperienceMatch=Conflicted$

不能继续直接采用：

$M1M_1$

必须重新经过：

$Matching→Risk→DecisionMatching \rightarrow Risk \rightarrow Decision$

203.18 经验更新

Experience 的更新模型：

$Et+1=Update(Et,ΔF,V,C,T)E_{t+1} = Update(E_t,\Delta F,V,C,T)$

其中：

$EtE_t$ ：当前经验；
$ΔF\Delta F$ ：新的事实；
$VV$ ：验证；
$CC$ ：条件；
$TT$ ：时间；
$Et+1E_{t+1}$ ：新经验。

主要更新类型：

$CreateCreate$ $ConfirmConfirm$ $StrengthenStrengthen$ $ReviseRevise$ $ConflictConflict$ $WeakenWeaken$ $OutdateOutdate$ $ArchiveArchive$

203.19 经验确认

如果新的历史再次符合已有经验：

$NewHistory≈ExperiencePatternNewHistory \approx ExperiencePattern$

则：

$Experience→ConfirmedExperience \rightarrow Confirmed$

并更新：

$NobservedN_{observed}$

以及：

$NconfirmedN_{confirmed}$

例如：

原经验：

$Nconfirmed=3N_{confirmed}=3$

新事实验证成功：

$Nconfirmed=4N_{confirmed}=4$

同时可以重新计算：

$StabilityStability$

203.20 经验强化

如果连续的新事实支持原经验：

$Et→Et+1E_t \rightarrow E_{t+1}$

经验的历史支持程度增加。

可以定义：

$Confidence=NconfirmedNvalidConfidence= \frac{ N_{confirmed} }{ N_{valid} }$

这里的 Confidence 仍然是明确统计计算，而不是神经网络参数。

如果：

$Nconfirmed=9N_{confirmed}=9$ $Nvalid=10N_{valid}=10$

则：

$Confidence=0.9Confidence=0.9$

203.21 经验冲突

如果新的事实与经验模式冲突：

$NewFact⊭PatternNewFact \not\models Pattern$

则：

$Experience→ConflictedExperience \rightarrow Conflicted$

但是不能马上删除经验。

应该保留：

$OriginalExperienceOriginalExperience$

并记录：

$ConflictHistoryConflictHistory$

然后分析：

是否对象发生变化；
是否条件发生变化；
是否状态发生变化；
是否方法发生变化；
是否环境发生变化；
是否原经验本身错误。

因此：

$Conflict→Diagnosis→RevisionConflict \rightarrow Diagnosis \rightarrow Revision$

而不是：

$Conflict→DeleteConflict \rightarrow Delete$

203.22 经验修订

如果新事实证明原经验只适用于部分条件：

原：

$C1→M1→SuccessC_1\rightarrow M_1\rightarrow Success$

新事实发现：

$C1∧S1→M1→SuccessC_1\land S_1 \rightarrow M_1 \rightarrow Success$

但：

$C1∧S2→M1→FailureC_1\land S_2 \rightarrow M_1 \rightarrow Failure$

则经验应该修订为：

$C1∧S1→M1→SuccessC_1\land S_1 \rightarrow M_1 \rightarrow Success$

而不是继续保留过于宽泛的：

$C1→M1→SuccessC_1\rightarrow M_1\rightarrow Success$

这就是经验结构化的重要意义。

203.23 经验与LearningEngine

ExperienceEngine 负责：

$History→Pattern→ExperienceHistory \rightarrow Pattern \rightarrow Experience$

LearningEngine 负责：

$Experience+Evidence+Verification→Knowledge/Capability/MethodUpdateExperience + Evidence + Verification \rightarrow Knowledge/Capability/Method Update$

因此：

$ExperienceEngine≠LearningEngineExperienceEngine\neq LearningEngine$

正确关系：

$ExperienceEngine→LearningEngineExperienceEngine \rightarrow LearningEngine$

例如经验发现：

方法 M1 在条件 C1 下成功率较高。

LearningEngine 可以进一步判断：

是否应该更新 Method M1 的适用条件？

所以：

$Experience→LearningCandidate→Learning→MethodUpdateExperience \rightarrow LearningCandidate \rightarrow Learning \rightarrow MethodUpdate$

203.24 Experience与Knowledge

Experience：

个体过去形成的结构化实践模式。

Knowledge：

当前系统认可并可计算、验证、应用的知识。

关系：

$Experience→KnowledgeCandidate→Verification→KnowledgeExperience \rightarrow KnowledgeCandidate \rightarrow Verification \rightarrow Knowledge$

因此：

$Experience≠KnowledgeExperience\neq Knowledge$

经验可以成为知识更新的依据，但未经验证的经验不能自动成为知识。

203.25 ExperienceEngine与DecisionEngine

完整关系：

$Goal→Capability→Method→ExperienceRecall→Risk→DecisionGoal \rightarrow Capability \rightarrow Method \rightarrow ExperienceRecall \rightarrow Risk \rightarrow Decision$

ExperienceEngine 可以告诉 DecisionEngine：

过去类似条件下哪些方法发生过什么结果。

但 DecisionEngine 最终仍然需要计算：

$Candidate+Condition+Capability+Risk+Experience→DecisionCandidate + Condition + Capability + Risk + Experience \rightarrow Decision$

203.26 ExperienceEngine完整PHP实现

首先建立基础 Engine：

<?php

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

然后定义 Experience 对象：

class Experience
{
    protected $id;
    protected $individualId;
    protected $history;
    protected $memory;
    protected $condition;
    protected $result;
    protected $pattern;
    protected $state;
    protected $confidence;
    protected $createdAt;
    protected $updatedAt;

    public function __construct($data = array())
    {
        $this->id = isset($data['id'])
            ? $data['id']
            : null;

        $this->individualId = isset($data['individual_id'])
            ? $data['individual_id']
            : null;

        $this->history = isset($data['history'])
            ? $data['history']
            : array();

        $this->memory = isset($data['memory'])
            ? $data['memory']
            : array();

        $this->condition = isset($data['condition'])
            ? $data['condition']
            : array();

        $this->result = isset($data['result'])
            ? $data['result']
            : array();

        $this->pattern = isset($data['pattern'])
            ? $data['pattern']
            : array();

        $this->state = isset($data['state'])
            ? $data['state']
            : 'candidate';

        $this->confidence = isset($data['confidence'])
            ? (float)$data['confidence']
            : 0.0;

        $this->createdAt = isset($data['created_at'])
            ? $data['created_at']
            : time();

        $this->updatedAt = isset($data['updated_at'])
            ? $data['updated_at']
            : time();
    }

    public function getId()
    {
        return $this->id;
    }

    public function getHistory()
    {
        return $this->history;
    }

    public function getMemory()
    {
        return $this->memory;
    }

    public function getCondition()
    {
        return $this->condition;
    }

    public function getResult()
    {
        return $this->result;
    }

    public function getPattern()
    {
        return $this->pattern;
    }

    public function getState()
    {
        return $this->state;
    }

    public function getConfidence()
    {
        return $this->confidence;
    }

    public function setState($state)
    {
        $this->state = $state;
    }

    public function setConfidence($confidence)
    {
        $this->confidence = (float)$confidence;
    }

    public function toArray()
    {
        return array(
            'id' => $this->id,
            'individual_id' => $this->individualId,
            'history' => $this->history,
            'memory' => $this->memory,
            'condition' => $this->condition,
            'result' => $this->result,
            'pattern' => $this->pattern,
            'state' => $this->state,
            'confidence' => $this->confidence,
            'created_at' => $this->createdAt,
            'updated_at' => $this->updatedAt
        );
    }
}

203.27 ExperienceEngine类

class ExperienceEngine extends Engine
{
    protected $rules;

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

    public function calculate($input)
    {
        $experienceCalculation =
            $this->calculateExperience($input);

        $experienceCalling =
            $this->callExperience(
                isset($input['experiences'])
                    ? $input['experiences']
                    : array(),
                isset($input['context'])
                    ? $input['context']
                    : array()
            );

        $experienceUpdate =
            $this->calculateUpdate($input);

        return array(
            'calculation' => $experienceCalculation,
            'calling' => $experienceCalling,
            'update' => $experienceUpdate,
            'time' => time()
        );
    }
}

203.28 经验计算PHP实现

经验计算从 History 开始：

public function calculateExperience($input)
{
    $history = isset($input['history'])
        ? $input['history']
        : array();

    $result = array();

    foreach ($history as $item) {

        if (!$this->validHistory($item)) {
            continue;
        }

        $condition =
            $this->extractCondition($item);

        $action =
            $this->extractAction($item);

        $resultData =
            $this->extractResult($item);

        $pattern = array(
            'condition' => $condition,
            'action' => $action,
            'result' => $resultData
        );

        $result[] = array(
            'history' => $item,
            'condition' => $condition,
            'action' => $action,
            'result' => $resultData,
            'pattern' => $pattern,
            'verification' =>
                $this->calculateHistoryVerification($item),
            'time' => time()
        );
    }

    return $this->groupPatterns($result);
}

203.29 History有效性验证

protected function validHistory($item)
{
    if (!is_array($item)) {
        return false;
    }

    if (!isset($item['result'])) {
        return false;
    }

    if (!isset($item['condition'])) {
        return false;
    }

    return true;
}

其理论关系：

$ValidHistory=Condition∧ResultValidHistory = Condition \land Result$

如果还要求实际证据：

$ValidHistory=Condition∧Result∧EvidenceValidHistory = Condition \land Result \land Evidence$

203.30 条件提取

protected function extractCondition($item)
{
    if (isset($item['condition'])) {
        return $item['condition'];
    }

    return array();
}

203.31 Action/Method提取

protected function extractAction($item)
{
    if (isset($item['method'])) {
        return array(
            'type' => 'method',
            'id' => $item['method']
        );
    }

    if (isset($item['action'])) {
        return array(
            'type' => 'action',
            'id' => $item['action']
        );
    }

    return array();
}

这样 Experience 可以同时描述：

$Condition→Method→ResultCondition \rightarrow Method \rightarrow Result$

或者：

$Condition→Action→ResultCondition \rightarrow Action \rightarrow Result$

203.32 Result提取

protected function extractResult($item)
{
    if (isset($item['result'])) {
        return $item['result'];
    }

    return array();
}

203.33 历史验证

protected function calculateHistoryVerification($item)
{
    if (isset($item['verification'])) {

        if ($item['verification'] === true) {
            return 1.0;
        }

        return $this->normalize(
            $item['verification']
        );
    }

    if (isset($item['result_status'])) {

        if ($item['result_status'] === 'success') {
            return 1.0;
        }

        if ($item['result_status'] === 'failed') {
            return 0.5;
        }
    }

    return 0.0;
}

203.34 Pattern分组

多个历史如果具有相同的：

$Condition+Action+ResultTypeCondition + Action + ResultType$

可以形成一个 Experience Pattern。

protected function groupPatterns($items)
{
    $groups = array();

    foreach ($items as $item) {

        $key = $this->buildPatternKey(
            $item['condition'],
            $item['action'],
            $item['result']
        );

        if (!isset($groups[$key])) {
            $groups[$key] = array(
                'condition' =>
                    $item['condition'],

                'action' =>
                    $item['action'],

                'result' =>
                    $item['result'],

                'history_count' => 0,

                'verified_count' => 0
            );
        }

        $groups[$key]['history_count']++;

        if ($item['verification'] >= 1.0) {
            $groups[$key]['verified_count']++;
        }
    }

    foreach ($groups as $key => $group) {

        $groups[$key]['stability'] =
            $this->calculateStability(
                $group['verified_count'],
                $group['history_count']
            );
    }

    return array_values($groups);
}

203.35 Pattern Key

protected function buildPatternKey(
    $condition,
    $action,
    $result
) {
    return md5(
        serialize(
            array(
                $condition,
                $action,
                $result
            )
        )
    );
}

这里的 md5() 只是用于生成结构键，不是用于 AI 计算。

203.36 稳定性计算

$Stability=NverifiedNhistoryStability = \frac{N_{verified}} {N_{history}}$

PHP：

protected function calculateStability(
    $verified,
    $total
) {
    if ($total <= 0) {
        return 0.0;
    }

    return $this->normalize(
        $verified / $total
    );
}

203.37 经验调用PHP实现

public function callExperience(
    $experiences,
    $context
) {
    $results = array();

    foreach ($experiences as $experience) {

        $match =
            $this->matchExperience(
                $experience,
                $context
            );

        if ($match['status'] === 'unmatched') {
            continue;
        }

        $score =
            $this->calculateExperienceScore(
                $match
            );

        $results[] = array(
            'experience' => $experience,
            'match' => $match,
            'score' => $score
        );
    }

    usort(
        $results,
        array($this, 'sortExperience')
    );

    return $results;
}

203.38 经验匹配

protected function matchExperience(
    $experience,
    $context
) {
    $objectMatch = false;
    $stateMatch = false;
    $goalMatch = false;
    $conditionMatch = false;

    if (isset($experience['object_id']) &&
        isset($context['object_id'])) {

        $objectMatch =
            $experience['object_id'] ==
            $context['object_id'];
    }

    if (isset($experience['state']) &&
        isset($context['state'])) {

        $stateMatch =
            $experience['state'] ==
            $context['state'];
    }

    if (isset($experience['goal_id']) &&
        isset($context['goal_id'])) {

        $goalMatch =
            $experience['goal_id'] ==
            $context['goal_id'];
    }

    if (isset($experience['condition']) &&
        isset($context['condition'])) {

        $conditionMatch =
            $this->matchCondition(
                $experience['condition'],
                $context['condition']
            );
    }

    $matchedCount = 0;
    $dimensionCount = 0;

    if (isset($experience['object_id'])) {
        $dimensionCount++;

        if ($objectMatch) {
            $matchedCount++;
        }
    }

    if (isset($experience['state'])) {
        $dimensionCount++;

        if ($stateMatch) {
            $matchedCount++;
        }
    }

    if (isset($experience['goal_id'])) {
        $dimensionCount++;

        if ($goalMatch) {
            $matchedCount++;
        }
    }

    if (isset($experience['condition'])) {
        $dimensionCount++;

        if ($conditionMatch) {
            $matchedCount++;
        }
    }

    if ($dimensionCount == 0) {
        return array(
            'status' => 'unknown',
            'score' => 0.0
        );
    }

    $score =
        $matchedCount / $dimensionCount;

    if ($score >= 1.0) {
        $status = 'matched';
    } elseif ($score > 0) {
        $status = 'partial';
    } else {
        $status = 'unmatched';
    }

    return array(
        'object_match' => $objectMatch,
        'state_match' => $stateMatch,
        'goal_match' => $goalMatch,
        'condition_match' => $conditionMatch,
        'status' => $status,
        'score' => $score
    );
}

203.39 Condition匹配

条件匹配不能简单依赖字符串完全相等。

可以使用结构化条件。

protected function matchCondition(
    $experienceCondition,
    $currentCondition
) {
    if (!is_array($experienceCondition) ||
        !is_array($currentCondition)) {

        return false;
    }

    foreach ($experienceCondition as $key => $value) {

        if (!array_key_exists(
            $key,
            $currentCondition
        )) {
            return false;
        }

        if ($currentCondition[$key] != $value) {
            return false;
        }
    }

    return true;
}

其逻辑：

$Match(Ce,Cc)=⋀iMatch(cei,cci)Match(C_e,C_c) = \bigwedge_i Match(c_{e_i},c_{c_i})$

203.40 Experience Score

经验排序：

protected function calculateExperienceScore(
    $match
) {
    $score = 0.0;

    $score +=
        $match['score'] * 0.6;

    if (!empty($match['state_match'])) {
        $score += 0.1;
    }

    if (!empty($match['goal_match'])) {
        $score += 0.1;
    }

    if (!empty($match['condition_match'])) {
        $score += 0.2;
    }

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

这里的 0.6 / 0.1 / 0.1 / 0.2 是明确的规则权重。

生产系统中应该从规则配置读取，而不是把所有业务规则永久硬编码在 Engine 中。

203.41 经验排序

protected function sortExperience(
    $a,
    $b
) {
    if ($a['score'] == $b['score']) {
        return 0;
    }

    return ($a['score'] > $b['score'])
        ? -1
        : 1;
}

所以：

$Score(E1)>Score(E2)Score(E_1)>Score(E_2)$

则：

$E1E_1$

优先被调用。

203.42 经验更新PHP实现

public function calculateUpdate($input)
{
    $experiences = isset($input['experiences'])
        ? $input['experiences']
        : array();

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

    $updates = array();

    foreach ($experiences as $experience) {

        $comparison =
            $this->compareExperience(
                $experience,
                $newFact
            );

        $updateType =
            $this->determineUpdateType(
                $comparison
            );

        $updates[] = array(
            'experience' => $experience,
            'comparison' => $comparison,
            'update_type' => $updateType,
            'time' => time()
        );
    }

    return $updates;
}

203.43 经验比较

protected function compareExperience(
    $experience,
    $newFact
) {
    $conditionSame =
        $this->sameValue(
            isset($experience['condition'])
                ? $experience['condition']
                : array(),
            isset($newFact['condition'])
                ? $newFact['condition']
                : array()
        );

    $resultSame =
        $this->sameValue(
            isset($experience['result'])
                ? $experience['result']
                : array(),
            isset($newFact['result'])
                ? $newFact['result']
                : array()
        );

    $actionSame =
        $this->sameValue(
            isset($experience['action'])
                ? $experience['action']
                : array(),
            isset($newFact['action'])
                ? $newFact['action']
                : array()
        );

    if ($conditionSame &&
        $actionSame &&
        $resultSame) {

        return 'confirmed';
    }

    if ($conditionSame &&
        $actionSame &&
        !$resultSame) {

        return 'conflict';
    }

    if ($conditionSame &&
        !$actionSame) {

        return 'revised';
    }

    return 'unrelated';
}

203.44 更新类型计算

protected function determineUpdateType(
    $comparison
) {
    switch ($comparison) {

        case 'confirmed':
            return 'strengthen';

        case 'conflict':
            return 'conflict';

        case 'revised':
            return 'revise';

        case 'unrelated':
        default:
            return 'no_change';
    }
}

因此：

$Comparison→UpdateTypeComparison \rightarrow UpdateType$

203.45 经验真正更新

计算出更新候选后，再执行更新。

public function updateExperience(
    $experience,
    $update
) {
    if (!is_array($experience)) {
        return array(
            'status' => 'invalid'
        );
    }

    $type =
        isset($update['update_type'])
            ? $update['update_type']
            : 'no_change';

    switch ($type) {

        case 'strengthen':

            $experience =
                $this->strengthenExperience(
                    $experience
                );

            break;

        case 'conflict':

            $experience =
                $this->markExperienceConflict(
                    $experience
                );

            break;

        case 'revise':

            $experience =
                $this->reviseExperience(
                    $experience,
                    $update
                );

            break;

        case 'no_change':
        default:
            break;
    }

    return array(
        'status' => 'updated',
        'experience' => $experience,
        'type' => $type,
        'time' => time()
    );
}

203.46 经验强化

protected function strengthenExperience(
    $experience
) {
    $confirmed =
        isset($experience['confirmed_count'])
            ? (int)$experience['confirmed_count']
            : 0;

    $observed =
        isset($experience['observed_count'])
            ? (int)$experience['observed_count']
            : 0;

    $confirmed++;
    $observed++;

    $experience['confirmed_count'] =
        $confirmed;

    $experience['observed_count'] =
        $observed;

    if ($observed > 0) {
        $experience['confidence'] =
            $confirmed / $observed;
    }

    $experience['state'] =
        'confirmed';

    $experience['updated_at'] =
        time();

    return $experience;
}

203.47 经验冲突

protected function markExperienceConflict(
    $experience
) {
    $experience['state'] =
        'conflicted';

    $experience['updated_at'] =
        time();

    if (!isset(
        $experience['conflict_count']
    )) {
        $experience['conflict_count'] = 0;
    }

    $experience['conflict_count']++;

    return $experience;
}

注意：

$Conflict≠DeleteConflict \neq Delete$

冲突经验仍然保留，因为它是历史事实的一部分。

203.48 经验修订

protected function reviseExperience(
    $experience,
    $update
) {
    if (isset(
        $update['new_condition']
    )) {
        $experience['condition'] =
            $update['new_condition'];
    }

    if (isset(
        $update['new_action']
    )) {
        $experience['action'] =
            $update['new_action'];
    }

    if (isset(
        $update['new_result']
    )) {
        $experience['result'] =
            $update['new_result'];
    }

    $experience['state'] =
        'revised';

    $experience['updated_at'] =
        time();

    return $experience;
}

203.49 通用值比较

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

该方法用于确定两个结构化事实是否完全一致。

203.50 数值归一化

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

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

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

    return $value;
}

这样所有内部评分都可以统一到：

$0≤X≤10\leq X\leq1$

203.51 ExperienceEngine统一入口

最终可以提供：

public function process($input)
{
    $calculation =
        $this->calculateExperience(
            $input
        );

    $calling =
        $this->callExperience(
            isset($input['experiences'])
                ? $input['experiences']
                : array(),
            isset($input['context'])
                ? $input['context']
                : array()
        );

    $updates =
        $this->calculateUpdate(
            $input
        );

    return array(
        'experience_calculation' =>
            $calculation,

        'experience_calling' =>
            $calling,

        'experience_updates' =>
            $updates,

        'status' => 'calculated',

        'time' => time()
    );
}

这样形成：

$ExperienceEngine.process()ExperienceEngine.process()$

统一执行：

$Calculation→Calling→UpdatingCalculation \rightarrow Calling \rightarrow Updating$

203.52 一个完整的实际计算数据结构

输入：

$input = array(
    'history' => array(
        array(
            'object_id' => 1001,
            'condition' => array(
                'state' => 'ready',
                'temperature' => 'normal'
            ),
            'method' => 2001,
            'result' => array(
                'status' => 'success'
            ),
            'verification' => true
        ),

        array(
            'object_id' => 1001,
            'condition' => array(
                'state' => 'ready',
                'temperature' => 'normal'
            ),
            'method' => 2001,
            'result' => array(
                'status' => 'success'
            ),
            'verification' => true
        )
    ),

    'context' => array(
        'object_id' => 1001,
        'state' => 'ready',
        'condition' => array(
            'state' => 'ready',
            'temperature' => 'normal'
        )
    ),

    'experiences' => array(
        array(
            'id' => 5001,
            'object_id' => 1001,
            'condition' => array(
                'state' => 'ready',
                'temperature' => 'normal'
            ),
            'action' => array(
                'type' => 'method',
                'id' => 2001
            ),
            'result' => array(
                'status' => 'success'
            ),
            'state' => 'active',
            'confidence' => 0.8
        )
    ),

    'new_fact' => array(
        'object_id' => 1001,
        'condition' => array(
            'state' => 'ready',
            'temperature' => 'normal'
        ),
        'action' => array(
            'type' => 'method',
            'id' => 2001
        ),
        'result' => array(
            'status' => 'success'
        )
    )
);

执行：

$engine =
    new ExperienceEngine();

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

得到的结果结构可以类似：

array(
    'experience_calculation' => array(
        // 根据历史计算出的经验候选
    ),

    'experience_calling' => array(
        // 与当前对象、状态、条件匹配的经验
    ),

    'experience_updates' => array(
        // confirmed / strengthen / conflict / revise
    ),

    'status' => 'calculated',

    'time' => 1726000000
);

这里的关键不是返回某一个固定数值，而是完整保留：

$Input→Pattern→Match→Score→UpdateInput \rightarrow Pattern \rightarrow Match \rightarrow Score \rightarrow Update$

整个计算过程。

203.53 PHP工程中的Service边界

ExperienceEngine 不应该直接承担数据库事务。

正确结构：

Controller
    ↓
ExperienceService
    ↓
ExperienceEngine
    ↓
ExperienceRepository
    ↓
MySQL

ExperienceService：

class ExperienceService
{
    protected $engine;
    protected $repository;

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

    public function calculate($input)
    {
        return $this->engine->process($input);
    }
}

因此：

$ExperienceService=流程协调ExperienceService = 流程协调$ $ExperienceEngine=经验计算ExperienceEngine = 经验计算$ $ExperienceRepository=经验持久化ExperienceRepository = 经验持久化$

203.54 数据库结构

ExperienceEngine 对应的持久化层可以使用：

experiences
experience_history
experience_conditions
experience_patterns
experience_relations
experience_verifications
experience_usage
experience_conflicts
experience_updates

其中：

experiences

保存正式经验。

experience_history

保存经验形成所依据的历史。

experience_conditions

保存经验适用条件。

experience_patterns

保存结构化模式。

experience_relations

保存经验之间的关系。

experience_verifications

保存验证记录。

experience_usage

保存经验何时被调用。

experience_conflicts

保存经验冲突。

experience_updates

保存经验更新过程。

203.55 ExperienceEngine与MemoryEngine的工程关系

上一章 MemoryEngine：

$History→MemoryHistory \rightarrow Memory$

本章 ExperienceEngine：

$History+Memory→ExperienceHistory + Memory \rightarrow Experience$

所以：

$MemoryEngine→ExperienceEngineMemoryEngine \rightarrow ExperienceEngine$

例如：

History
  ↓
MemoryEngine
  ↓
Memory
  ↓
ExperienceEngine
  ↓
Experience

但不能理解成：

$Memory=ExperienceMemory=Experience$

二者必须保持独立的数据结构。

203.56 ExperienceEngine与LearningEngine

经验形成以后，可以进入 LearningEngine：

Experience
   ↓
Evidence
   ↓
Verification
   ↓
Learning Candidate
   ↓
Knowledge / Capability / Method

因此：

$ExperienceEngine→LearningEngineExperienceEngine \rightarrow LearningEngine$

但是：

$ExperienceEngine≠LearningEngineExperienceEngine \neq LearningEngine$

ExperienceEngine 发现模式。

LearningEngine 判断是否应该改变系统未来的认知基础。

203.57 ExperienceEngine与RiskEngine

经验还可以帮助风险计算：

$Experience→RiskCandidateExperience \rightarrow RiskCandidate$

例如：

过去：

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

重复出现。

RiskEngine 可以得到：

$RiskCandidate=C1+M1+HistoricalFailureRiskCandidate = C_1+M_1+HistoricalFailure$

然后计算：

$RiskScoreRiskScore$

因此：

$ExperienceEngine→RiskEngineExperienceEngine \rightarrow RiskEngine$

但 ExperienceEngine 本身不负责风险处理。

203.58 ExperienceEngine与DecisionEngine

完整关系：

$ExperienceRecall→CandidateEvidence→DecisionEngineExperienceRecall \rightarrow CandidateEvidence \rightarrow DecisionEngine$

Experience 只是 Decision 的依据之一。

最终：

$Decision=f(Goal,State,Capability,Method,Risk,Conflict,Knowledge,Memory,Experience)Decision = f( Goal, State, Capability, Method, Risk, Conflict, Knowledge, Memory, Experience )$

仍然采用确定性规则和离散计算。

203.59 ExperienceEngine完整认知闭环

完整经验闭环：

$Execution→Result→Feedback→History→Memory→ExperienceExecution \rightarrow Result \rightarrow Feedback \rightarrow History \rightarrow Memory \rightarrow Experience$

然后：

$Experience→Recall→Decision→Behavior→Action→ExecutionExperience \rightarrow Recall \rightarrow Decision \rightarrow Behavior \rightarrow Action \rightarrow Execution$

形成：

$Experience→Decision→Execution→Result→Feedback→ExperienceExperience \rightarrow Decision \rightarrow Execution \rightarrow Result \rightarrow Feedback \rightarrow Experience$

如果新的事实支持经验：

$Experience→StrengthenExperience \rightarrow Strengthen$

如果新的事实不一致：

$Experience→Conflict→Diagnosis→RevisionExperience \rightarrow Conflict \rightarrow Diagnosis \rightarrow Revision$

如果长期失效：

$Experience→Outdated→ArchivedExperience \rightarrow Outdated \rightarrow Archived$

203.60 ExperienceEngine确定性原则

ExperienceEngine 必须保持确定性和可解释性。

对于相同：

$History+Memory+Condition+RuleHistory + Memory + Condition + Rule$

应得到相同的：

$PatternPattern$

对于相同：

$Experience+RuntimeExperience + Runtime$

应得到相同的：

$MatchMatch$

和：

$ScoreScore$

因此：

$f(X)=Yf(X)=Y$

而不是：

$f(X)=Random(Y)f(X)=Random(Y)$

ExperienceEngine 不需要：

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

它使用：

$History+Memory+Condition+Result+Relation+Rule+VerificationHistory + Memory + Condition + Result + Relation + Rule + Verification$

形成经验计算。

203.61 ExperienceEngine可解释性

每一次经验计算必须能够追溯：

经验从哪些历史形成？

哪些 Memory 支持经验？

经验适用什么条件？

为什么当前调用这个经验？

为什么这个经验排名较高？

为什么经验被确认？

为什么经验发生冲突？

为什么经验被修订？

因此：

$History→Evidence→Pattern→ExperienceHistory \rightarrow Evidence \rightarrow Pattern \rightarrow Experience$

调用：

$Runtime→Match→Score→RecallRuntime \rightarrow Match \rightarrow Score \rightarrow Recall$

更新：

$NewFact→Compare→Verify→UpdateNewFact \rightarrow Compare \rightarrow Verify \rightarrow Update$

整个过程都可以通过结构化数据追踪。

203.62 ExperienceEngine最终架构

                         ExperienceEngine
                                │
             ┌──────────────────┼──────────────────┐
             ↓                  ↓                  ↓
     ExperienceCalculation ExperienceCalling ExperienceUpdating
             │                  │                  │
             ↓                  ↓                  ↓
          History             Context          New Fact
             │                  │                  │
             ↓                  ↓                  ↓
          Pattern            Matching          Comparison
             │                  │                  │
             ↓                  ↓                  ↓
        Verification          Ranking          Conflict
             │                  │                  │
             ↓                  ↓                  ↓
        Experience            Recall           Revision
             │                  │                  │
             └──────────────────┼──────────────────┘
                                ↓
                       Experience Result
                                │
              ┌─────────────────┼─────────────────┐
              ↓                 ↓                 ↓
       DecisionEngine     RiskEngine       LearningEngine

203.63 第203章总结

ExperienceEngine 的核心不是保存历史，而是从历史和记忆中形成可以再次调用的结构化经验。

核心模型：

$Experience=(H,M,C,R,P)Experience=(H,M,C,R,P)$

核心引擎：

$ExperienceEngine=ExperienceCalculation+ExperienceCalling+ExperienceUpdatingExperienceEngine = ExperienceCalculation + ExperienceCalling + ExperienceUpdating$

经验计算：

$History+Memory→Comparison→Pattern→ExperienceHistory + Memory \rightarrow Comparison \rightarrow Pattern \rightarrow Experience$

经验调用：

$CurrentContext→Matching→Ranking→RecallCurrentContext \rightarrow Matching \rightarrow Ranking \rightarrow Recall$

经验更新：

$NewFact→Comparison→Verification→Confirm/Strengthen/Revise/ConflictNewFact \rightarrow Comparison \rightarrow Verification \rightarrow Confirm/Strengthen/Revise/Conflict$

最终闭环：

$Result→Feedback→History→Memory→Experience→Decision→Behavior→Execution→ResultResult \rightarrow Feedback \rightarrow History \rightarrow Memory \rightarrow Experience \rightarrow Decision \rightarrow Behavior \rightarrow Execution \rightarrow Result$

因此，在 ICAI 的完整认知体系中：

$Memory=过去有价值的信息Memory = 过去有价值的信息$ $Experience=过去形成的结构化模式Experience = 过去形成的结构化模式$ $Knowledge=经过验证并可计算应用的认知知识Knowledge = 经过验证并可计算应用的认知知识$ $Learning=改变未来认知基础的更新过程Learning = 改变未来认知基础的更新过程$

四者形成：

$Memory→Experience→Learning→Knowledge/Capability/MethodMemory \rightarrow Experience \rightarrow Learning \rightarrow Knowledge/Capability/Method$

而 ExperienceEngine 正处于这一认知链条的关键位置。

它使 ICAI 不仅能够“记住过去”，还能够从过去形成结构化经验，并将经验重新带回当前的决策、风险、方法和行为计算中。

第203章 ExperienceEngine

第203章 ExperienceEngine

203.1 ExperienceEngine概述

203.2 Experience与Memory的区别

203.3 ExperienceEngine核心模型

203.4 ExperienceEngine三大功能

一、经验计算

二、经验调用

三、经验更新

203.5 经验候选

203.6 经验计算

203.7 经验模式模型

203.8 经验成功率

203.9 经验稳定性

203.10 经验状态

Candidate

Formed

Verified

Active

Used

Confirmed

Revised

Conflicted

Outdated

Archived

203.11 经验验证

203.12 经验调用

203.13 经验匹配

203.14 ExperienceMatchResult

203.15 经验调用排序

203.16 经验调用不是决策

203.17 当前事实优先于经验

203.18 经验更新

203.19 经验确认

203.20 经验强化

203.21 经验冲突

203.22 经验修订

203.23 经验与LearningEngine

203.24 Experience与Knowledge

203.25 ExperienceEngine与DecisionEngine

203.26 ExperienceEngine完整PHP实现

203.27 ExperienceEngine类

203.28 经验计算PHP实现

203.29 History有效性验证

203.30 条件提取

203.31 Action/Method提取

203.32 Result提取

203.33 历史验证

203.34 Pattern分组

203.35 Pattern Key

203.36 稳定性计算

203.37 经验调用PHP实现

203.38 经验匹配

203.39 Condition匹配

203.40 Experience Score

203.41 经验排序

203.42 经验更新PHP实现

203.43 经验比较

203.44 更新类型计算

203.45 经验真正更新

203.46 经验强化

203.47 经验冲突

203.48 经验修订

203.49 通用值比较

203.50 数值归一化

203.51 ExperienceEngine统一入口

203.52 一个完整的实际计算数据结构

203.53 PHP工程中的Service边界

203.54 数据库结构

experiences

experience_history

experience_conditions

experience_patterns

experience_relations

experience_verifications

experience_usage

experience_conflicts

experience_updates

203.55 ExperienceEngine与MemoryEngine的工程关系

203.56 ExperienceEngine与LearningEngine

第203章　ExperienceEngine

第203章　ExperienceEngine