第130章　经验计算

130.1 提出背景

第129章建立了经验形成机制：

$Behavior→Result→Feedback→Memory→ExperienceBehavior\rightarrow Result\rightarrow Feedback\rightarrow Memory\rightarrow Experience$

经验形成以后，并不能仅仅停留在经验库中。如果经验不能被比较、组合、调用、验证和更新，那么经验就只能成为历史数据，而不能真正成为认知系统的一部分。

因此，经验系统必须进一步回答五个问题：

不同经验之间有什么区别？

多个经验能否组合？

当前情况应该调用哪条经验？

调用的经验是否适合当前情况？

新的结果发生以后，原有经验如何变化？

由此形成经验计算的基本过程：

$Experience→Compare→Combine→Recall→Verify→UpdateExperience \rightarrow Compare \rightarrow Combine \rightarrow Recall \rightarrow Verify \rightarrow Update$

经验计算的目标不是产生自然语言描述，而是将经验转换成可以由程序直接处理的结构化计算对象。

130.2 经验计算定义

**经验计算（Experience Computation）**是系统针对经验对象进行比较、组合、匹配、调用、验证和更新，并计算经验适用程度、经验价值和经验状态的过程。

可以定义：

$EC=Compute(E,Q,C,R)EC=Compute(E,Q,C,R)$

其中：

$EE$ ：经验集合；
$QQ$ ：当前认知条件；
$CC$ ：计算条件；
$RR$ ：计算结果。

经验计算的核心不是简单查询，而是：

$CurrentCondition→ExperienceMatching→ExperienceCalculation→ExperienceDecisionCurrentCondition \rightarrow ExperienceMatching \rightarrow ExperienceCalculation \rightarrow ExperienceDecision$

因此，经验计算属于认知计算的一部分。

130.3 经验对象

经验计算首先需要一个标准化的经验对象。

定义：

$E={O,C,S,B,R,F,T,V,W,St}E=\{O,C,S,B,R,F,T,V,W,St\}$

其中：

$OO$ ：对象；
$CC$ ：条件；
$SS$ ：状态；
$BB$ ：行为；
$RR$ ：结果；
$FF$ ：反馈；
$TT$ ：时间；
$VV$ ：经验价值；
$WW$ ：经验权重；
$StSt$ ：经验状态。

经验对象可以看成：

$Condition+State→Behavior→Result→FeedbackCondition+State \rightarrow Behavior \rightarrow Result \rightarrow Feedback$

以及：

$History→ValueHistory\rightarrow Value$

两个部分共同构成。

130.4 经验比较

**经验比较（Experience Comparison）**是对两个或多个经验对象的对象、条件、状态、行为、结果、反馈、时间和价值进行结构化比较的过程。

定义：

$ECmp(E1,E2)=Compare(E1,E2)ECmp(E_1,E_2)=Compare(E_1,E_2)$

经验比较不是简单判断两个对象是否相等，而是判断两个经验在多个维度上的相似、差异和关系。

130.4.1 对象比较

首先比较经验针对的对象：

$O1=O2O_1=O_2$

或者：

$Type(O1)=Type(O2)Type(O_1)=Type(O_2)$

也可以通过属性和关系判断对象是否具有可比性。

对象比较结果可以分为：

EXACT；
TYPE；
ATTRIBUTE；
RELATION；
NONE。

130.4.2 条件比较

条件比较：

$C1≈C2C_1\approx C_2$

如果两个经验具有相同条件，则具有较高的直接可比性。

如果条件不同，则需要判断差异是否会影响经验结果。

因此：

$ConditionMatch(E1,E2)ConditionMatch(E_1,E_2)$

可以作为经验比较的重要指标。

130.4.3 状态比较

状态比较用于判断两个经验是否发生在相同或相似状态下：

$S1=S2S_1=S_2$

或者：

$Match(S1,S2)>TsMatch(S_1,S_2)>T_s$

状态不同可能意味着经验不能直接合并。

130.4.4 行为比较

比较两个经验采用的行为：

$B1=B2B_1=B_2$

或者：

$Method(B1)=Method(B2)Method(B_1)=Method(B_2)$

也可以判断两个行为是否属于同一种行为类型。

130.4.5 结果比较

比较：

$R1≈R2R_1\approx R_2$

如果同一条件、相似行为产生相似结果，则经验关系更加稳定。

如果：

$R1≠R2R_1\neq R_2$

则需要进一步检查条件、状态和环境是否存在差异。

