第203章　ExperienceEngine

203.1 ExperienceEngine定义

在ICAI体系中，FeedbackEngine负责把实际执行结果转换为结构化反馈，MemoryEngine负责保存和调用过去的重要信息，而ExperienceEngine进一步负责从历史、记忆、结果和反馈中形成可计算的经验，并在当前认知过程中调用这些经验。

因此，ExperienceEngine可以定义为：

$ExperienceEngine=ExperienceCalculation+ExperienceRecall+ExperienceUpdateExperienceEngine= ExperienceCalculation+ ExperienceRecall+ ExperienceUpdate$

即：

ExperienceEngine = 经验计算 + 经验调用 + 经验更新

它解决三个核心问题：

过去发生过什么？
        ↓
这些历史形成了什么经验？
        ↓
当前情况是否可以调用这些经验？
        ↓
新的实际结果是否需要更新原有经验？

ExperienceEngine不是简单的经验数据库，也不是简单统计“成功次数”。

它负责把过去的历史事实转换为当前可以参与认知计算的结构化经验。

203.2 Experience基本概念

第164章已经定义Experience：

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

其中：

$HH$ ：History，历史；
$MM$ ：Memory，记忆；
$CC$ ：Condition，经验成立条件；
$RR$ ：Result，历史结果；
$PP$ ：Pattern，经验模式。

因此经验并不是一次Result。

例如：

History：
第一次使用Method A，结果成功

History：
第二次使用Method A，结果成功

History：
第三次使用Method A，结果成功

经过条件和结果比较，可以形成：

Experience：

在Condition C下，
Method A具有较高的成功可能性。

因此：

$Experience≠HistoryExperience\neq History$ $Experience≠MemoryExperience\neq Memory$ $Experience≠ResultExperience\neq Result$

经验是从多个实际事实中形成的结构化模式。

203.3 ExperienceEngine核心模型

ExperienceEngine可以定义为：

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

其中：

$HH$ ：History；
$MM$ ：Memory；
$CC$ ：Condition；
$PP$ ：Pattern；
$RR$ ：Result；
$VV$ ：Verification；
$TT$ ：Time。

其核心流程为：

History
 ↓
Memory
 ↓
Condition Extraction
 ↓
Result Comparison
 ↓
Pattern Calculation
 ↓
Experience
 ↓
Verification

ExperienceEngine不是直接把History复制成Experience，而是进行条件、结果、关系和重复模式计算。

203.4 ExperienceEngine与ExperienceService

ExperienceService属于Service层。

ExperienceEngine属于Engine层。

两者必须保持职责分离。

ExperienceService负责：

接收请求
加载历史
加载Memory
调用ExperienceEngine
组织Experience
保存Experience
协调其他Service

ExperienceEngine负责：

经验计算
条件匹配
模式计算
经验调用判断
经验更新计算
经验验证

因此：

$ExperienceService=OrchestrationExperienceService=Orchestration$ $ExperienceEngine=CalculationExperienceEngine=Calculation$

架构为：

Controller
 ↓
ExperienceService
 ↓
ExperienceEngine
 ↓
MemoryEngine / KnowledgeEngine
 ↓
ExperienceResult
 ↓
ExperienceRepository
 ↓
MySQL

203.5 ExperienceEngine输入

ExperienceEngine主要使用以下数据：

History
Memory
Result
Feedback
State
Condition
Method
Capability
Knowledge
Decision
Behavior
Verification
Time

可以定义：

$InputE=(H,M,R,F,S,C,Mt,K,D,B,V,T)Input_E= (H,M,R,F,S,C,Mt,K,D,B,V,T)$

其中：

$HH$ ：History；
$MM$ ：Memory；
$RR$ ：Result；
$FF$ ：Feedback；
$SS$ ：State；
$CC$ ：Condition；
$MtMt$ ：Method；
$KK$ ：Knowledge；
$DD$ ：Decision；
$BB$ ：Behavior；
$VV$ ：Verification；
$TT$ ：Time。

并不是所有Experience计算都必须使用全部输入。

ExperienceEngine应该根据经验类型选择实际需要的数据。

203.6 经验计算

Experience计算的核心是：

历史事实
 ↓
条件提取
 ↓
结果比较
 ↓
重复关系
 ↓
模式识别
 ↓
经验候选
 ↓
验证

可以定义：

$Ec=Calculate(H,M,C,R,F,V)E_c= Calculate(H,M,C,R,F,V)$

其中：

$HH$ ：历史事实；
$MM$ ：记忆；
$CC$ ：条件；
$RR$ ：结果；
$FF$ ：反馈；
$VV$ ：验证。

ExperienceEngine输出的是Experience Candidate，而不是未经验证的经验。

203.7 历史不是经验

History记录：

实际发生过什么。

例如：

2026-09-01
Method A
Result = Success

2026-09-03
Method A
Result = Success

2026-09-05
Method A
Result = Failed

这些都是历史事实。

ExperienceEngine进一步分析：

Method A
Condition X
Success = 2
Failure = 1

然后继续分析：

Failure是否由Condition Y导致？

如果能够确认：

Condition X → Method A → Success
Condition Y → Method A → Failure

才可以形成更加准确的经验结构。

因此：

$History≠ExperienceHistory\neq Experience$

203.8 Memory不是经验

Memory主要保存可被未来认知过程调用的信息。

例如：

Memory：
Object A具有属性B

Experience则描述：

在Condition C下，
使用Method M处理Object A，
通常产生Result R。

因此：

Memory：
是什么

Experience：
在什么条件下，
过去采用什么方式，
产生了什么结果

可以表示：

$Memory=InformationMemory=Information$ $Experience=Patterned HistoryExperience=Patterned\ History$

203.9 经验条件计算

经验必须具有适用条件。

