第五章 学习更新
5.1 学习更新的定义
前一章已经说明,反馈可以转化为学习材料,并通过对象、属性、值、关系、状态、条件和规则的识别,形成新的结构化知识。
但是,学习并不在“形成知识”这一时刻结束。
如果新的知识只是被保存,而原有的知识结构、能力结构、方法结构以及结构之间的关系没有发生变化,那么系统下一次面对相同或相似问题时,仍然可能按照原来的方式进行认知、决策和执行。
因此,学习必须进一步进入已有结构,对已有结构进行增加、修改、修正、替换、扩展、关联和重组。
由此,WSaiOS-SI将学习更新定义为:
学习更新,是将经过学习形成并验证的新知识、新经验、新规则、新能力和新方法,与已有结构进行匹配,在保持有效结构连续性的基础上,对知识结构、能力结构、方法结构以及结构之间的关系进行增加、修改、修正、替换、扩展和重组,使系统获得新的问题解决能力的过程。
其基本过程为:
学习材料→结构识别→结构匹配→差异分析→结构更新→验证→新结构学习材料 \rightarrow 结构识别 \rightarrow 结构匹配 \rightarrow 差异分析 \rightarrow 结构更新 \rightarrow 验证 \rightarrow 新结构
因此:
Learning→Update→Validation→NewStructure\boxed{ Learning \rightarrow Update \rightarrow Validation \rightarrow NewStructure }
学习更新不是单纯的数据写入,而是结构的变化。
5.2 学习更新与知识保存的区别
知识保存只解决:
已经获得的信息保存在哪里。
学习更新解决的是:
新获得的信息进入现有知识结构以后,现有结构应该发生什么变化。
例如,系统原来具有:
Object=ElectricToothbrushObject=ElectricToothbrush
并且具有:
Function=ChargingFunction=Charging
后来通过新的资料发现某一产品增加了新的功能:
Function=PressureSensorFunction=PressureSensor
那么简单保存新的文本,只能得到两个信息:
ChargingCharging
和:
PressureSensorPressureSensor
但学习更新要求判断:
- 这是新的对象吗?
- 是已有对象的新属性吗?
- 是已有属性的新值吗?
- 是已有关系吗?
- 是新的关系吗?
- 是某个条件下成立的关系吗?
- 是新的方法吗?
- 是否会影响已有能力?
- 是否会影响已有决策方法?
因此:
NewInformation≠KnowledgeUpdateNewInformation\neq KnowledgeUpdate
必须经过:
NewInformation→KnowledgeMatching→StructureComparison→UpdateDecision→KnowledgeUpdateNewInformation \rightarrow KnowledgeMatching \rightarrow StructureComparison \rightarrow UpdateDecision \rightarrow KnowledgeUpdate
学习更新的核心不是“增加”,而是判断:
新的结构与旧的结构是什么关系。
5.3 学习更新的基本结构
学习更新的对象不是单一数据,而是结构体系。
一个完整的学习更新对象可以表示为:
LearningUpdate={Source,NewInformation,ExistingStructure,Matching,Difference,UpdateType,Validation,Result}LearningUpdate= \{ Source, NewInformation, ExistingStructure, Matching, Difference, UpdateType, Validation, Result \}
其中:
- Source:学习来源;
- NewInformation:新获得的信息;
- ExistingStructure:已有结构;
- Matching:新旧结构匹配结果;
- Difference:新旧结构差异;
- UpdateType:更新类型;
- Validation:更新后的验证;
- Result:最终结构更新结果。
完整过程:
NewInformation→ExistingKnowledge→Matching→Difference→UpdateType→Update→ValidationNewInformation \rightarrow ExistingKnowledge \rightarrow Matching \rightarrow Difference \rightarrow UpdateType \rightarrow Update \rightarrow Validation
这意味着学习更新本身也是一种结构处理过程。
5.4 学习更新的基本类型
新的学习结果进入系统以后,并不一定意味着建立一个全新的结构。
根据新旧结构之间的关系,学习更新至少包括以下几种基本形式。
5.4.1 新增
已有结构中不存在相关结构,而新学习结果提供了新的有效结构。
例如:
Object=AObject=A
原来没有:
AttributeBAttribute_B
学习以后得到:
A.AttributeB=ValueA.Attribute_B=Value
于是:
Structureold→Structureold+AttributeBStructure_{old} \rightarrow Structure_{old}+Attribute_B
这是结构新增。
5.4.2 扩展
已有结构存在,但新的学习结果增加了其内容。
例如:
Function={Charging}Function=\{Charging\}
学习以后:
Function={Charging,PressureSensor}Function=\{Charging,PressureSensor\}
原有结构没有被否定,而是得到扩展。
因此:
Knowledgeold→KnowledgeextendedKnowledge_{old} \rightarrow Knowledge_{extended}
5.4.3 修正
新信息经过验证后发现已有知识存在错误。
例如原有知识:
Price=39.99Price=39.99
新的有效信息为:
Price=29.99Price=29.99
如果确认新的值正确,则:
39.99→29.9939.99\rightarrow29.99
这不是简单增加两个价格,而是对已有知识进行修正。
5.4.4 替换
某些结构不能与新结构同时成立,经过验证后需要使用新结构替代旧结构。
例如某个对象原来的状态为:
State=AvailableState=Available
新的执行结果确认:
State=UnavailableState=Unavailable
则当前状态更新为:
Available→UnavailableAvailable\rightarrow Unavailable
这里必须注意:
替换并不意味着历史数据被彻底消失。
当前结构可以更新,而历史状态仍然可以作为时间上的历史结构保存:
Statet0=AvailableState_{t0}=Available Statet1=UnavailableState_{t1}=Unavailable
因此:
CurrentStructure≠HistoricalStructureCurrentStructure\neq HistoricalStructure
5.4.5 关联
新的学习结果没有改变对象本身,却发现了两个原来没有建立的结构关系。
例如:
ObjectA→Relation→ObjectBObject_A\rightarrow Relation\rightarrow Object_B
新的学习结果发现:
ObjectA→uses→ObjectBObject_A \rightarrow uses \rightarrow Object_B
于是增加新的关系结构。
5.4.6 重组
多个已有结构在新的学习结果作用下,需要形成新的组合关系。
例如:
K1+K2K_1+K_2
原来分别存在,但新的问题解决过程发现:
K1→K2K_1\rightarrow K_2
可以形成新的解决路径。
于是:
K1+K2→CompositeKnowledgeK_1+K_2 \rightarrow CompositeKnowledge
重组可能进一步产生:
CapabilityCapability
或者:
MethodMethod
因此学习不仅能够增加知识,还可以改变知识之间的组织方式。
5.5 知识结构更新
知识结构是学习更新最直接的对象。
知识结构包括:
KnowledgeStructure={Class,Object,Attribute,Value,State,Relation,Condition,Rule,Method}KnowledgeStructure= \{ Class, Object, Attribute, Value, State, Relation, Condition, Rule, Method \}
学习更新可以作用于其中任何一个层次。
例如:
Object→Attribute→ValueObject \rightarrow Attribute \rightarrow Value
如果新的信息增加一个属性:
Object→NewAttributeObject \rightarrow NewAttribute
如果新的信息改变属性值:
Attribute→Valueold→ValuenewAttribute \rightarrow Value_{old} \rightarrow Value_{new}
如果新的信息发现对象之间存在关系:
ObjectA→Relation→ObjectBObject_A \rightarrow Relation \rightarrow Object_B
如果新的信息发现关系只在特定条件下成立:
Condition→RelationCondition \rightarrow Relation
如果新的执行结果形成新的规则:
Condition+Result→RuleCondition+Result \rightarrow Rule
因此知识更新不是简单的“增加知识条目”,而是对知识结构内部节点和关系进行更新。
5.6 知识更新中的新旧结构匹配
学习更新必须首先解决新旧知识之间的对应关系。
设新学习结构为:
KnewK_{new}
已有知识结构为:
KoldK_{old}
则:
Knew↔KoldK_{new}\leftrightarrow K_{old}
可能产生:
Match(Knew,Kold)={SameExtendCorrectReplaceConflictNewMatch(K_{new},K_{old})= \begin{cases} Same\\ Extend\\ Correct\\ Replace\\ Conflict\\ New \end{cases}
其中:
Same
新旧知识表示同一结构:
Knew=KoldK_{new}=K_{old}
不需要产生新的知识结构。
Extend
新知识是已有知识的扩展:
Knew⊃KoldK_{new}\supset K_{old}
保留旧结构并增加新的结构。
Correct
新知识证明旧知识存在错误:
Knew≠KoldK_{new}\neq K_{old}
并且新知识经过验证后应修正旧结构。
Replace
当前状态或当前有效结构发生变化:
Kold→KnewK_{old}\rightarrow K_{new}
Conflict
两个知识结构存在冲突,但当前无法立即确定哪一个正确:
Knew↔KoldK_{new}\leftrightarrow K_{old}
此时不能直接覆盖原有知识,而应进入冲突分析和进一步验证。
New
新知识与已有知识没有对应结构:
Knew∩Kold=∅K_{new}\cap K_{old}=\varnothing
则建立新的知识结构。
因此:
KnowledgeUpdate=Match+Difference+ValidationKnowledgeUpdate= Match + Difference + Validation
5.7 能力结构更新
知识更新并不自动等于能力更新。
这是结构智能理论中的一个重要边界:
Knowledge≠CapabilityKnowledge\neq Capability
新的知识只有在与能力结构发生有效匹配以后,才可能形成能力更新。
例如,系统已经具有:
CapabilityCCapability_C
该能力可以处理:
Object+PriceObject + Price
新的学习结果增加了:
CertificationCertification
如果原有能力结构无法处理 Certification,那么仅增加知识:
Knowledge+CertificationKnowledge+Certification
并不会自动形成新的能力。
必须进一步建立:
CapabilityStructure↔NewKnowledgeStructureCapabilityStructure \leftrightarrow NewKnowledgeStructure
如果匹配成功,则:
Capabilityold→CapabilityextendedCapability_{old} \rightarrow Capability_{extended}
因此能力更新过程为:
KnowledgeUpdate→CapabilityRequirement→CapabilityMatching→CapabilityUpdateKnowledgeUpdate \rightarrow CapabilityRequirement \rightarrow CapabilityMatching \rightarrow CapabilityUpdate
5.8 能力结构的更新内容
能力结构可以更新:
- 输入结构;
- 对象结构;
- 属性结构;
- 知识调用结构;
- 条件结构;
- 方法结构;
- 规则结构;
- 运算结构;
- 输出结构;
- 验证结构。
能力结构:
CS={Goal,Input,Object,Attribute,Knowledge,Condition,Method,Rule,Operation,Output,Validation}CS= \{ Goal, Input, Object, Attribute, Knowledge, Condition, Method, Rule, Operation, Output, Validation \}
学习以后可能形成:
CSold→CSnewCS_{old} \rightarrow CS_{new}
例如原来的能力只能:
Price→Compare()Price\rightarrow Compare()
学习以后能够:
Price+Certification→Compare()+Verify()Price+Certification\rightarrow Compare()+Verify()
于是:
Capabilityold→CapabilityextendedCapability_{old} \rightarrow Capability_{extended}
能力本身因此获得新的处理范围。
5.9 知识缺口驱动能力更新
能力结构更新还可以反过来暴露知识需求。
例如某能力要求:
CapabilityRequirement={Object,Price,Certification,Function}CapabilityRequirement= \{ Object, Price, Certification, Function \}
但已有知识只有:
Object+PriceObject+Price
则:
KnowledgeGap={Certification,Function}KnowledgeGap= \{Certification,Function\}
于是:
CapabilityGap→KnowledgeRequirement→Learning→KnowledgeUpdate→CapabilityUpdateCapabilityGap \rightarrow KnowledgeRequirement \rightarrow Learning \rightarrow KnowledgeUpdate \rightarrow CapabilityUpdate
这说明学习更新不是单向过程。
不是:
Learning→KnowledgeLearning\rightarrow Knowledge
而是:
Requirement→Capability→KnowledgeRequirement→Learning→KnowledgeUpdate→CapabilityUpdateRequirement \rightarrow Capability \rightarrow KnowledgeRequirement \rightarrow Learning \rightarrow KnowledgeUpdate \rightarrow CapabilityUpdate
由此形成需求驱动的结构更新。
5.10 方法更新
方法是学习更新的重要结果。
方法不是单纯的知识,也不是能力本身。
Capability≠MethodCapability\neq Method
能力回答:
能够完成什么任务。
方法回答:
按照什么结构路径完成任务。
因此,当新的学习结果改变了解决问题的有效路径时,原有方法也必须更新。
方法结构:
Method={Goal,Input,Object,Condition,Knowledge,Capability,Rule,Operation,Step,Output,Validation}Method= \{ Goal, Input, Object, Condition, Knowledge, Capability, Rule, Operation, Step, Output, Validation \}
学习更新以后:
Methodold→MethodnewMethod_{old} \rightarrow Method_{new}
可能发生:
- 增加步骤;
- 删除步骤;
- 调整步骤顺序;
- 增加条件;
- 修改条件;
- 修改规则;
- 替换运算;
- 增加子方法;
- 更换能力调用;
- 修改参数;
- 增加验证;
- 增加异常处理。
5.11 方法更新与执行反馈
方法更新的重要来源是实际执行结果。
设:
Methodold→Execution→ResultMethod_{old} \rightarrow Execution \rightarrow Result
如果:
Result≠ExpectedResult\neq Expected
则:
Feedback→MethodEvaluationFeedback \rightarrow MethodEvaluation
如果经过分析发现方法结构本身存在问题:
MethodFailure→MethodCorrectionMethodFailure \rightarrow MethodCorrection
形成:
Methodold→Correction→MethodnewMethod_{old} \rightarrow Correction \rightarrow Method_{new}
例如:
M=Step1→Step2→Step3M= Step_1 \rightarrow Step_2 \rightarrow Step_3
执行以后发现:
Step2Step_2
在某一条件下无效。
则可能形成:
Condition→Step2ACondition \rightarrow Step_2A
和:
Condition→Step2BCondition \rightarrow Step_2B
于是原来的线性方法:
Step1→Step2→Step3Step_1\rightarrow Step_2\rightarrow Step_3
更新为:
Step1→Condition→{Step2AStep2B→Step3Step_1 \rightarrow Condition \rightarrow \begin{cases} Step_{2A}\\ Step_{2B} \end{cases} \rightarrow Step_3
这就是学习对方法结构的直接更新。
5.12 方法知识与可执行方法的更新
需要进一步区分:
MethodKnowledgeMethodKnowledge
和:
ExecutableMethodExecutableMethod
方法知识描述:
某种方法在什么条件下有效,以及产生什么结果。
可执行方法则能够真正被调用、实例化和执行。
因此:
MethodKnowledge→MethodStructure→MethodInstantiation→ExecutionMethodKnowledge \rightarrow MethodStructure \rightarrow MethodInstantiation \rightarrow Execution
学习可以首先产生:
MethodKnowledgeMethodKnowledge
经过验证以后才形成稳定的:
MethodMethod
再经过实例化以后:
Method→MethodInstanceMethod\rightarrow MethodInstance
最终进入:
ExecutionExecution
因此:
Learning≠ImmediateMethodFormationLearning \neq ImmediateMethodFormation
必须经过:
Learning→MethodKnowledge→Validation→MethodFormationLearning \rightarrow MethodKnowledge \rightarrow Validation \rightarrow MethodFormation
5.13 结构关系更新
结构智能中的结构并不是孤立节点的集合。
真正使知识、能力和方法形成可运算体系的是它们之间的关系。
因此学习不仅更新节点,还必须更新关系。
结构关系包括:
Relation={ObjectRelation,AttributeRelation,KnowledgeRelation,CapabilityRelation,MethodRelation,ConditionRelation,RuleRelation,ResultRelation}Relation= \{ ObjectRelation, AttributeRelation, KnowledgeRelation, CapabilityRelation, MethodRelation, ConditionRelation, RuleRelation, ResultRelation \}
例如:
ObjectA→Relation→ObjectBObject_A\rightarrow Relation\rightarrow Object_B
能力与知识之间:
Capability→Requires→KnowledgeCapability\rightarrow Requires\rightarrow Knowledge
能力与方法之间:
Capability→Uses→MethodCapability\rightarrow Uses\rightarrow Method
方法与能力之间:
Method→Calls→CapabilityMethod\rightarrow Calls\rightarrow Capability
方法与运算之间:
Method→OperationMethod\rightarrow Operation
知识与方法之间:
Knowledge→Supports→MethodKnowledge\rightarrow Supports\rightarrow Method
反馈与知识之间:
Feedback→Updates→KnowledgeFeedback\rightarrow Updates\rightarrow Knowledge
这些关系本身也是学习对象。
5.14 结构关系的新增与修正
新的学习结果可能发现:
A→R1→BA\rightarrow R_1\rightarrow B
原有结构没有该关系。
则:
Relationnew=Relationold+R1Relation_{new}=Relation_{old}+R_1
如果新的学习结果证明原来的关系错误:
A→R1→BA\rightarrow R_1\rightarrow B
应更新为:
A→R2→BA\rightarrow R_2\rightarrow B
则:
R1→R2R_1\rightarrow R_2
如果关系只在特定条件下成立:
A→R→BA\rightarrow R\rightarrow B
进一步更新为:
Condition→(A→R→B)Condition\rightarrow(A\rightarrow R\rightarrow B)
因此,学习不仅能够发现“有什么”,还能够发现:
什么与什么存在关系、关系是什么、关系在什么条件下成立。
5.15 结构关系决定知识能否运算
孤立的信息不能形成完整的可运算知识结构。
例如:
29.9929.99
只是一个值。
如果建立:
Product→Price→29.99Product\rightarrow Price\rightarrow29.99
则形成属性结构。
进一步建立:
Product→Price→29.99Product\rightarrow Price\rightarrow29.99
与:
Condition→Price<30Condition\rightarrow Price<30
结合以后,才能形成可判断结构。
因此:
Element→Structure→Relation→OperationElement \rightarrow Structure \rightarrow Relation \rightarrow Operation
结构关系决定了元素之间如何被解释和运算。
这也是结构智能与单纯信息存储之间的重要区别。
5.16 学习更新中的结构传播
一次知识更新可能进一步影响能力、方法和决策结构。
例如:
KnowledgeUpdateKnowledgeUpdate
可能导致:
CapabilityUpdateCapabilityUpdate
进而导致:
MethodUpdateMethodUpdate
再进一步影响:
DecisionUpdateDecisionUpdate
因此:
Knowledge→Capability→Decision→MethodKnowledge \rightarrow Capability \rightarrow Decision \rightarrow Method
中的任意一个基础结构发生变化,都可能产生后续结构传播。
完整更新过程:
Feedback→LearningMaterial→KnowledgeUpdate→CapabilityEvaluation→CapabilityUpdate→MethodEvaluation→MethodUpdate→DecisionEvaluation→DecisionUpdateFeedback \rightarrow LearningMaterial \rightarrow KnowledgeUpdate \rightarrow CapabilityEvaluation \rightarrow CapabilityUpdate \rightarrow MethodEvaluation \rightarrow MethodUpdate \rightarrow DecisionEvaluation \rightarrow DecisionUpdate
但是,这种传播不是无条件自动发生。
必须判断:
新结构是否真正影响下游结构。
因此需要:
ImpactAnalysisImpactAnalysis
即结构影响分析。
5.17 结构影响分析
设:
KnewK_{new}
是新的知识结构。
系统需要判断:
Knew→C?K_{new}\rightarrow C?
如果:
YesYes
则检查能力:
C→M?C\rightarrow M?
如果该知识会影响方法:
YesYes
则:
Mold→MnewM_{old}\rightarrow M_{new}
进一步:
Mnew→D?M_{new}\rightarrow D?
如果影响决策,则更新决策相关结构。
因此:
NewKnowledge→ImpactAnalysis→AffectedStructures→SelectiveUpdateNewKnowledge \rightarrow ImpactAnalysis \rightarrow AffectedStructures \rightarrow SelectiveUpdate
这避免了每次学习都重新建立整个系统。
5.18 学习更新不是全部重建
结构智能中的学习更新应当尽可能保持已有有效结构。
如果只有一个属性发生变化,不应重新建立全部对象。
例如:
ProductProduct
已有:
BrandBrand PricePrice FunctionFunction
现在仅新增:
CertificationCertification
则更新:
Product→CertificationProduct \rightarrow Certification
即可。
因此:
Update≠RebuildUpdate\neq Rebuild
学习更新的基本原则是:
保留已经验证有效的结构,只改变需要改变的结构。
但是,如果新知识证明整个结构模型存在根本错误,则可以进行结构重组。
于是:
SelectiveUpdateSelectiveUpdate
是通常状态,而:
StructuralReorganizationStructuralReorganization
是必要情况下的高级更新。
5.19 学习更新的验证
任何学习更新都不能因为“获得了新信息”就立即被视为有效。
必须验证更新结果。
基本过程:
Learning→Update→ValidationLearning \rightarrow Update \rightarrow Validation
验证至少包括:
StructureValidationStructureValidation KnowledgeValidationKnowledgeValidation RelationValidationRelationValidation CapabilityValidationCapabilityValidation MethodValidationMethodValidation
以及必要时:
ExecutionValidationExecutionValidation
例如新方法形成以后:
Methodnew→Execution→Result→ValidationMethod_{new} \rightarrow Execution \rightarrow Result \rightarrow Validation
如果执行结果有效:
Methodnew→StableMethod_{new}\rightarrow Stable
如果无效:
Methodnew→CorrectionMethod_{new}\rightarrow Correction
因此:
LearningUpdate→Validation→StableStructureLearningUpdate \rightarrow Validation \rightarrow StableStructure
5.20 学习更新与历史结构
结构更新不能破坏时间上的知识变化。
现实世界中的对象、属性、状态和方法可能随着时间变化。
因此:
StructuretStructure_t
不能简单理解为永远不变。
例如:
Pricet1=29.99Price_{t1}=29.99
后来:
Pricet2=39.99Price_{t2}=39.99
则不是说:
29.9929.99
从未存在,而是:
Price(t1)=29.99Price(t_1)=29.99 Price(t2)=39.99Price(t_2)=39.99
所以:
Knowledge=CurrentKnowledge+HistoricalKnowledgeKnowledge = CurrentKnowledge + HistoricalKnowledge
当前有效结构和历史结构应当区分。
这使结构智能能够描述:
Statet0→Statet1→Statet2State_{t0} \rightarrow State_{t1} \rightarrow State_{t2}
从而形成具有时间连续性的知识结构。
5.21 学习更新与冲突知识
新旧知识之间可能发生冲突。
例如:
K1:Price=29.99K_1:Price=29.99 K2:Price=39.99K_2:Price=39.99
不能简单认为后来的信息一定正确。
必须分析:
- 对象是否相同;
- 时间是否相同;
- 条件是否相同;
- 来源是否相同;
- 状态是否相同;
- 是否存在不同版本;
- 是否属于不同场景。
因此:
KnowledgeConflict→ConflictAnalysisKnowledgeConflict \rightarrow ConflictAnalysis
可能得到:
SameObject+DifferentTimeSameObject+DifferentTime
或者:
DifferentObjectDifferentObject
或者:
DifferentConditionDifferentCondition
或者:
KnowledgeErrorKnowledgeError
只有在确定冲突原因以后,才能决定:
MergeMerge UpdateUpdate ReplaceReplace KeepBothKeepBoth
或:
RejectReject
这保证学习更新不会因为新信息进入系统就破坏原有知识结构。
5.22 学习更新与能力验证
知识更新以后,必须进一步判断能力是否仍然有效。
例如:
CapabilityCCapability_C
原来依赖:
KnowledgeKKnowledge_K
如果:
K→K′K\rightarrow K’
那么需要检查:
CapabilityC(K′)Capability_C(K’)
是否仍然能够产生有效结果。
因此:
KnowledgeUpdate→CapabilityValidationKnowledgeUpdate \rightarrow CapabilityValidation
如果能力仍然有效:
Cold→CstableC_{old}\rightarrow C_{stable}
如果能力需要增加新的输入:
Cold→CextendedC_{old}\rightarrow C_{extended}
如果能力失效:
Cold→CcorrectedC_{old}\rightarrow C_{corrected}
如果原有能力完全无法适应新的知识结构:
CapabilityGap→CapabilityFormationCapabilityGap \rightarrow CapabilityFormation
因此:
KnowledgeUpdate→CapabilityValidation→CapabilityUpdateKnowledgeUpdate \rightarrow CapabilityValidation \rightarrow CapabilityUpdate
5.23 学习更新与方法验证
能力更新以后,原有方法也可能受到影响。
例如:
Capabilityold→MethodoldCapability_{old} \rightarrow Method_{old}
如果:
Capabilityold→CapabilitynewCapability_{old} \rightarrow Capability_{new}
则必须检查:
MethodoldMethod_{old}
是否还能调用新的能力结构。
如果不能:
MethodGapMethodGap
产生。
然后:
MethodGap→MethodUpdateMethodGap \rightarrow MethodUpdate
形成:
Methodold→MethodnewMethod_{old} \rightarrow Method_{new}
因此学习更新形成:
Knowledge→Capability→MethodKnowledge \rightarrow Capability \rightarrow Method
的结构传播。
5.24 学习更新与决策结构
虽然本章重点是知识结构、能力结构、方法和结构关系,但学习更新最终可能影响决策。
例如新的知识改变了:
ObjectStateObjectState
则原来的决策条件可能不再成立。
于是:
KnowledgeUpdate→CognitionUpdate→DecisionReEvaluationKnowledgeUpdate \rightarrow CognitionUpdate \rightarrow DecisionReEvaluation
如果新的能力产生了更优的处理方式:
CapabilityUpdate→CandidateUpdate→DecisionUpdateCapabilityUpdate \rightarrow CandidateUpdate \rightarrow DecisionUpdate
如果新的方法产生了不同执行路径:
MethodUpdate→DecisionMethodSelectionMethodUpdate \rightarrow DecisionMethodSelection
因此学习更新不是孤立的数据更新,而是会进入整个智能过程。
5.25 学习更新的结构闭环
前面各章形成的结构可以在本章中连接起来。
首先:
Requirement→Knowledge→Capability→Decision→Method→ExecutionRequirement \rightarrow Knowledge \rightarrow Capability \rightarrow Decision \rightarrow Method \rightarrow Execution
执行以后:
Execution→Result→FeedbackExecution \rightarrow Result \rightarrow Feedback
反馈进入学习:
Feedback→LearningMaterialFeedback \rightarrow LearningMaterial
学习材料经过结构化:
LearningMaterial→NewInformation→StructureLearningMaterial \rightarrow NewInformation \rightarrow Structure
然后与已有结构进行匹配:
Structurenew↔StructureoldStructure_{new} \leftrightarrow Structure_{old}
形成更新:
Structureold→StructureupdatedStructure_{old} \rightarrow Structure_{updated}
进一步:
KnowledgeUpdate→CapabilityUpdate→MethodUpdateKnowledgeUpdate \rightarrow CapabilityUpdate \rightarrow MethodUpdate
并更新结构关系:
Relationold→RelationupdatedRelation_{old} \rightarrow Relation_{updated}
最终:
UpdatedKnowledge→UpdatedCognition→UpdatedCapability→UpdatedDecision→UpdatedMethod→NewExecutionUpdatedKnowledge \rightarrow UpdatedCognition \rightarrow UpdatedCapability \rightarrow UpdatedDecision \rightarrow UpdatedMethod \rightarrow NewExecution
新的执行又产生新的结果:
NewExecution→NewResult→NewFeedbackNewExecution \rightarrow NewResult \rightarrow NewFeedback
于是形成:
Learning→Update→Execution→Feedback→Learning\boxed{ Learning \rightarrow Update \rightarrow Execution \rightarrow Feedback \rightarrow Learning }
这构成结构智能的持续学习闭环。
5.26 学习更新的统一结构
综合本章,可以将学习更新表示为:
LU={K,C,M,R,V}\boxed{ LU= \{ K, C, M, R, V \} }
其中:
- KK:Knowledge Update,知识结构更新;
- CC:Capability Update,能力结构更新;
- MM:Method Update,方法结构更新;
- RR:Relation Update,结构关系更新;
- VV:Validation,更新验证。
完整过程:
LearningMaterial→KnowledgeUpdate→RelationUpdate→CapabilityEvaluation→CapabilityUpdate→MethodEvaluation→MethodUpdate→ValidationLearningMaterial \rightarrow KnowledgeUpdate \rightarrow RelationUpdate \rightarrow CapabilityEvaluation \rightarrow CapabilityUpdate \rightarrow MethodEvaluation \rightarrow MethodUpdate \rightarrow Validation
如果更新结果通过验证:
UpdatedStructure→StableStructureUpdatedStructure\rightarrow StableStructure
如果没有通过验证:
UpdatedStructure→CorrectionUpdatedStructure\rightarrow Correction
进一步:
Correction→ReLearningCorrection\rightarrow ReLearning
形成:
Learning→Update→Validation→Correction→ReLearning\boxed{ Learning \rightarrow Update \rightarrow Validation \rightarrow Correction \rightarrow ReLearning }
5.27 学习更新的层级关系
学习更新可以形成不同层级。
第一层是元素更新:
ElementUpdateElementUpdate
第二层是对象、属性和值更新:
Object/Attribute/ValueUpdateObject/Attribute/ValueUpdate
第三层是知识结构更新:
KnowledgeStructureUpdateKnowledgeStructureUpdate
第四层是能力结构更新:
CapabilityStructureUpdateCapabilityStructureUpdate
第五层是方法结构更新:
MethodStructureUpdateMethodStructureUpdate
第六层是结构关系更新:
RelationStructureUpdateRelationStructureUpdate
第七层是整个问题解决结构更新:
ProblemSolvingStructureUpdateProblemSolvingStructureUpdate
因此:
Element→Object→Knowledge→Capability→Method→ProblemSolvingElement \rightarrow Object \rightarrow Knowledge \rightarrow Capability \rightarrow Method \rightarrow ProblemSolving
可以形成层级化学习更新。
5.28 学习更新形成新的结构能力
学习的最终目的不是不断扩大数据量,而是让系统能够以新的结构解决新的问题。
因此:
Learning→KnowledgeUpdateLearning \rightarrow KnowledgeUpdate
只是第一步。
真正重要的是:
KnowledgeUpdate→CapabilityUpdateKnowledgeUpdate \rightarrow CapabilityUpdate
以及:
CapabilityUpdate→MethodUpdateCapabilityUpdate \rightarrow MethodUpdate
最终:
MethodUpdate→ProblemSolvingImprovementMethodUpdate \rightarrow ProblemSolvingImprovement
因此可以表示为:
学习→知识更新→能力更新→方法更新→问题解决能力提升\boxed{ 学习 \rightarrow 知识更新 \rightarrow 能力更新 \rightarrow 方法更新 \rightarrow 问题解决能力提升 }
这里的“提升”不是抽象的智能评分,而是能够明确表现为:
- 可以处理更多对象;
- 可以识别更多属性;
- 可以使用更多知识;
- 可以调用更多能力;
- 可以执行更多运算;
- 可以适应更多条件;
- 可以形成更多方法;
- 可以解决原来不能解决的问题;
- 可以减少已经验证的错误;
- 可以根据反馈修正原有结构。
因此学习成果是可结构化、可验证和可执行的。
5.29 学习更新的核心原则
通过前面的理论,可以建立学习更新的基本原则。
第一,学习不是简单增加信息
Learning≠DataAdditionLearning\neq DataAddition
而是:
Learning=StructureUpdateLearning=StructureUpdate
第二,知识更新不等于能力更新
KnowledgeUpdate≠CapabilityUpdateKnowledgeUpdate\neq CapabilityUpdate
必须经过:
Knowledge↔CapabilityKnowledge\leftrightarrow Capability
的结构匹配。
第三,能力更新不等于方法更新
CapabilityUpdate≠MethodUpdateCapabilityUpdate\neq MethodUpdate
必须检查新的能力是否改变实际解决问题路径。
第四,结构关系本身也是学习对象
Relation∈LearningTargetRelation\in LearningTarget
第五,更新必须经过验证
Update→ValidationUpdate\rightarrow Validation
第六,更新应当保持已有有效结构
Update≠RebuildUpdate\neq Rebuild
除非新的学习结果证明原结构需要重组。
第七,学习更新必须能够进入下一轮执行
UpdatedStructure→ExecutionUpdatedStructure \rightarrow Execution
只有进入实际问题解决过程并产生有效结果,学习更新才真正完成验证。
5.30 学习更新与结构智能
传统的信息积累可以表示为:
Information→StorageInformation \rightarrow Storage
而结构智能中的学习更新则是:
Information→Element→Structure→Knowledge→Capability→Method→Execution→Feedback→UpdateInformation \rightarrow Element \rightarrow Structure \rightarrow Knowledge \rightarrow Capability \rightarrow Method \rightarrow Execution \rightarrow Feedback \rightarrow Update
因此,学习不是智能系统外部附加的资料管理过程,而是结构智能自身持续改变和完善的过程。
结构智能的学习结果不是简单地回答:
“系统增加了多少信息?”
而是回答:
“系统原来的结构发生了什么变化?”
这种变化可以发生在:
ElementElement ObjectObject AttributeAttribute ValueValue RelationRelation StateState KnowledgeKnowledge CapabilityCapability MethodMethod
以及更高层的问题解决结构中。
由此:
Learning=Knowledge+Structure+Capability+Method+Relation+Validation\boxed{ Learning = Knowledge + Structure + Capability + Method + Relation + Validation }
5.31 学习更新的完整循环
将本章与前面的感知、认知、学习、能力、决策、方法、执行和反馈理论统一起来,可以得到完整的结构智能学习循环:
需求→需求结构需求 \rightarrow 需求结构 →知识获取→知识结构化\rightarrow 知识获取 \rightarrow 知识结构化 →知识匹配→知识语义理解\rightarrow 知识匹配 \rightarrow 知识语义理解 →认知结果→能力匹配\rightarrow 认知结果 \rightarrow 能力匹配 →能力形成→决策\rightarrow 能力形成 \rightarrow 决策 →方法形成→方法实例化\rightarrow 方法形成 \rightarrow 方法实例化 →执行→执行结果\rightarrow 执行 \rightarrow 执行结果 →状态变化→反馈\rightarrow 状态变化 \rightarrow 反馈 →学习材料→新知识\rightarrow 学习材料 \rightarrow 新知识 →知识更新→结构关系更新\rightarrow 知识更新 \rightarrow 结构关系更新 →能力更新→方法更新\rightarrow 能力更新 \rightarrow 方法更新 →验证→新的问题解决结构\rightarrow 验证 \rightarrow 新的问题解决结构
最终形成:
需求→知识→认知→能力→决策→方法→执行→结果→反馈→学习→更新→新知识→新能力→新方法→再次解决问题\boxed{ 需求 \rightarrow 知识 \rightarrow 认知 \rightarrow 能力 \rightarrow 决策 \rightarrow 方法 \rightarrow 执行 \rightarrow 结果 \rightarrow 反馈 \rightarrow 学习 \rightarrow 更新 \rightarrow 新知识 \rightarrow 新能力 \rightarrow 新方法 \rightarrow 再次解决问题 }
这不是一次性的学习过程,而是持续运行的结构循环。
5.32 本章结论
学习更新是结构智能学习理论中连接“学习”和“智能持续发展”的关键环节。
前面的学习过程解决了:
从反馈中获得什么。
本章解决的是:
获得以后,已有结构如何发生变化。
因此,学习更新不是简单保存新的知识,而是将新学习结果与已有结构进行匹配和比较,并根据验证结果决定对知识结构、能力结构、方法结构以及结构关系进行新增、扩展、修正、替换、关联或重组。
其基本结构为:
新学习结果→新旧结构匹配→差异分析→知识更新→关系更新→能力更新→方法更新→验证\boxed{ 新学习结果 \rightarrow 新旧结构匹配 \rightarrow 差异分析 \rightarrow 知识更新 \rightarrow 关系更新 \rightarrow 能力更新 \rightarrow 方法更新 \rightarrow 验证 }
进一步形成:
知识更新→能力更新→方法更新→执行验证→反馈→再次学习\boxed{ 知识更新 \rightarrow 能力更新 \rightarrow 方法更新 \rightarrow 执行验证 \rightarrow 反馈 \rightarrow 再次学习 }
由此,学习不再被理解为知识数量的增长,而被定义为结构持续更新的过程。
最终可以建立WSaiOS-SI的学习更新基本公式:
LearningUpdate=NewKnowledge+StructureMatching+DifferenceAnalysis+RelationUpdate+CapabilityUpdate+MethodUpdate+Validation\boxed{ LearningUpdate = NewKnowledge + StructureMatching + DifferenceAnalysis + RelationUpdate + CapabilityUpdate + MethodUpdate + Validation }
而结构智能的持续学习循环则可以归纳为:
Feedback→Learning→Update→Capability→Method→Execution→Result→Feedback\boxed{ Feedback \rightarrow Learning \rightarrow Update \rightarrow Capability \rightarrow Method \rightarrow Execution \rightarrow Result \rightarrow Feedback }
因此,学习更新使结构智能具备了一种重要的结构特性:
系统不是通过不断堆积信息而获得持续智能,而是通过实际问题解决产生反馈,通过反馈形成新的学习材料,再通过学习改变知识、能力、方法及其结构关系,并通过新的执行不断验证这些更新,使智能结构在问题解决过程中持续形成、修正和发展。
这使“学习”从知识获取过程进一步成为结构自我更新过程,也使WSaiOS-SI前面建立的知识、认知、能力、决策、方法、执行和反馈理论最终形成连续的结构闭环。