130.4.6 反馈比较

反馈比较：

$F1≈F2F_1\approx F_2$

如果反馈方向一致，则说明两个历史事件具有相似的评价结果。

130.4.7 综合经验比较

可以定义经验比较分数：

$Scorecmp=woO+wcC+wsS+wbB+wrR+wfF+wtTScore_{cmp} = w_oO+w_cC+w_sS+w_bB+w_rR+w_fF+w_tT$

其中：

$OO$ ：对象匹配度；
$CC$ ：条件匹配度；
$SS$ ：状态匹配度；
$BB$ ：行为匹配度；
$RR$ ：结果匹配度；
$FF$ ：反馈匹配度；
$TT$ ：时间关系匹配度；
$ww$ ：对应维度权重。

满足：

$∑wi=1\sum w_i=1$

这样就可以将复杂经验关系转换为数值。

130.5 经验差异

经验比较不仅要计算相似性，还要计算差异。

定义：

$D(E1,E2)=1−Scorecmp(E1,E2)D(E_1,E_2)=1-Score_{cmp}(E_1,E_2)$

差异较小时：

$D→0D\rightarrow0$

说明两个经验较为接近。

差异较大时：

$D→1D\rightarrow1$

说明两个经验可能属于不同条件、不同方法或不同结果类型。

经验差异可以用于：

经验分类；
经验分化；
经验合并判断；
冲突检测；
经验更新。

130.6 经验组合

**经验组合（Experience Combination）**是将多个具有兼容关系的经验组织成更完整的经验结构。

定义：

$Ec=Combine(E1,E2,…,En)E_c=Combine(E_1,E_2,\ldots,E_n)$

经验组合不是简单把多条经验放在一起，而是建立它们之间的逻辑关系。

130.6.1 顺序组合

如果：

$E1:S1→B1→S2E_1:S_1\rightarrow B_1\rightarrow S_2$

而：

$E2:S2→B2→S3E_2:S_2\rightarrow B_2\rightarrow S_3$

则可以组合：

$E1→E2E_1\rightarrow E_2$

形成：

$S1→B1S2→B2S3S_1 \xrightarrow{B_1} S_2 \xrightarrow{B_2} S_3$

这是一种过程经验。

130.6.2 条件组合

如果：

$C1→B1→R1C_1\rightarrow B_1\rightarrow R_1$

同时：

$C2→B2→R2C_2\rightarrow B_2\rightarrow R_2$

当：

$C=C1∧C2C=C_1\land C_2$

成立时，可以形成组合经验：

$C1∧C2→B1+B2→RC_1\land C_2 \rightarrow B_1+B_2 \rightarrow R$

130.6.3 并行组合

多个经验可能针对同一个条件：

$C→E1C\rightarrow E_1$ $C→E2C\rightarrow E_2$

如果两条经验互不冲突，可以形成并行经验集合：

$C→{E1,E2}C\rightarrow\{E_1,E_2\}$

此时系统可以进一步比较两条经验的价值。

130.6.4 替代组合

如果：

$C→B1→R1C\rightarrow B_1\rightarrow R_1$

以及：

$C→B2→R2C\rightarrow B_2\rightarrow R_2$

则可以形成替代经验：

$C→{B1,B2}C\rightarrow\{B_1,B_2\}$

然后依据经验价值进行选择。

130.7 经验组合条件

经验不能无限组合。

经验组合至少需要检查：

$CC={Object,Condition,State,Relation,Conflict}CC=\{Object,Condition,State,Relation,Conflict\}$

包括：

对象是否兼容；
条件是否兼容；
状态是否连续；
关系是否明确；
是否存在行为冲突；
是否存在结果冲突。

因此：

$Compatible(E1,E2)=ObjectMatch∧ConditionCompatible∧StateCompatible∧RelationValid∧ConflictFreeCompatible(E_1,E_2)= ObjectMatch \land ConditionCompatible \land StateCompatible \land RelationValid \land ConflictFree$

只有满足组合条件，经验才可以形成新的组合结构。

130.8 经验调用

**经验调用（Experience Invocation）**是系统在当前认知条件下，从经验库中寻找并提取适用经验的过程。

定义：

$EI=Invoke(Q,E)EI=Invoke(Q,E)$

其中：

$QQ$ ：当前情况；
$EE$ ：经验集合；
$EIEI$ ：调用结果。

经验调用过程：

当前对象 → 当前状态 → 当前条件 → 查询经验 → 条件匹配 → 经验排序 → 选择经验 → 调用经验