定义：

$EC=(O,S,C,R,T)EC=(O,S,C,R,T)$

其中：

$OO$ ：Object；
$SS$ ：State；
$CC$ ：Condition；
$RR$ ：Resource；
$TT$ ：Time。

例如：

Object = Order
State = Pending
Condition = Payment Verified
Method = ProcessOrder

如果历史中大量出现：

Pending
+
Payment Verified
+
ProcessOrder
→
Processing

则ExperienceEngine可以形成：

Experience Pattern：

当Order处于Pending，
且Payment已经Verified，
ProcessOrder通常能够使Order进入Processing。

203.10 经验模式

经验模式可以定义：

$P=(C,A,R,S)P=(C,A,R,S)$

其中：

$CC$ ：Condition；
$AA$ ：Action或Method；
$RR$ ：Result；
$SS$ ：State Change。

例如：

Condition：
库存充足

Method：
ShipOrder

Result：
Shipment Created

State：
Ready → Shipped

经验模式可以表示：

$C+A→R+SC+A\rightarrow R+S$

这成为未来经验调用的基础。

203.11 经验形成

经验形成过程：

History
 ↓
History Selection
 ↓
Memory
 ↓
Condition Extraction
 ↓
Result Comparison
 ↓
Pattern Calculation
 ↓
Experience Candidate
 ↓
Verification
 ↓
Experience

因此Experience不是自动从单次事件产生。

最低原则是：

经验必须建立在实际历史事实之上。

203.12 单次结果与经验

某个Action第一次成功：

Action A
 ↓
Result Success

不能立即得出：

Method A永远有效

正确处理是：

Result Success
 ↓
History
 ↓
Memory
 ↓
Experience Candidate

随着更多事实进入：

Success
Success
Success

并且条件保持一致：

Condition C

经验可信程度才可能提高。

因此：

$OneResult≠StableExperienceOneResult\neq StableExperience$

203.13 经验计算的重复性

经验通常需要计算历史中的重复模式。

例如：

H1：
C1 → M1 → R1

H2：
C1 → M1 → R1

H3：
C1 → M1 → R1

H4：
C2 → M1 → R2

ExperienceEngine可以计算：

C1 + M1 → R1

具有重复性。

而：

C2 + M1 → R2

可能属于另外一种经验。

因此经验计算必须保留条件，不能只统计Method本身。

203.14 经验一致性

如果历史数据出现：

C1 → M1 → R1
C1 → M1 → R1
C1 → M1 → R2

ExperienceEngine不能直接认定：

C1 → M1 → R1

必须继续计算：

R1数量
R2数量
条件差异
状态差异
资源差异
环境差异
时间差异

这样才能判断：

条件是否缺失？
结果是否存在冲突？
是否需要拆分经验？

203.15 经验冲突

经验之间可能发生冲突。

例如：

Experience E1：

Condition C
Method M
Result R1

同时：

Experience E2：

Condition C
Method M
Result R2

如果R1和R2不能同时成立，则形成：

Experience Conflict

ExperienceEngine应该输出：

Conflict Candidate

而不是擅自删除其中一个经验。

后续可以交给：

ConflictEngine

进一步处理。

203.16 经验计算结果

可以定义：

$ECR=(E,C,P,R,V,S,T)ECR=(E,C,P,R,V,S,T)$

其中：

$EE$ ：Experience Candidate；
$CC$ ：Condition；
$PP$ ：Pattern；
$RR$ ：Result；
$VV$ ：Verification；
$SS$ ：Status；
$TT$ ：Time。

状态可以包括：

Candidate
Calculated
Verified
Conflicted
Outdated
Rejected
Active
Archived

203.17 经验调用

ExperienceEngine第二项核心能力是Experience Recall。

经验调用解决的问题是：

当前情况与过去经验是否具有可用关系？

基本流程：

Current Runtime
 ↓
Current Object
 ↓
Current State
 ↓
Current Condition
 ↓
Experience Matching
 ↓
Applicable Experience

可以定义：

$Recall(E,C,R,S)→EaRecall(E,C,R,S)\rightarrow E_a$

其中：

$EE$ ：Experience；
$CC$ ：Current Condition；
$RR$ ：Current Runtime；
$SS$ ：Current State；
$EaE_a$ ：Applicable Experience。

203.18 经验调用不是简单查询

Experience调用不能只是：

SELECT * FROM experiences;

然后全部返回。

因为系统需要判断：

当前对象
当前状态
当前条件
当前方法
当前目标
当前环境

是否与经验成立条件匹配。

因此：

$ExperienceRecall=ExperienceMatching+ConditionEvaluation+ApplicabilityCheckExperienceRecall= ExperienceMatching+ ConditionEvaluation+ ApplicabilityCheck$

203.19 当前条件匹配

例如经验：

Object = Order
State = Pending
Condition = PaymentVerified
Method = ProcessOrder
Result = Processing

当前Runtime：

Object = Order
State = Pending
Condition = PaymentVerified

ExperienceEngine计算：

Object = Match
State = Match
Condition = Match

则：

Experience = Applicable

203.20 经验调用状态

经验调用不能只有：

found
not found

可以定义：

Applicable
PartiallyApplicable
NotApplicable
Unknown
Conflicted
Outdated
Blocked

例如：

Object Match
State Match
Condition Partial

则：

PartiallyApplicable

而不是直接：

Applicable

203.21 经验适用度

可以定义：

$EA=Type∧Object∧State∧Condition∧Time∧VerificationEA= Type \land Object \land State \land Condition \land Time \land Verification$

只有满足必要条件，经验才可以进入后续认知计算。

其中：

Type：经验类型匹配；
Object：对象匹配；
State：状态匹配；
Condition：条件匹配；
Time：时间有效；
Verification：经验已经验证。

203.22 经验调用与DecisionEngine

ExperienceEngine不负责最终决策。

例如：

Experience E1：
Method A → Success

Experience E2：
Method B → Success

当前Goal：

完成Goal G

ExperienceEngine只负责提供：

E1 Applicable
E2 Applicable

然后：

ExperienceEngine
 ↓
Applicable Experiences
 ↓
MethodEngine
 ↓
DecisionEngine
 ↓
Final Decision

因此：

$ExperienceRecall≠DecisionExperienceRecall\neq Decision$

经验提供依据。

DecisionEngine负责选择。

203.23 经验调用与MethodEngine

经验可以影响Method计算。

例如：

Current Condition
 ↓
Experience
 ↓
Method Candidate

ExperienceEngine输出：

Method A has historical experience

MethodEngine再计算：

Method A
Condition
Capability
Resource
Process

最后DecisionEngine选择。

因此：

ExperienceEngine
      ↓
MethodEngine
      ↓
DecisionEngine

而不是：

ExperienceEngine
      ↓
直接执行Method

203.24 经验调用与CapabilityEngine

经验也可以用于能力判断。

例如历史显示：

Object A
Capability C
Condition X
Execution Success

当前情况：

Object A
Condition X

ExperienceEngine可以提供历史经验。

CapabilityEngine再结合：

Current State
Current Range
Current Verification

判断当前Capability是否可用。

因此：

$Experience→CapabilityEvidenceExperience\rightarrow CapabilityEvidence$

但：

$Experience≠CapabilityExperience\neq Capability$

过去成功并不等于当前一定具备能力。

203.25 经验调用与RiskEngine

经验可以作为RiskEngine的重要历史依据。

例如：

过去100次执行Method A：

95次成功
5次失败

当前又准备执行：

Method A

ExperienceEngine可以返回：

Historical Experience

RiskEngine进一步计算风险。

因此：

ExperienceEngine
 ↓
Historical Pattern
 ↓
RiskEngine
 ↓
Risk Calculation

ExperienceEngine不直接生成RiskScore。

203.26 经验调用与KnowledgeEngine

经验可以辅助KnowledgeEngine。

例如：

Experience：
C + M → R

经过验证后，可以成为知识更新证据。

流程：

Experience
 ↓
Evidence
 ↓
KnowledgeEngine
 ↓
Knowledge Candidate
 ↓
Verification
 ↓
Knowledge

但：

$Experience≠KnowledgeExperience\neq Knowledge$

Experience强调：

过去实际发生形成的模式。

Knowledge强调：

系统当前认可的结构化事实或关系。

203.27 经验调用与MemoryEngine

MemoryEngine负责找到相关Memory。

ExperienceEngine负责根据Memory和历史形成经验并判断经验是否适用。

因此：

MemoryEngine
 ↓
Relevant Memory
 ↓
ExperienceEngine
 ↓
Experience Calculation
 ↓
Applicable Experience

二者形成：

$Memory→ExperienceMemory\rightarrow Experience$

203.28 经验更新

ExperienceEngine第三项核心能力是Experience Update。

经验不是永久不变的。

新的：

Result
Feedback
History
Verification
Environment
Condition

都可能改变经验。

因此：

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

其中：

$EtE_t$ ：当前经验；
$ΔF\Delta F$ ：经过验证的新事实；
$Et+1E_{t+1}$ ：更新后的经验。

203.29 经验更新来源

Experience更新可以来自：

New History
New Result
New Feedback
New State
New Verification
New Knowledge
New Diagnosis
New Repair
New Environment

但必须满足：

Actual Evidence
+
Valid Data
+
Applicable Condition
+
Verification

才可以形成有效更新。

203.30 经验更新类型

ExperienceEngine可以产生：

Create
Strengthen
Weaken
Modify
Split
Merge
Invalidate
Outdate
Conflict
Archive

例如：

Create

原来不存在：

C1 → M1 → R1

新的历史反复验证后：

Create Experience

Strengthen

已有：

C1 → M1 → R1

新的事实再次支持：

Strengthen

Weaken

连续出现不同结果：

C1 → M1 → R2

原经验支持程度下降：

Weaken

203.31 经验修改

如果发现原经验条件过于宽泛：

原经验：

Condition：
Payment

新历史发现：

只有Payment Verified
才会产生Result R1

则ExperienceEngine可以形成：

Condition：

Payment
+
PaymentVerified

这属于：

Experience Modification

而不是简单删除原经验。

203.32 经验拆分

如果：

C → M → R1
C → M → R2

后来发现实际上存在：

C1 → M → R1
C2 → M → R2

ExperienceEngine可以进行：

Experience Split

形成：

E1：
C1 → M → R1

E2：
C2 → M → R2

这可以解决经验条件过宽导致的冲突。

203.33 经验合并

如果两个经验：

C1 → M → R
C2 → M → R

经过分析发现：

C1
C2

属于同一个更高层条件：

则可以形成：

C → M → R

这就是：

Experience Merge

但合并必须有明确的条件兼容规则，不能因为结果相同就自动合并。

203.34 经验削弱

如果历史开始产生不同结果：

原经验：
C → M → R1

新历史：

C → M → R2

ExperienceEngine应当记录：

Experience Support ↓

但不能简单执行：

Experience = Invalid

必须进一步检查：

Condition
State
Object
Environment
Method Version
Resource
Time

是否发生变化。

203.35 经验失效

如果经验的成立条件已经不再存在：

Method M已经删除

或者：

Object Type已经改变

则原经验可能：

Outdated

如果已经明确证明经验不再成立，则可以：

Invalid

因此：

$Outdated≠InvalidOutdated\neq Invalid$

Outdated表示：

可能仍然有历史价值，但当前适用性下降。

Invalid表示：