130.8.1 当前条件

当前条件可以表示为：

$Q={O,S,C,G,T,R}Q=\{O,S,C,G,T,R\}$

其中：

$OO$ ：当前对象；
$SS$ ：当前状态；
$CC$ ：当前条件；
$GG$ ：当前目标；
$TT$ ：当前时间；
$RR$ ：当前关系。

130.8.2 候选经验

系统首先获取可能相关的经验：

$E1,E2,…,EnE_1,E_2,\ldots,E_n$

这些经验只是候选对象，并不意味着全部适用。

130.8.3 经验匹配

计算：

$Match(Ei,Q)Match(E_i,Q)$

匹配内容包括：

$Object→State→Condition→Relation→TimeObject \rightarrow State \rightarrow Condition \rightarrow Relation \rightarrow Time$

130.8.4 经验排序

对候选经验计算：

$Score(Ei,Q)Score(E_i,Q)$

然后：

$E∗=arg⁡max⁡iScore(Ei,Q)E^*=\arg\max_i Score(E_i,Q)$

获得当前最相关经验。

但最高分经验也必须经过验证后才能真正用于行为决策。

130.9 经验调用与决策的区别

经验调用不是决策。

经验调用得到：

$RelevantExperienceRelevantExperience$

决策则进一步计算：

$Decision=f(CurrentState,Goal,Risk,Experience,Rule)Decision=f(CurrentState,Goal,Risk,Experience,Rule)$

因此：

$ExperienceInvocation≠DecisionExperienceInvocation\neq Decision$

经验只提供历史依据。

最终决策仍然需要考虑：

当前状态；
当前目标；
当前风险；
当前资源；
当前规则；
当前能力；
当前经验。

因此：

$CurrentCondition+Experience→DecisionCurrentCondition + Experience \rightarrow Decision$

130.10 经验验证

**经验验证（Experience Verification）**是判断某条经验是否真实、稳定、适用以及是否可以继续使用的过程。

定义：

$EV=Verify(E,Q,R)EV=Verify(E,Q,R)$

其中：

$EE$ ：经验；
$QQ$ ：当前条件；
$RR$ ：新的结果。

经验验证至少包括两个方向：

历史验证

和

当前验证。

130.10.1 历史验证

历史验证检查经验是否得到足够的历史支持。

例如：

$E=(C,B,R)E=(C,B,R)$

检查：

$Count(C,B,R)Count(C,B,R)$

以及：

$Stability(E)Stability(E)$

如果多个历史事件持续支持该经验，则经验可信程度提高。

130.10.2 当前验证

经验被调用后，需要检查实际结果：

$C+B→RactualC+B\rightarrow R_{actual}$

然后与经验预期：

$RexperienceR_{experience}$

进行比较。

定义：

$Vr=Match(Ractual,Rexperience)V_r=Match(R_{actual},R_{experience})$

如果：

$Vr≥TvV_r\geq T_v$

则当前验证成功。

130.10.3 验证结果

经验验证可以产生：

VERIFIED；
PARTIAL；
UNCERTAIN；
FAILED。

其中：

VERIFIED：经验得到当前结果支持。

PARTIAL：部分条件或结果得到支持。

UNCERTAIN：当前数据不足。

FAILED：当前结果明显违反经验预期。

130.11 经验更新

**经验更新（Experience Update）**是新事件、新结果和新反馈出现后，对已有经验的价值、条件、结果、权重、稳定性和状态进行重新计算的过程。

定义：

$EU=Update(E,Mnew)EU=Update(E,M_{new})$

其中：

$EE$ ：旧经验；
$MnewM_{new}$ ：新的相关记忆；
$EUEU$ ：更新后的经验。

基本过程：

$Experienceold+NewMemory→Comparison→Recalculation→ExperiencenewExperience_{old} + NewMemory \rightarrow Comparison \rightarrow Recalculation \rightarrow Experience_{new}$

130.12 经验权重更新

经验权重可以随着历史结果变化。

假设：

$WoldW_{old}$

为旧权重，新的验证结果为：

$VnewV_{new}$

则可以采用简单更新：

$Wnew=(1−α)Wold+αVnewW_{new} = (1-\alpha)W_{old} + \alpha V_{new}$

其中：

$WoldW_{old}$ ：旧经验权重；
$WnewW_{new}$ ：新经验权重；
$VnewV_{new}$ ：新验证结果；
$α\alpha$ ：更新系数。