已经有证据证明该经验不成立。

203.36 经验验证

经验必须进行验证。

可以定义：

$Verify(E)=H∧C∧R∧P∧VVerify(E)=H\land C\land R\land P\land V$

其中：

$HH$ ：History Evidence；
$CC$ ：Condition；
$RR$ ：Result；
$PP$ ：Pattern；
$VV$ ：Verification。

只有满足必要条件，Experience才能进入：

Verified

否则保持：

Candidate

或者：

Unverified

203.37 经验状态

Experience可以定义生命周期：

Formed
 ↓
Candidate
 ↓
Verified
 ↓
Active
 ↓
Used
 ↓
Confirmed
 ↓
Revised
 ↓
Archived

异常状态：

Candidate → Rejected
Active → Conflicted
Active → Outdated
Active → Invalid

因此：

$ExperienceState≠ResultStateExperienceState\neq ResultState$

经验状态描述经验本身，而不是一次Execution的状态。

203.38 经验使用记录

Experience被调用后，应该记录：

哪个Experience
什么时候调用
当前Condition是什么
是否匹配
是否被Decision采用
最终Result是什么

例如：

Experience E100
 ↓
Called
 ↓
Matched
 ↓
Used by Decision D200
 ↓
Method A
 ↓
Result Success

这样新的实际结果可以反向更新E100。

203.39 经验调用闭环

完整经验调用过程：

Current Runtime
 ↓
Current Object
 ↓
Current State
 ↓
Current Condition
 ↓
Experience Matching
 ↓
Applicable Experience
 ↓
Method / Capability / Risk / Decision
 ↓
Execution
 ↓
Result
 ↓
Feedback
 ↓
Experience Update

因此ExperienceEngine不是单向数据库查询，而是一个闭环计算Engine。

203.40 经验更新闭环

完整更新：

Experience
 ↓
Current Use
 ↓
Decision
 ↓
Behavior
 ↓
Action
 ↓
Execution
 ↓
Result
 ↓
Feedback
 ↓
History
 ↓
ExperienceEngine
 ↓
Experience Update

形成：

$Experiencet→Use→Result→Feedback→Experiencet+1Experience_t \rightarrow Use \rightarrow Result \rightarrow Feedback \rightarrow Experience_{t+1}$

203.41 ExperienceEngine与LearningEngine

Experience更新和Learning更新不能混为一谈。

ExperienceEngine负责：

经验形成
经验调用
经验更新

LearningEngine负责：

学习判断
知识更新
能力更新
方法更新

因此：

$ExperienceEngine≠LearningEngineExperienceEngine\neq LearningEngine$

关系为：

History
 ↓
ExperienceEngine
 ↓
Experience
 ↓
LearningEngine
 ↓
Knowledge
Capability
Method

Experience可以成为Learning的输入，但ExperienceEngine不直接承担整个学习过程。

203.42 ExperienceEngine与MemoryEngine

MemoryEngine：

Memory形成
Memory保存
Memory调用
Memory关系

ExperienceEngine：

Experience计算
Experience调用
Experience更新

关系：

History
 ↓
MemoryEngine
 ↓
Memory
 ↓
ExperienceEngine
 ↓
Experience

因此：

$Memory→ExperienceMemory\rightarrow Experience$

但：

$Memory≠ExperienceMemory\neq Experience$

203.43 ExperienceEngine与FeedbackEngine

FeedbackEngine产生可靠的执行反馈。

ExperienceEngine利用反馈形成新的经验依据。

关系：

Execution
 ↓
Result
 ↓
FeedbackEngine
 ↓
Feedback
 ↓
History
 ↓
ExperienceEngine

因此：

$Feedback→ExperienceFeedback\rightarrow Experience$

但：

$Feedback≠ExperienceFeedback\neq Experience$

203.44 ExperienceEngine与DecisionEngine

DecisionEngine负责：

现在选择什么。

ExperienceEngine负责：

过去什么模式在当前条件下可能具有参考价值。

因此：

ExperienceEngine
 ↓
Applicable Experience
 ↓
DecisionEngine
 ↓
Candidate Evaluation
 ↓
Decision

经验可以影响Decision，但不能替代Decision。

203.45 ExperienceEngine与RiskEngine

历史经验可以作为风险计算依据。

例如：

Experience：
Method A
Condition C
过去100次：
Success = 90
Failure = 10

当前：

Condition C
Method A

ExperienceEngine输出：

Applicable Experience

RiskEngine再计算：

Historical Failure Evidence
 ↓
Risk Probability
 ↓
Risk Score

因此：

$Experience→RiskEvidenceExperience\rightarrow RiskEvidence$

而不是：

$Experience=RiskExperience=Risk$

203.46 ExperienceEngine与DiagnosisEngine

诊断后的结果也可以进入经验。

例如：

Method A
 ↓
Failure
 ↓
Diagnosis
 ↓
Cause = Resource Insufficient

经过多次确认：

Condition：
Resource < Required

ExperienceEngine可以形成：

Experience：
当Resource不足时，
Method A容易失败。

因此：

Diagnosis
 ↓
Verified Cause
 ↓
History
 ↓
ExperienceEngine
 ↓
Experience

203.47 ExperienceEngine与RepairEngine

Repair结果也可以形成经验。

例如：

Failure
 ↓
Diagnosis
 ↓
Repair Method B
 ↓
Success

多次发生：

Same Failure
+
Repair Method B
→
Recovery

ExperienceEngine可以形成：

Repair Experience

以后遇到相同异常时：

Diagnosis
 ↓
Experience Recall
 ↓
Repair Candidate

再交由DecisionEngine选择。

203.48 ExperienceEngine经验类型

经验可以按照来源和用途分类：

MethodExperience
ActionExperience
BehaviorExperience
DecisionExperience
CapabilityExperience
RiskExperience
RepairExperience
StateTransitionExperience
ObjectExperience
EnvironmentExperience

例如：

MethodExperience

Condition → Method → Result

DecisionExperience

Condition → Candidate → Decision Result

RepairExperience

Problem → Repair → Recovery

StateTransitionExperience

State + Event + Condition → New State

这些经验类型仍然属于统一Experience模型，只是Pattern结构不同。

203.49 ExperienceEngine计算模型

可以进一步统一为：

$ExperienceCalculation=History+Memory+Condition+Pattern+Result+VerificationExperienceCalculation= History+ Memory+ Condition+ Pattern+ Result+ Verification$

经验计算：

$Ec=F(H,M,C,P,R,V)E_c=F(H,M,C,P,R,V)$

经验调用：

$Ea=Match(E,C,S,O,T,V)E_a=Match(E,C,S,O,T,V)$

经验更新：

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

形成：

Experience
 ├── Calculate
 ├── Recall
 └── Update

203.50 ExperienceEngine统一结果

ExperienceEngine可以输出：

$EER=(E,C,P,A,U,V,T)EER=(E,C,P,A,U,V,T)$

其中：

$EE$ ：Experience；
$CC$ ：Current Condition；
$PP$ ：Pattern；
$AA$ ：Applicability；
$UU$ ：Update；
$VV$ ：Verification；
$TT$ ：Time。

例如：

Experience Result
{
    experience_id: 1001,
    condition: C1,
    pattern: C1 + MethodA -> ResultR1,
    applicability: applicable,
    update: strengthen,
    verification: verified
}

203.51 经验权重

经验可以存在一个确定性的参考权重，但这里的权重不能理解为机器学习模型参数。

可以定义：

$We=f(F,R,V,T,A)W_e=f(F,R,V,T,A)$

其中：

$FF$ ：Frequency，历史出现次数；
$RR$ ：Result consistency，结果一致性；
$VV$ ：Verification，验证程度；
$TT$ ：Time，时间因素；
$AA$ ：Applicability，当前适用程度。

这个权重只是离散计算中的经验参考值。

它不是：

Neural Network Weight

也不是：

Embedding Weight

更不是：

LLM Parameter

203.52 时间衰减

经验可能随着时间降低当前适用性。

可以定义：

$Wt=W0×D(t)W_t=W_0\times D(t)$

其中：

$W0W_0$ ：原始经验权重；
$D(t)D(t)$ ：时间衰减函数；
$WtW_t$ ：当前参考权重。

例如某个经验来自旧版本Method：

Method V1

现在已经变成：

Method V2

那么V1经验不能继续以原权重参与当前计算。

203.53 经验权重与概率区别

Experience Weight与Probability必须区分。

例如：

Experience Weight = 0.85

不一定意味着：

Probability = 85%

权重表示：

当前经验在认知计算中的参考强度。

概率表示：

某事件发生的数学概率。

因此：

$Weight≠ProbabilityWeight\neq Probability$

如果需要概率，应由相应的Probability/Risk/Statistical Engine进行计算。

203.54 ExperienceEngine PHP OOP结构

在PHP OOP工程中，可以建立：

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

ExperienceEngine：

class ExperienceEngine extends Engine
{
    public function calculate($input)
    {
        $history = $input['history'];
        $memory = $input['memory'];
        $condition = $input['condition'];

        $pattern = $this->calculatePattern(
            $history,
            $memory,
            $condition
        );

        $experience = $this->buildExperience(
            $condition,
            $pattern
        );

        return array(
            'experience' => $experience,
            'pattern' => $pattern,
            'status' => 'candidate'
        );
    }

    protected function calculatePattern(
        $history,
        $memory,
        $condition
    ) {
        return array(
            'history' => $history,
            'memory' => $memory,
            'condition' => $condition
        );
    }

    protected function buildExperience(
        $condition,
        $pattern
    ) {
        return array(
            'condition' => $condition,
            'pattern' => $pattern
        );
    }
}

这里表达的是ExperienceEngine的OOP结构。

实际生产系统中的：

Pattern Calculation
Condition Matching
Verification
Update Rules
Conflict Handling

必须根据实际Domain Object、History、Memory和Rule实现，不能把上述结构示例视为已经完成生产验证。

203.55 ExperienceRecallEngine结构

如果工程规模较大，可以将经验调用拆分为专门计算组件：

class ExperienceRecallEngine extends Engine
{
    public function calculate($input)
    {
        $experiences = $input['experiences'];
        $condition = $input['condition'];

        $matches = array();

        foreach ($experiences as $experience) {
            if ($this->matchCondition(
                $experience,
                $condition
            )) {
                $matches[] = $experience;
            }
        }

        return array(
            'matches' => $matches
        );
    }

    protected function matchCondition(
        $experience,
        $condition
    ) {
        return true;
    }
}

这里的true只是结构占位，实际工程中必须替换为真实的：

Object Match
State Match
Condition Match
Time Match
Verification Match

不能把占位逻辑直接视为生产实现。

203.56 ExperienceUpdateEngine结构

经验更新也可以进一步独立：

class ExperienceUpdateEngine extends Engine
{
    public function calculate($input)
    {
        $experience = $input['experience'];
        $history = $input['history'];
        $feedback = $input['feedback'];

        $update = $this->calculateUpdate(
            $experience,
            $history,
            $feedback
        );

        return array(
            'experience' => $experience,
            'update' => $update
        );
    }

    protected function calculateUpdate(
        $experience,
        $history,
        $feedback
    ) {
        return array(
            'type' => 'modify'
        );
    }
}

这样可以形成：

ExperienceEngine
 ├── ExperienceCalculation
 ├── ExperienceRecallEngine
 └── ExperienceUpdateEngine