如果新结果支持经验：

$Vnew↑⇒Wnew↑V_{new}\uparrow \Rightarrow W_{new}\uparrow$

如果新结果否定经验：

$Vnew↓⇒Wnew↓V_{new}\downarrow \Rightarrow W_{new}\downarrow$

130.13 经验稳定性更新

经验稳定性可以根据历史一致结果重新计算：

$Stability(E)=NconsistentNtotalStability(E)= \frac{N_{consistent}} {N_{total}}$

每出现一次新的相关结果，就更新：

$NtotalN_{total}$

如果结果符合经验：

$Nconsistent↑N_{consistent}\uparrow$

如果结果不符合经验：

$NconsistentN_{consistent}$

不增加。

因此，经验稳定性会随着实际运行持续变化。

130.14 经验条件更新

如果新事件表明原经验只在某些条件下成立，则必须缩小经验适用范围。

例如原经验：

$B→RB\rightarrow R$

后来发现只有：

$C1C_1$

条件下成立。

则更新为：

$C1+B→RC_1+B\rightarrow R$

这种更新称为经验条件收缩。

相反，如果多个不同条件下都得到相同结果：

$C1+B→RC_1+B\rightarrow R$ $C2+B→RC_2+B\rightarrow R$ $C3+B→RC_3+B\rightarrow R$

则可以在验证充分后扩大经验适用范围。

因此经验更新包括：

条件收缩 → 条件保持 → 条件扩展

130.15 经验结果更新

如果新结果与历史结果一致：

$Rnew≈RoldR_{new}\approx R_{old}$

则经验稳定性提高。

如果：

$Rnew≠RoldR_{new}\neq R_{old}$

则需要重新计算经验。

可能产生：

$Experience→DowngradeExperience \rightarrow Downgrade$

或者：

$Experience→SplitExperience \rightarrow Split$

甚至：

$Experience→InvalidExperience \rightarrow Invalid$

因此，经验不是永久固定的。

130.16 经验分裂

当一条经验内部出现明显条件差异时，可以进行经验分裂。

例如原经验：

$E=(C,B,R)E=(C,B,R)$

后来发现：

$C1+B→R1C_1+B\rightarrow R_1$ $C2+B→R2C_2+B\rightarrow R_2$

则原经验可能分裂为：

$E1=(C1,B,R1)E_1=(C_1,B,R_1)$ $E2=(C2,B,R2)E_2=(C_2,B,R_2)$

经验分裂可以防止一条过于宽泛的经验产生错误调用。

130.17 经验合并

如果两条经验长期表现一致：

$E1=(C1,B,R)E_1=(C_1,B,R)$ $E2=(C2,B,R)E_2=(C_2,B,R)$

并且：

$Compatible(C1,C2)=TRUECompatible(C_1,C_2)=TRUE$

则可以形成：

$Enew=Combine(E1,E2)E_{new}=Combine(E_1,E_2)$

经验合并可以减少重复经验，提高经验库结构化程度。

130.18 经验失效

经验可能失效。

经验失效的原因包括：

对象发生变化；
条件发生变化；
环境发生变化；
方法发生变化；
结果长期不一致；
反馈持续否定；
时间过长；
被新的经验取代。

因此：

$ExperienceValidity=f(Condition,Result,Feedback,Time)ExperienceValidity=f(Condition,Result,Feedback,Time)$

如果：

$Validity(E)<TvalidValidity(E)<T_{valid}$

则：

$E→InactiveE\rightarrow Inactive$

经验失效并不等于历史记忆删除。

必须保持：

$Memory 保留Memory\;保留$

而：

$Experience 失效Experience\;失效$

因为历史事实和当前经验属于不同层级。

130.19 经验计算统一模型

经验比较、组合、调用、验证和更新可以统一为：

$Eold→Compare→Combine→Invoke→Verify→Update→EnewE_{old} \rightarrow Compare \rightarrow Combine \rightarrow Invoke \rightarrow Verify \rightarrow Update \rightarrow E_{new}$

更完整地表示：

$CurrentCondition→ExperienceQuery→ExperienceCompare→ExperienceRank→ExperienceInvoke→ExperienceVerify→ExperienceUpdateCurrentCondition \rightarrow ExperienceQuery \rightarrow ExperienceCompare \rightarrow ExperienceRank \rightarrow ExperienceInvoke \rightarrow ExperienceVerify \rightarrow ExperienceUpdate$

由此形成经验运行闭环。

130.20 经验计算工程对象

PHP OOP可以建立：

class ExperienceCalculator
{
    protected $experienceRepository;
    protected $experienceMatcher;
    protected $experienceValidator;
    protected $experienceUpdater;

    public function compare($experienceA, $experienceB)
    {
        // 经验比较
    }

    public function combine($experiences)
    {
        // 经验组合
    }

    public function invoke($condition)
    {
        // 经验调用
    }

    public function verify($experience, $result)
    {
        // 经验验证
    }

    public function update($experience, $memory)
    {
        // 经验更新
    }
}

可以进一步拆分为：

ExperienceComparator
ExperienceCombiner
ExperienceInvoker
ExperienceValidator
ExperienceUpdater
ExperienceRanker
ExperienceRepository

使每个模块具有明确职责。

130.21 经验计算模块

WSaiOS经验计算系统可以形成以下结构：

ExperienceRepository

负责保存经验。

ExperienceComparator

负责经验之间的多维比较。

ExperienceCombiner

负责兼容经验组合。

ExperienceMatcher

负责当前条件与历史经验匹配。

ExperienceRanker

负责经验排序。

ExperienceInvoker

负责调用适用经验。

ExperienceValidator

负责历史及当前验证。

ExperienceUpdater

负责经验更新。

ExperienceStateManager

负责管理经验状态。

完整结构：

$Repository→Comparator→Matcher→Ranker→Invoker→Validator→UpdaterRepository \rightarrow Comparator \rightarrow Matcher \rightarrow Ranker \rightarrow Invoker \rightarrow Validator \rightarrow Updater$

130.22 经验计算数据库模型

经验表可以继续扩展：

cognitive_experiences
- experience_id
- object_type
- object_value
- condition
- state
- behavior
- result
- feedback
- value
- weight
- stability
- usage_count
- success_count
- failure_count
- status
- last_verified_at
- created_at
- updated_at

经验使用记录：

cognitive_experience_usage
- usage_id
- experience_id
- object_type
- condition
- matched_score
- expected_result
- actual_result
- verification_result
- created_at

经验更新记录：

cognitive_experience_updates
- update_id
- experience_id
- old_value
- new_value
- old_weight
- new_weight
- reason
- source_memory_id
- created_at

这样可以形成：

$Experience→Usage→Verification→UpdateExperience \rightarrow Usage \rightarrow Verification \rightarrow Update$

完整的历史轨迹。

130.23 经验计算状态机

经验计算可以定义为：

$Idle→Querying→Comparing→Ranking→Invoking→Verifying→Updating→CompletedIdle \rightarrow Querying \rightarrow Comparing \rightarrow Ranking \rightarrow Invoking \rightarrow Verifying \rightarrow Updating \rightarrow Completed$

其中：

$Comparing→NoMatchComparing\rightarrow NoMatch$

表示没有找到匹配经验。

$Invoking→VerificationFailedInvoking\rightarrow VerificationFailed$

表示经验调用后的结果不符合预期。

$VerificationFailed→UpdatingVerificationFailed\rightarrow Updating$

表示需要根据新的结果重新计算经验。

如果经验失效：

$Updating→InactiveUpdating\rightarrow Inactive$

如果经验得到强化：

$Updating→ActiveUpdating\rightarrow Active$

130.24 经验计算与学习

经验计算是经验系统内部的运行机制，而学习是在经验基础上改变系统未来能力的更高层机制。

因此：

$Experience→ExperienceCalculation→ExperienceUpdate→LearningExperience \rightarrow ExperienceCalculation \rightarrow ExperienceUpdate \rightarrow Learning$

经验计算本身不等于学习。

例如：

经验权重从：

$0.7→0.80.7\rightarrow0.8$

属于经验更新。

而根据长期经验改变某个行为规则：

$Ruleold→RulenewRule_{old}\rightarrow Rule_{new}$

则属于学习过程。

因此必须保持：

$ExperienceCalculation≠LearningExperienceCalculation\neq Learning$

130.25 经验计算与记忆的关系

经验计算始终建立在记忆基础上。

新事件产生：

$Behavior→Result→FeedbackBehavior\rightarrow Result\rightarrow Feedback$

然后：

$→Memory\rightarrow Memory$

新的记忆进入经验计算：

$Memorynew→ExperienceVerification→ExperienceUpdateMemory_{new} \rightarrow ExperienceVerification \rightarrow ExperienceUpdate$

因此完整关系为：