但在系统规模较小时，也可以统一由ExperienceEngine协调三个计算过程。

203.57 ExperienceEngine与Repository

ExperienceEngine不应该直接操作MySQL。

正确结构：

ExperienceService
 ↓
ExperienceEngine
 ↓
ExperienceResult
 ↓
ExperienceRepository
 ↓
MySQL

Repository负责：

saveExperience()
savePattern()
saveRelation()
saveHistory()
saveUsage()
saveUpdate()

Engine只负责计算。

203.58 Experience数据库结构

可以建立：

experiences

保存经验主体：

id
type
status
condition
pattern
weight
verification_status
created_at
updated_at

经验条件：

experience_conditions

经验模式：

experience_patterns

经验关系：

experience_relations

经验调用：

experience_usages

经验更新：

experience_updates

经验证据：

experience_evidence

形成：

experiences
 ├── experience_conditions
 ├── experience_patterns
 ├── experience_relations
 ├── experience_usages
 ├── experience_updates
 └── experience_evidence

203.59 ExperienceEngine完整调用流程

完整经验调用：

Current Runtime
 ↓
Object
 ↓
State
 ↓
Condition
 ↓
Load Experiences
 ↓
Experience Matching
 ↓
Applicability Calculation
 ↓
Verification Check
 ↓
Applicable Experience
 ↓
Method / Capability / Risk / Decision

这里最重要的是：

ExperienceEngine只能提供经验依据，不能越权替代其他Engine。

203.60 ExperienceEngine完整更新流程

完整经验更新：

Execution
 ↓
Result
 ↓
FeedbackEngine
 ↓
Feedback
 ↓
History
 ↓
Memory
 ↓
ExperienceEngine
 ↓
Existing Experience Matching
 ↓
Pattern Comparison
 ↓
Update Candidate
 ↓
Verification
 ↓
Experience Update

形成：

$History→Memory→Experience→Use→Result→Feedback→ExperienceUpdateHistory \rightarrow Memory \rightarrow Experience \rightarrow Use \rightarrow Result \rightarrow Feedback \rightarrow ExperienceUpdate$

203.61 经验更新与验证

经验更新必须经过验证。

例如原经验：

C → M → R1

新的结果：

C → M → R2

不能直接：

R1 → R2

必须计算：

Condition是否相同？
Object是否相同？
State是否相同？
Method是否相同？
Environment是否变化？
Result是否真实？
Evidence是否有效？

只有这些条件得到确认后，才可以产生：

Modify
Weaken
Split
Conflict
Invalidate

203.62 经验更新最小原则

ExperienceEngine应该遵循：

最小经验更新原则。

即：

只修改被新事实证明发生变化的部分。

例如：

原经验：

Object A
Condition C
Method M
Result R

新的事实只证明：

Condition C发生变化

那么不能直接修改：

Method
Result
Object

只应形成：

Condition Update Candidate

这样可以避免一次异常导致整个经验结构被错误修改。

203.63 经验可靠性

Experience可靠性可以综合：

History数量
Result一致性
Condition稳定性
Verification状态
时间有效性
使用结果
冲突数量

可以表示：

$Reliability=f(H,R,C,V,T,U,K)Reliability= f(H,R,C,V,T,U,K)$

其中：

$HH$ ：History；
$RR$ ：Result consistency；
$CC$ ：Condition stability；
$VV$ ：Verification；
$TT$ ：Time validity；
$UU$ ：Usage results；
$KK$ ：Conflict information。

这里仍然属于离散计算，不需要机器学习。

203.64 经验与概率计算

如果系统需要概率统计，可以从经验历史中计算：

$P(R∣C)=N(R,C)N(C)P(R|C)= \frac{N(R,C)}{N(C)}$

其中：

$N(R,C)N(R,C)$ ：在Condition C下出现Result R的次数；
$N(C)N(C)$ ：Condition C出现的总次数。

例如：

Condition C出现100次
Result R成功出现90次

则：

$P(R∣C)=90100=0.9P(R|C)=\frac{90}{100}=0.9$

但这个概率来自实际历史统计。

它不是ExperienceEngine凭空生成的概率。

因此：

History
 ↓
Experience
 ↓
Statistics
 ↓
Probability

是可以成立的。

203.65 ExperienceEngine与统计计算

统计可以辅助ExperienceEngine，但：

$Statistics≠ExperienceStatistics\neq Experience$

统计回答：

出现了多少次。

经验回答：

在什么条件下，采用什么方式，过去产生了什么结果。

因此：

Frequency
Success Rate
Probability

都只是经验计算可能使用的证据。

203.66 ExperienceEngine与确定性

ExperienceEngine必须保持确定性。

对于相同：

History
Memory
Condition
Rule
Verification

应得到相同经验计算结果。

即：

$EE(X,R)=YEE(X,R)=Y$

而不是：

$EE(X,R)→Random(Y)EE(X,R)\rightarrow Random(Y)$

因此ExperienceEngine不需要：

LLM
Transformer
Embedding
Vector Search
Neural Network
Prompt Engineering
LLM API

203.67 ExperienceEngine可解释性

任何经验计算结果都应该可以追溯：

Experience
 ↓
History Evidence
 ↓
Condition
 ↓
Result
 ↓
Pattern
 ↓
Verification

例如系统产生：

Experience E1001

必须能够回答：

来自哪些History？
满足什么Condition？
产生过什么Result？
形成什么Pattern？
经过什么Verification？
什么时候形成？

这保证Experience不是黑箱。

203.68 ExperienceEngine异常流程

经验计算过程中可能出现：

History不足
Condition不明确
Result冲突
Evidence无效
Experience过期
Experience冲突

对应：

Unknown
Candidate
Conflicted
Rejected
Outdated

例如：

Condition Unknown

不能直接生成：

Verified Experience

而应该：

Experience Candidate

等待更多事实。

203.69 ExperienceEngine与ConflictEngine

当出现：

E1：
C → M → R1

E2：
C → M → R2

并且两者不能同时成立时：

ExperienceEngine
 ↓
Experience Conflict Candidate
 ↓
ConflictEngine
 ↓
Conflict Classification
 ↓
Conflict Resolution

ExperienceEngine负责发现经验冲突依据。

ConflictEngine负责冲突处理。

203.70 ExperienceEngine与DiagnosisEngine

经验也可以帮助DiagnosisEngine。

例如：

Current Failure
 ↓
Diagnosis Candidate

ExperienceEngine可以调用历史：

过去同类Failure
 ↓
Diagnosis Result
 ↓
Cause

形成：

DiagnosisEngine
 ↓
ExperienceEngine
 ↓
Historical Diagnosis Experience

但经验不能直接作为确定原因。

必须由DiagnosisEngine结合当前Evidence进行确认。

203.71 ExperienceEngine完整ICAI位置

到第203章，ICAI Engine体系可以进一步表示：

ObjectEngine
 ↓
StateEngine
 ↓
RelationEngine
 ↓
SceneEngine
 ↓
KnowledgeEngine
 ↓
CapabilityEngine
 ↓
MatchingEngine
 ↓
MethodEngine
 ↓
RiskEngine
 ↓
ConflictEngine
 ↓
DecisionEngine
 ↓
BehaviorEngine
 ↓
ActionEngine
 ↓
ExecutionEngine
 ↓
FeedbackEngine
 ↓
MemoryEngine
 ↓
ExperienceEngine
 ↓
LearningEngine

其中ExperienceEngine位于：

实际执行事实
        ↓
Feedback
        ↓
Memory
        ↓
Experience
        ↓
Learning

这一认知链中。

203.72 ExperienceEngine完整闭环

完整ICAI闭环可以进一步表示为：

Goal
 ↓
Capability
 ↓
Method
 ↓
Decision
 ↓
Behavior
 ↓
Action
 ↓
Execution
 ↓
Result
 ↓
FeedbackEngine
 ↓
Memory
 ↓
ExperienceEngine
 ↓
Experience Recall
 ↓
Decision

同时形成更新路径：

Experience
 ↓
Use
 ↓
Execution
 ↓
Result
 ↓
Feedback
 ↓
History
 ↓
Experience Update
 ↓
New Experience

因此ExperienceEngine同时具有：

过去 → 当前
当前 → 未来

两个方向。

203.73 ExperienceEngine的三个核心能力

最终可以把ExperienceEngine压缩为三个核心能力。

第一，经验计算

$ExperienceCalculation=History+Memory+Condition+Pattern+Result+VerificationExperienceCalculation= History+ Memory+ Condition+ Pattern+ Result+ Verification$

解决：

经验是如何形成的？

第二，经验调用

$ExperienceRecall=Experience+CurrentCondition+State+Object+VerificationExperienceRecall= Experience+ CurrentCondition+ State+ Object+ Verification$

解决：

当前情况能不能调用过去经验？

第三，经验更新

$ExperienceUpdate=OldExperience+NewEvidence+Comparison+VerificationExperienceUpdate= OldExperience+ NewEvidence+ Comparison+ Verification$

解决：

新事实是否需要改变过去经验？

203.74 ExperienceEngine统一公式

因此可以建立：

$EE=EC+ER+EUEE= EC+ ER+ EU$

其中：

$ECEC$ ：Experience Calculation；
$ERER$ ：Experience Recall；
$EUEU$ ：Experience Update。

进一步：

$EC=F(H,M,C,P,R,V)EC=F(H,M,C,P,R,V)$ $ER=F(E,C,S,O,T,V)ER=F(E,C,S,O,T,V)$ $EU=F(Et,Hf,F,R,V)EU=F(E_t,H_f,F,R,V)$

其中：

$EtE_t$ ：当前经验；
$HfH_f$ ：新的历史事实；
$FF$ ：新的Feedback；
$RR$ ：新的Result；
$VV$ ：Verification。

203.75 ExperienceEngine与ICAI学习闭环

经验最终进入学习体系：

Actual Execution
 ↓
Result
 ↓
Feedback
 ↓
History
 ↓
Memory
 ↓
ExperienceEngine
 ↓
Experience
 ↓
LearningEngine
 ↓
Knowledge Update
Capability Update
Method Update
 ↓
DecisionEngine
 ↓
New Execution

因此：

$Experience→Learning→Knowledge/Capability/Method→DecisionExperience \rightarrow Learning \rightarrow Knowledge/Capability/Method \rightarrow Decision$

构成ICAI的重要认知循环。

203.76 ExperienceEngine工程边界

ExperienceEngine负责：

经验计算
经验条件计算
经验模式计算
经验调用
经验匹配
经验适用性判断
经验更新计算
经验验证
经验冲突候选
经验结果输出

不负责：

实际Action执行
Behavior组织
最终Decision
直接修改Goal
直接修改Capability
直接修改Method
最终Diagnosis
最终Repair
直接执行Risk处理
直接执行Conflict解决
直接保存MySQL

因此Engine边界保持清晰：

ExperienceEngine = Calculation
ExperienceService = Orchestration
ExperienceRepository = Persistence

203.77 ExperienceEngine最终架构