$Event→Memory→Experience→ExperienceCalculation→CognitionEvent \rightarrow Memory \rightarrow Experience \rightarrow ExperienceCalculation \rightarrow Cognition$

这保证经验始终能够追溯到实际历史事件。

130.26 经验计算闭环

经验计算的最终闭环为：

$Behavior→Result→Feedback→Memory→Experience→Compare→Invoke→Verify→Update→Cognition→Decision→BehaviorBehavior \rightarrow Result \rightarrow Feedback \rightarrow Memory \rightarrow Experience \rightarrow Compare \rightarrow Invoke \rightarrow Verify \rightarrow Update \rightarrow Cognition \rightarrow Decision \rightarrow Behavior$

其中新的行为又产生新的结果：

$Behaviornew→Resultnew→Feedbacknew→MemorynewBehavior_{new} \rightarrow Result_{new} \rightarrow Feedback_{new} \rightarrow Memory_{new}$

再进入：

$Experienceold+Memorynew→ExperiencenewExperience_{old}+Memory_{new} \rightarrow Experience_{new}$

于是形成持续运行的经验循环。

130.27 本章总结

第130章建立了经验从“形成”进入“计算”的完整机制。

经验计算主要包括五个核心过程：

经验比较：

$E1+E2→CompareE_1+E_2\rightarrow Compare$

判断经验之间的对象、条件、状态、行为、结果和反馈关系。

经验组合：

$E1+E2+⋯+En→CombinedExperienceE_1+E_2+\cdots+E_n\rightarrow CombinedExperience$

建立顺序、条件、并行和替代等经验结构。

经验调用：

$CurrentCondition→ExperienceMatching→ExperienceInvocationCurrentCondition\rightarrow ExperienceMatching\rightarrow ExperienceInvocation$

从经验库中找到当前最相关的经验。

经验验证：

$Experience+ActualResult→VerificationExperience+ActualResult\rightarrow Verification$

判断经验是否继续成立。

经验更新：

$OldExperience+NewMemory→NewExperienceOldExperience+NewMemory\rightarrow NewExperience$

根据新的结果和反馈调整经验的价值、权重、稳定性、条件和状态。

最终形成：

$Experience→Compare→Combine→Invoke→Verify→UpdateExperience \rightarrow Compare \rightarrow Combine \rightarrow Invoke \rightarrow Verify \rightarrow Update$

并进一步形成：

$Memory→Experience→ExperienceCalculation→Cognition→Decision→Behavior→Result→Feedback→MemoryMemory \rightarrow Experience \rightarrow ExperienceCalculation \rightarrow Cognition \rightarrow Decision \rightarrow Behavior \rightarrow Result \rightarrow Feedback \rightarrow Memory$

因此，经验不再是静态历史数据，而成为一种可以计算、可以调用、可以验证、可以组合、可以更新的动态认知结构。

经验计算使系统能够把过去形成的经验真正带入当前运行过程，并通过新的行为结果不断修正已有经验，从而建立：

历史 → 经验 → 当前认知 → 行为 → 新历史

的连续认知循环。

这为后续的经验评价、经验选择、经验学习以及经验驱动的行为决策建立了计算基础。

第130章 经验计算

第130章 经验计算

130.1 提出背景

130.2 经验计算定义

130.3 经验对象

130.4 经验比较

130.4.1 对象比较

130.4.2 条件比较

130.4.3 状态比较

130.4.4 行为比较

130.4.5 结果比较

130.4.6 反馈比较

130.4.7 综合经验比较

130.5 经验差异

130.6 经验组合

130.6.1 顺序组合

130.6.2 条件组合

130.6.3 并行组合

130.6.4 替代组合

130.7 经验组合条件

130.8 经验调用

130.8.1 当前条件

130.8.2 候选经验

130.8.3 经验匹配

130.8.4 经验排序

130.9 经验调用与决策的区别

130.10 经验验证

130.10.1 历史验证

130.10.2 当前验证

130.10.3 验证结果

130.11 经验更新

130.12 经验权重更新

130.13 经验稳定性更新

130.14 经验条件更新

130.15 经验结果更新

130.16 经验分裂

130.17 经验合并

130.18 经验失效

130.19 经验计算统一模型

130.20 经验计算工程对象

130.21 经验计算模块

130.22 经验计算数据库模型

130.23 经验计算状态机

130.24 经验计算与学习

130.25 经验计算与记忆的关系

130.26 经验计算闭环

130.27 本章总结