最终形成：

                  ┌───────────────┐
                  │    History    │
                  └───────┬───────┘
                          ↓
                  ┌───────────────┐
                  │     Memory    │
                  └───────┬───────┘
                          ↓
              ┌───────────────────────┐
              │    ExperienceEngine   │
              └───────────┬───────────┘
                          │
             ┌────────────┼────────────┐
             ↓            ↓            ↓
       Experience     Experience   Experience
       Calculation      Recall       Update
             │            │            │
             └────────────┼────────────┘
                          ↓
                  Verified Experience
                          ↓
             ┌────────────┼────────────┐
             ↓            ↓            ↓
          Method       Decision        Risk
             │            │            │
             └────────────┼────────────┘
                          ↓
                       Execution
                          ↓
                        Result
                          ↓
                       Feedback
                          ↓
                       History
                          ↓
                 Experience Update

这构成完整经验循环。

203.78 本章总结

第203章建立了ICAI体系中的ExperienceEngine。

其核心定义为：

$ExperienceEngine=ExperienceCalculation+ExperienceRecall+ExperienceUpdateExperienceEngine= ExperienceCalculation+ ExperienceRecall+ ExperienceUpdate$

它解决三个核心问题。

第一，经验计算

从：

History
Memory
Condition
Result
Feedback
Verification

中计算：

Pattern
Experience Candidate
Verified Experience

即：

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

第二，经验调用

将：

Current Object
Current State
Current Condition
Current Runtime

与历史经验进行匹配，判断：

Applicable
PartiallyApplicable
NotApplicable
Unknown
Conflicted
Outdated
Blocked

然后将适用经验提供给：

MethodEngine
CapabilityEngine
RiskEngine
DecisionEngine
DiagnosisEngine

但不直接替代这些Engine进行最终决策。

第三，经验更新

新的：

Result
Feedback
History
Verification

进入ExperienceEngine之后，与已有经验进行比较，形成：

Create
Strengthen
Weaken
Modify
Split
Merge
Invalidate
Outdate
Conflict
Archive

最终形成：

$Experiencet→Use→Result→Feedback→History→Experiencet+1Experience_t \rightarrow Use \rightarrow Result \rightarrow Feedback \rightarrow History \rightarrow Experience_{t+1}$

因此，第203章建立的不是一个简单的“经验存储器”，而是一个真正参与ICAI认知循环的经验计算Engine。

最终结构为：

History
 ↓
Memory
 ↓
ExperienceEngine
 ├── Experience Calculation
 ├── Experience Recall
 └── Experience Update
 ↓
Verified Experience
 ↓
Method / Capability / Risk / Decision / Diagnosis
 ↓
Behavior
 ↓
Action
 ↓
Execution
 ↓
Result
 ↓
Feedback
 ↓
History

在工程实现上，ExperienceEngine仍然严格遵循ICAI的基本原则：

$ExperienceEngine=Object+State+Condition+Rule+History+Memory+DiscreteCalculation+VerificationExperienceEngine= Object + State + Condition + Rule + History + Memory + DiscreteCalculation + Verification$

它不需要LLM、Transformer、Embedding、Vector Search、Prompt Engineering、神经网络或LLM API。

Experience不是模型参数，而是由真实历史事实、条件、结果、关系、验证和重复模式形成的结构化认知经验。

第203章 ExperienceEngine

第203章 ExperienceEngine

203.1 ExperienceEngine定义

203.2 Experience基本概念

203.3 ExperienceEngine核心模型

203.4 ExperienceEngine与ExperienceService

203.5 ExperienceEngine输入

203.6 经验计算

203.7 历史不是经验

203.8 Memory不是经验

203.9 经验条件计算

203.10 经验模式

203.11 经验形成

203.12 单次结果与经验

203.13 经验计算的重复性

203.14 经验一致性

203.15 经验冲突

203.16 经验计算结果

203.17 经验调用

203.18 经验调用不是简单查询

203.19 当前条件匹配

203.20 经验调用状态

203.21 经验适用度

203.22 经验调用与DecisionEngine

203.23 经验调用与MethodEngine

203.24 经验调用与CapabilityEngine

203.25 经验调用与RiskEngine

203.26 经验调用与KnowledgeEngine

203.27 经验调用与MemoryEngine

203.28 经验更新

203.29 经验更新来源

203.30 经验更新类型

Create

Strengthen

Weaken

203.31 经验修改

203.32 经验拆分

203.33 经验合并

203.34 经验削弱

203.35 经验失效

203.36 经验验证

203.37 经验状态

203.38 经验使用记录

203.39 经验调用闭环

203.40 经验更新闭环

203.41 ExperienceEngine与LearningEngine

203.42 ExperienceEngine与MemoryEngine

203.43 ExperienceEngine与FeedbackEngine

203.44 ExperienceEngine与DecisionEngine

203.45 ExperienceEngine与RiskEngine

203.46 ExperienceEngine与DiagnosisEngine

203.47 ExperienceEngine与RepairEngine

203.48 ExperienceEngine经验类型

MethodExperience

DecisionExperience

RepairExperience

StateTransitionExperience

203.49 ExperienceEngine计算模型

203.50 ExperienceEngine统一结果

203.51 经验权重

203.52 时间衰减

203.53 经验权重与概率区别

203.54 ExperienceEngine PHP OOP结构

203.55 ExperienceRecallEngine结构

203.56 ExperienceUpdateEngine结构

203.57 ExperienceEngine与Repository

203.58 Experience数据库结构

203.59 ExperienceEngine完整调用流程

203.60 ExperienceEngine完整更新流程

203.61 经验更新与验证

203.62 经验更新最小原则

203.63 经验可靠性

203.64 经验与概率计算

203.65 ExperienceEngine与统计计算

203.66 ExperienceEngine与确定性

203.67 ExperienceEngine可解释性

203.68 ExperienceEngine异常流程

203.69 ExperienceEngine与ConflictEngine

203.70 ExperienceEngine与DiagnosisEngine

203.71 ExperienceEngine完整ICAI位置

第203章　ExperienceEngine

第203章　ExperienceEngine