CN1167948A - 一种高效的数据驱动理论修正系统 - Google Patents

Abstract

高效的数据驱动理论修正系统，取一初始层KB₀和注解的会话转录集C={π_j，r_j}作为输入，并给定一组特定的修正操作符T={θ_i}。每个θ_i∈T将一错误KB映射成稍有不同的层θ_i(KB)。其用T来从初始错误层KB₀。通过连续层KB₁…KB_m爬山，这些连续层在C上具有连续较高经验精度。提供一种高效的方法来求出KB_k及每个θ_i(KB_k)的精度，以确定哪一个θ_i(KB_k)比KB_k更精确。最后定出对于知识库可以基于任何事例而变化的精度分值，此即分支界限法可用于避免对并非最优的不同的层计算其精度值。

Description

一种高效的数据驱动 理论修正系统

本发明涉及理论修正系统的一部分，此系统给出了一个产生具有最高精度的理论的修正。更具体地，本发明涉及高效地使用一套固定的注解会话转录(session transcripts)和一套固定的可能的理论到理论修正操作符来修改给定的理论的系统，此给定的理论编码为一个错误层次(fault hierarchy)，从而形成一个具有最理想精度的新理论。

许多专家系统使用一错误层次来对依据一组所报告的症状测试值的装置提出修补。遗憾的是，如果它们的这种基础层次是不正确的，那么这些种系统就可能又回到错误的修补。一种理论修正系统使用一个带标记的会话转录C(每一转录包括由该专家系统给出的对测试的答案及由人类专家提供的正确的修补)来修改不正确的错误层次，以生成一个更精确的新层次。典型的修正系统将初始层KB与它的每个相邻层N(KB)＝{KB_k}进行比较，其中KB_k是对KB进行一个简单的修正而形成的，例如去掉一对错误节点之间的连接，或者改变考虑某些错误节点的顺序。如果KB^*对C的经验精度大大高于KB的精度，则这些修正系统将从KB上升至相邻KB^*∈N(KB)。

在机器学习文献中描述有许多理论修正系统。其大多数与本发明类似使用一组变换以从一种理论转变成另一种理论。然而很多其他系统则集中注意力于霍恩子句知识库(Horn clause knowledge bases)或判定树；不是很适于展开应用系统的表示法。本发明的一个目的是使用广泛展开的错误层表示法。而且，现有的理论修正系统建议的修改可能产生会被本领域专家否定的理论。本发明的另一个目的是建议保留错误层次的结构的修改，这样就很可能被本领域专家接受。最后，这些现有技术系统假定用来确定哪个知识库最精确的训练数据(即注解会话转录)将包括对所有相关测试的答案。在许多标准情况下这是不现实的，在这些标准情况下，每一个训练事例仅包括相对于一特定理论得到答案所需要的最小量信息。相比之下，本发明的D_ELTAD_ELTA系统是设计来测定任何理论的精度，即使是用不完全的数据来进行。

而且这些系统很少考虑计算效率。特别地，实现爬山法(hill climbing)的每一步的明显的方法包括了第一步经验地对整体的一组情况报告来求出初始KB及每个KB_i∈N(KB)。可是，对于单个报告来求出单个层所花的代价很高，而且更糟的是其可能有大量的报告和大量的相邻层。本发明的一个目的是提供一个高效的方法来确定哪个KB_i∈N(KB)具有最高的经验精度，如果该精度大于KB的精度。

本发明是一个计算机系统，称作D_ELTAD_ELTA，它取一个初始错误层KB₀和一组注解会话转录C＝{<π_j，r_j>}作为输入，其中πj包括对该专家系统提供的所有测试的答案，并且正确的修补r_j由人类专家提供。本发明有一组专用的修正操作符T＝{θ_i}，这里每一个θ_i∈T将一错误层KB映射到一稍微不同的层θ_i(KB)。这种修正的错误层θ_i(KB)称为KB邻层。所有KB的邻层的集合，N(KB)＝{θ_i(KB)}，是KB的邻域。

本发明使用T来从初始错误层KB₀经过连续具有超过C的较高经验精度的连续层KB₁...KB_m进行爬山过程；最终层KB_m在由修正操作符所定义的空间中为局部最佳。在每个阶段，为了从错误层KB_k进到它的邻层KB_k+1，本发明必须求出KB_k对C的精度，同时求出每个KB′∈N(KB_k)的精度。令KB为经验精度最高的层。如果此KB^*比KB_k更精确，则该KB^*层为新标准，记为KB_k+1，并反复进行理论修正过程，寻找此KB_k+1的对于事例集合C比KB_k+1更为精确的相邻层，并如此进行下去。否则，如果没有比KB_k更精确的KB′，则爬山过程将返回此KB_k并结束。本发明不同于美国专利中描述的Delta系统之处在于提供了一种高效装置来求出一组知识库KB′∈N(KB_k)的精度。

如果带标记的会话转录C＝{<π_j，r_j>}是完备的(即每个C_j∈C包括对KB中每个可能的测试的答案)，则可直接求出KB对C的经验精度，然而实际上，C总是不完备的，因为每个πj仅包含一个很小的KB中的测试值的子集。本发明的理论修正系统提供了一种求出KB和每个KB′∈N(KB)的经验精度的方法，即使在C是不完备的时候。

而且，本发明的求值器(在理论修正系统内)提供了一种高效的求出KBk及每一个θ_i(KBk)的方法，以确定是否有θ_i(KBk)比KBk更精确。它利用了一些关键的观测结果。第一，由于本发明中使用的将一层映射到其相关层的每次变换只对该层进行局部改变，所以对任一事例，将只产生较小的并容易计算的影响；第二，大多数变换对很多事例不产生影响；最后，可以根据任一事例，给出对一知识库可以变化的精度大小的界限，这意味着可用分支界限(branchand-bound)技术来避免计算不是最佳的不同层的精度大小。由于这些原因，直接分析就使该系统避免了大量的用蛮力的(brute-force)经验计算。

图1表示一个利用本发明的总体理论修正任务的系统。

图2表示本发明的一个实施例应用的一个错误层(KB₀)的结构。

图3表示各节点是相关的，即使各相异测试是独立的，A_CCN_ODE ^*将解决这个问题。

图4表示父与子节点间的依赖关系，这会导致A_CCN_ODE ^*子例程产生错误应答。

图5表示本发明的一个实施例应用的初始层KB_before和相继的层KB_after。

图6表示在理论修正过程中由任一单步所取得的信息。

图1表示总体理论修正任务，此总体任务在第08/583,249号美国专利申请中也有描述。其名称是“使用专家意见来修正诊断专家系统错误层次的Delta学习系统(The Delta Learning System For Using Expert Advice To ReviseDiagnostic Expert System Fault Hierarchies)”，申请日为1996年1月5日，转让给了与本发明相同的受让人，这里用作参考。给定一个知识库11KB和使用者反馈(一套训练示例，每一个会话转录12由一个正确的答案作注解)，则理论修正系统13产生一个新的知识库KB′，此知识库对于这些训练示例具有更好的性能。更详细地，会话转录12在将专家系统给现场用户15使用之后进行收集。每个转录12将包括由该专家系统14要求的对测试的答案及由该专家系统14建议的修补。在适当的时候(如给出的修补是不正确的)，本领域专家16则对这些转录进行注解以指示错漏的测试及适当的修补。该理论修正系统13(如本发明)使用这些注解的转录作为训练数据来对知识库11提出修正。最后，本领域专家16评估这些修正以决定是否将其结合到知识库11中，然后可对知识库11进行重新利用。

目前使用的许多专家系统，根据一组报告的症状，使用一错误层来给一个设备提出一个修补。遗憾的是，由于这些基础设备的改变，由于设备的使用年数及新设备的安装而产生的新的错误分布，也由于原来的知识库中的错误，所以，这些提供的修补不可能是正确的修补。“理论修正”系统使用一组“带标记的会话转录”来修改不正确的错误层以产生更精确的新层。由于没没有有效的算法来保证找到全局最优层，所以许多方案以爬山法过程来实现它的理论修正系统，爬山法是以一些连续的步骤来爬向精度为局部最优的层。在每一步中，每个这种系统计算相对于给定的带标记会话转录的集合C的当前层KB和KB的每个相邻层N(KB)＝{KB_k}的经验精度，其中每个相邻层KB_k∈N(KB)只是对KB稍加修改。然后该理论修正系统选择具有最高经验精度的相邻层KB^*∈N(KB)。并且如果KB^*的精度大于KB的精度，则理论修正过程反复进行。它进而比较KB^*和它的相邻层，并爬到任何一个更好的层。如果带标记的会话转录C＝{<π_j，r_j>}是完备的(即每个C_j∈C包含KB中每个可能测试的答案)，就直接求出C上的KB的经验精度。然而实际上，C通常是不完备的，这是因为每个C_j仅包括一个KB中的测试值的小子集。本发明的理论修正系统提供了一种对相对于给定的一组带标记会话转录的错误层及其每个相邻层的经验精度进行求值的方法，即使是在转录是不完备的时候。

本发明提供了一种高效的方法来求出相对于一组给定的带标记情况报告的错误层及其每一相邻层的经验精度。本申请将提供本发明的结构，描述基本的专家系统的操作过程，并总结其理论修正任务，以下将描述为此任务而实现理论修正系统的方法：首先，总结明显的穷举算法，然后，提供导致一个更高效的“数据驱动”理论修正系统的原理方法，最后描述本发明的D_ELTAD_ELTA算法。

下文给出两个错误层及问题事例的结构，然后描述一个以错误层为基础的专家系统是如何工作的：在某一事例的上下文求出一个层以产生一个修补。每个错误层KB＝<N，E，Ts，R，t(·)，r(·)，child(·，·))是一个直接非周期性森林(directed-acyclic forest)<N，E>，其结点N代表错误，其边缘E连接错误与从属错误。每个节点n∈N用测试t(n)＝t或t(n)＝t作标记，其中t∈TS。而且，每个叶节点也用一个“repair”，r(n)＝r∈R作标记。每个节点下的弧是有序的；child(n，i)表示“n的第i个子”。为解释方便，用k：N→Z⁺函数将每个节点映射成它的子数目。用l：N→Z⁺函数将每个节点映射成它的父数目。

例如，考虑图2所示的层，这里与节点X相关的测试为T_X。由此，与节点A相关的测试为T_A，等等。表达方式r_X是标记有关叶节点X的修补。因此，与节点D相关的修补头r_D，其测试为T_D。A的子(Children)按顺序为C，D及E。由此，Child(A，1)＝C，Child(A，2)＝D及Child(A，3)＝E，这里k(A)＝3，类似地，l(A)＝1。

应用KB层的专家系统，称为S_KB，在运行时会向用户提出一系列的问题，这些问题符合深度优先，从左到右、无回溯遍历的(no-backtracktraversal)(部分的)KB结构。这里，S_KBo从根开始，提出与那个节点相关的问题；这里“T_Z为真？”如果用户回答“是”，则S_KBo往下去考虑Z的子，按从左到右的顺序，接着问“T_A为真？”。如果用户回答“是”，则S_KBo往下去考虑A的子。如果用户对T_c回答“否”。S_KB0将继续到C的兄弟D，问关于T_D的情况。假定这里用户回答“是”，则S_KB0将返回到与叶节点D相关的修补，即r_D。相反，如果用户对T_D回答“否”，S_KB0就接着问T_E。如果回答“是”，S_KB0就返回到r_E。否则，如果还是回答“否”，S_KB0就返回到“未找到修补(NO-Repair-Found)答案，r_⊥。注意，S_KB0不再继续到B；对T_A回答“是”表示用户仅考虑此节点下的测试及修补。

表1表示本发明的一个实施例的子例程E_VALK_B和E_vALNODE。表2表示本发明的一个实施例的子例程A_CCKB。

不考虑实际用户交互作用的细节，每个“总共问题事例(toral problem in-stance)”是一个赋值π：TS→{+，-}，表示将每个测试映射成{+，-}之一，这里“+”表示测试被证实(通过)，“-”表示测试未被证实(失败)。给定一个事例π，S_KB就返回一个修补r∈R，记为E_VALKB(KB，π)＝r。这里的r是使用表1所示的子例程E_vALNode，由E_VALNode(ROOT(KB)，π)返回到的值。其中n_root＝ROOT(KB)是KB的根。在调用E_VALNode时，假定与n_root相关的测试已经被证实即其π(t(n_root))＝+。此测试t(n_root)视为症状或触发信息。在测到这个测试值后，S_KB仅考虑使用这个子树。在处理下面定义的子例程A_CCKB时，假定此根(root)的测试已经被证实。

对事例π，KB层的精度是这里，对此事例的正确答案是r_cor∈R。(此r_cor修补通常由人类专家提供)。一般来说，这样一对<π，r_cor>将称为“带标记的(全部)问题事例。对于一组带标记的事例(a.k.a.会话转录)C＝{<π_i，r_i>}_i，KB的(经验)精度是 $\mathrm{acc}(\mathrm{KB},C)=\underset{(\mathrm{\&pi;},r)\mathrm{\&epsiv;C}}{\mathrm{\&Sigma;}}\mathrm{acc}(\mathrm{KB},(\mathrm{\&pi;},r))---\left(1\right)$ 其平均精度为此值除以示例数，|C|。

这些计算假定S_KB总可得到对相关测试的答案，在理论修正的上下文中这不总是真的。这里，理论修正系统可能仅知道所需的某些答案。为了便于我们考虑在这样的上下文中一专家系统可能产生的结果，我们应用一个“部分问题事例”π：TS→{+，-，？}，其中“π(t)＝？”表示测试t的值未知。

每个这样的部分事例π实际上与一些总体事例π′相对应，其中某些测试值没有得到。这一点更精确地讲，只要π(t)是绝对的(即不为“？”)，如果π′与π一致，就称总的问题事例π′： T_S→{+，-}是π的完备：

π′使π完备，iff[π(t)≠？π′(t)＝π(t)]由此，总的事例

π_T1＝{T_Z/+，T_A/+，T_B/-，T_C/-，T_D/+，T_E/+，T_F/-}是以下部分事例的完备：

π_P1＝{T_Z/+，T_A/+，T_B/？，T_C/-，T_D/+，T_E/？，T_F/？}。设

complete(π)＝{π′：TS{+，-}|π′completesπ}表示使一给定的部分事例完备的总的事例集。

一般来说，已观测的部分事例对应于总的事例π′∈Complete(π)的概率Pr[π′|π]依赖于每个未观测的测试t(即其中π(t)＝“？”)具有特定值π′(t)的概率。这里，已观察的π_P1对应于实际总体π_T1的概率依赖于T_B＝-，T_E＝+及T_F＝-的概率。假定这些测试是不相关的(互不相关及上下文互不相关)，这即表示这种条件概率可用概率函数p：TS→[0，1]来表示，其中p(t)是未观察的测试t将接下去进行的概率，只要它已被运行及报告。

注意，每个π′∈Complete(π)有一个相关的修补，r_π′＝E_VALKB(KB，π′)；我们因此可使用p(·)值来计算S_KB0将返回每个r_π′的概率，这里给定已观察值π。一般情况下，我们需计算S_KB0将返回正确修补r_cor的概率Pr[S_KB0return r_cor|πobserved]([S_KB0返回r_cor|π已观测])。因为在π是总体事例时此量对应于acc(KB，<π，r_cor>)，所以一般情况下acc(·，·)可扩充为这个概率值，即使是在π为部分事例时。(函数p(·)隐含在acc(KB，<π，r_cor>)描述中)。

表2所示的子例程A_CCKB对于部分事例π计算精度值。无论在什么时候，只要与节点相关的测试是独立的。即：只要确认一个节点测试t(n)的事件是独立而不必考虑其它节点t(n′)是否是独立的，它都返回到正确值。然而，并不总是这种情况。如果所有的节点都用不同的测试作标记，(例如n≠n′暗示t(n)≠t(n′))，那么只要这些测试是独立的，这种条件就应满足。可假定满足此条件。但是，即使这些测试是独立的，而如果不同的节点用相同的测试作标记，那么这种独立节点条件就不能满足。例如，参见图3所示的结构，其中n₁＝child(n，1)用测试t₁作标记，n₂＝child(n，2)用测试t₁作标记并且n₃的修补为正确的r_cor；还假定S_KB以概率1已达到并越过此顶点n(即已知接着进行t_o测试)。这里，A_CCKB将计算到达n₃＝child(n，3)的概率为(1-p(t₁))×p(t₁)，其给出的成功概率为p(t₃)×[(1-p(t₁))×p(t₁)]。当然，这种事件的实际概率为0。

然而，对于一般的dag-structures(dag结构)，计算达到任何特别修补的概率并由此计算acc(KB，C)的任务是NP-hard(很难的)，不可能有一种高效的算法能在任何场合下计算正确的答案。相反，在许多典型情况下，很多算法可用来正确地进行运算。

表3表示本发明的一个实施例的A_CCNODE^*子例程。

因此，本发明应用了稍有扩展的A_CCKB子例程，称A_CCKB^*，如表3所示，其保留了兄弟节点之间的依赖关系，并以此正确解决前面提到的情况。然而，它没有保留其他依赖关系。即如果说n和n₁＝child(n，1)都用t₁作标记，其中π(t₁)＝“？”如图4所示，则它不可能返回(retum)正确的答案。这里，与A_CCKB类似，A_CCKB^*可得出假定其达到n的情况下，达到r_cor修补的概率为p(t₁)×p(t₁)；简单地，过程(course)的正确值简单为p(t₁)。

表4-1和4-2表示本发明的一个实施例的D_ELTAD_ELTA子例程。

下面描述理论修正任务，主要的D_ELLAD_ELTA例程(表4-1和4-2)用初始层KB₀和一组带标记会话转录C＝(C_i)作为输入。D_ELTAD_ETA使用了一组变换T＝{θ_K}，其中θ_K将一层映射成另一层。D_ELTAD_ELTA考虑四种的修正操作符：

-每个Delete_par，n(删除)修正操作符删除节点par与其子节点n之间现存的链接。因此，Delete_B，E(KB₀)是一个层KB₁，包括所有KB₀的节点和它的除从B至E的弧外的所有弧(arcs)。由此，在KB₁中，child(B，1)＝F，注意此删除过程隐性地重新定义了child(·，·)函数。

-每个Add_par，n，i(增加)修正操作符在par和n之间增加一个新链接、即par下的第i弧。由此，层KB₂＝Add_A，F，2(KB₀)包括KB₀中的所有节点和弧以及在<A，C>之后和<A，D>之前得到的从A至F的附加弧。从而，在KB₂中，chold(A，1)＝C，child(A，2)＝F，child(A，3)＝D，child(A，4)＝E，注意，Delete_A，F(Add_A，F2(KB₀))≡KB₀。

-每个Move_{par1，par2，n，i}(移动)修正操作符删除par1和n之间现存的链接，再然后从par2至n增加一个链接。作为Par2下的第i弧，从而Move_{par1，par2，n，i}(KB)＝Add_par2，n，i(Delete_par1，n(KB))。

-每个SWitch_{par，n1，n2}(交换)修正操作符交换从par至n₁的链接和从par至n₂的链接的顺序。注意，每个Switch_{n1，n2，par}修正操作符最多对应于两个Move(移动)修正操作符。

图5表示对错误层KB_before应用Add_A，B，1修正操作符的结果。注意每个操作符都有一个相关的操作符可消除(undo)此操作符的影响。例如应用图5的Delete_A，B操作过程给KB_after，会将错误层恢复为KB_before中。假设N(KB)＝{θ₁(KB)|θ₁∈T}是KB的相邻层的集合。

D_ELTAD_ELTA用一个特定的知识库KB_i来开始每一个爬山步骤。然后要确定是否有任何KB′∈N(KB_i)比KB_i更好；即确定在带标记事例的集合C＝{<π_j，r_j>}上，是否有任何KB′具有更高的经验精度。(如果是这样，则D_ELTAD_ELTA将从KB_i爬到具有最高经验精度的KB^*∈N(KB))。

计算这种最优KB^*实际上需要获得{(acc(KB，C_j)}_Cj∈C的|C|值以计算acc(KB，C)，还需要对每个θ_i∈T和C中的每个C_j计算{acc(θ_i(KB，C_j)}的|C|×|T|值，以计算{acc(θ_i(KB)，C)}_i的|T|值，然后确定这些值中的哪些超过acc(KB，C)(如有的话)。用于这种任务的一个算法应先装入KB层，然后用结果的S_KB来对每个(π_j，r_j)∈C求得E_ValKB(KB，π_j)，进而先计算acc(KB，π_j)的值，然后计算他们的总和acc(KB，C)＝∑_jacc(KB，<π_j，r_j>)。然后要用第一修正操作符θ₁作用于KB来建立KB₁＝θ₁(KB)。然后装入此层以获取S_KB1，并再次考虑|C|事例{<π_j，r_j>}以计算acc(KB₁，C)。接下来，将产生KB₂＝θ₂(KB)。并遍历所有的|C|事例来产生acc(KB₂，C)；并对所有的|T|变换这样做。实质上，此过程包括相继计算图6所示矩阵的每一行。此修正算法然后确定这些KB^*＝argmax_i{acc{KB_i，C}}中最大者，如果acc(KB^*，C)＞acc(θ_i(KB，C)则爬到这一KB层。

这就需很高的代价，因为(1)计算每个acc(KB_i，<π_j，r_j>)，需要对一个事例求出一层，这是很费时的；而且更糟的是(2)|T|和|C|都是很大的，例如，在一次研究中，经常发现有|T|≈10,000这样的值。

提高效率有两种基本的方法：第一种方法是求出{acc(θ_i(KB)，C_j)}_i，j入口的更少部分；以下是这种做的三种技术。第二种方法提供一种更有效的方式来计算此量。由于下面解释的原因，我们实际上使用等效值

diff′(θ，C)＝acc(θ(KB)，C)-acc(KB，C)

Diff(θ，K)＝∑_j＝1..kdiff(θ，C_j)此即在事例C上，θ(KB)和KB之间的精度差。(代表K个事例后的变换的θ(KB)知识库的相对分值)，计算D_ELTAD_ELTA的系统如表4-1和4-2所示。

第一种方法，称为RT_I，根据所考虑的事例<π_j，r_j>限定变换。此方法利用正在考虑的特定的一组变换。这通过观察来完成，即对于几乎每个π_j，对于大量的θ_i，acc(θ_j(KB)，<π_j，r_j>)的值都等于acc(KB，<π_j，r_j>)。这表示大多数变换θ_i并不影响在一个事例上的一层是否正确。作为一个示例，考虑KB₀层(图2)和证实(confirm)t(Z)，t(A)，和t(D)和非证实(disconfirm)t(C)的部分事例π₁＝{t(Z)/+，t(A)/+，t(C)/-，t(D)/+}；这里，S_KB0返回r_D＝E_VALKB(KB₀，π₁)。(注意，S_KB0仅关于这4个测试提问，并仅记录它们的值，其他测试不再被提问，因为在这里它们的值不相关；因此，π₁将每个其他测试映射成“？”)。现在，考虑删除<B，E>弧的Delete_B，E变换并观察到由于在曾达到B之前，原来层KB₀达到其答案(r_D)，所以新层KB₁＝Delete_B，E(KB₀)将达成相同的判定，这里为r_D。由于E_VALKB(KB₀，π₁)＝E_VALKB(KB₁，π₁)，显然acc(KB₀，<π₁，r>)＝acc(Delete_B，E(KB₀)，<π₁，r>)。(注意，这并不依赖于r_D是否过去是正确的答案：如果KB₀对π₁是正确的，则KB₁正确；同样，如果KB₀对π₁不正确，则KB₁不正确)。

现在考虑其他删除。例如删除<B，F>或<A，E>弧；通过上面的讨论，我们立即可知acc(KB₀，<π₁，r>)＝acc(Delete_B，F(KB0)，<π₁，r>)＝acc(Delete_A，E(KB₀)，<π₁，r>)，注意删除<A，C>不产生影响，因为到底C节点是非证实(disconfirmed)的。(这里，由于我们仅考虑该层的精度，并不是其效率，求出额外的T_C测试不是出发点)。很清楚，这里只有删除<Z，A>和<A，D>是可能产生一个差值(即，产生一个层KB′＝Delete(KB₀)，其对π₁的精度可能不同于KB′₀的精度)的删除。(当然，仍可能有acc(Delete_Z，A(KB₀)，<π₁，r>)＝acc(KB₀，<π，r>)。例如，如果为正确修补r_c，则两个系统将都会具有0的值。如果在初始层中有几个路径能导致相同的正确的节点，或者如果此层包括具有相同修补的不同节点，则此情况也会发生)。

增加新链接的类似要求也会被考虑，由于S_KB0从未达到B，所以包括从B到任意点的新链接的新层可能在事例π₁中返回相同的r_D，即对任意节点X₁和索引(index)X₂，有acc(AddB，X₁，X₂(KB₀)，<π₁，r₂>)＝acc(KB₀，<π₁，r₂>)。类似地，由于S_KB0降至A的第二子点，所以对任意新子点X，Add_A，X，3也无影响。如果我们从A到某个其他节点，假定是W增加一个链接，如果不管在何处Add_A，W，i增加此新链接W的测试失败(即：如果π₁(t(W))＝-)，则也没有影响。这里，可能产生差异的唯一的增加变换Add是这样的一些变换：它们通过从可达到的节点(如Z或A)降至可证实的节点从而产生新层KB₂＝Add(KB₀)，这些新层引起S_KB2采取一个不同的路径。类似地，大多数移动(Move)和交换(Switch)变换也没有影响。特别是，只要Delete_par1，n和Add_par2，n，i无影响时，Move_{par1，par2，n，i}肯定是无影响的。

更精确地说，D_ELTAD_ELTA将只考虑通过RT_I_E_LIGIBLE子例程返回的变换的子集，称它们为RT_I(T，N，C_K)，它们不包括其difjf(θ，C_j)＝0的多个变换θ。

表5表示本发明的一个实施例的RT_P和RT_M子例程。

表6-1到表6-6表示本发明的一个实施例的RT_I_E_LIGBLE及相关的子例程。

在本发明的一个实施例中，根据初始错误层KB和注解情况<π，r>，RT_I_E_LIGIBLE子例程(见表6-1到6-6)返回一组变换，其包括：

·Delete(par，n)，只要

n当前为par之子点，

与par相关的测试的状态(表示n)是+或是？(即：π(t(par)∈{+，？})以及

par将被达到(即：用下面定义的τ(·)函数，τ(par＞0)

·Add(par，n，i)，只要

与par相关的测试的状态(表示n)是+或是？

i在0和K(par)之间

par将被达到(即：τ(par)＞0)

n已不为par之子点，及

在par下加n将不会引起循环

·Switch(par，n₁，n₂)，只要

n₁和n₂均为par之子点

与par相关的测试(表示n₁，n₂)的状态是+或是？

par将被达到(即：τ(par)＞0)

·Move(par1，par2，n，i)，只要

根据上面的说明，Add(par2，n，i)合法

根据上面的说明，Delete(par1，n)合法

另外，即使由Add(par2，n，i)产生循环，只要它由Delete(par1，n)操作打断了循环，Move(par1，par2，n，i)是允许的。

第二种方法，称RT_P即“根据一个正的分值来限制变换”，其来自于两种观察：首先，如果对于所有的M个事例，KB^*的经验值严格大于KB的经验值，即如果diff(θ，M)＞0，则D_ELTAD_ELTA仅会从KB爬到变换理论KB＝θ(KB)；第二，由于acc(θ(KB)，C_K)≤1，diff(θ_i，K)和Diff(θ_i，K-1)之间的差值最大可为

Diff(θ，K)-Diff(θ，K-1)

＝acc(θ(KB)，C_K)-acc(KB，C_K)

≤1-acc(KB，C_K)

一般地这表示Diff(θ，M≤Diff(θ，K)+Err_k，其中Err_k＝∑^M _j＝K+1(1-acc(KB，<π_j，r_j>))是剩余的M-k个事例上的KB的总误差。如果Diff(θ，K)≤-Err_k，则显然Diff(θ，M)≤0，这意味着D_ELTAD_ELTA将不会爬至θ(KB)，因此，

RT_P(KB，N，Err_k，Diff(·，K))＝{θ_i∈N|Diff(θ_i，k)＞-Err_k}，这由RTP子例程完成，见表5。

第三种方法，称为RT_M，即“根据极大分值限制变换”。其与上面提到的RT_P过滤器相关，也是基于动态规划。它使用两种观察：第一，如果KB的经验分值在所有的N(KB)的元素上为最大，即如果θ_i∈N，Diff(θ^*，M)≥Diff(θ_i，M)，则D_EITAD_ELTA将仅从KB爬至变换形式KB^*＝θ′(KB)；第二，对于任意θ_g，θ_h∈N，Diff(θ_g，k)-Diff(θ_h，k)和Diff(θ_g，k-1)-Diff(θ_h，k-1)之间的差最大可为1。这一般意味着Diff(θ_g，M)-Diff(θ_h，M)≤Diff(θ_g，k)-Diff(θ_h，k)+(M-k)这样就得到：

如果Diff(θ_g，k)＜Diff(θ_h，k)-(M-k)

则Diff(θ_g，M)＜Diff(θ_h，M)这表示D_ELTAD_ELTA不会爬至θ_g(KB)，在k个采样之后，对于所有的变换，设Best_k＝Max_θ∈N{Diff(θ，k)}为最大的经验(相对的)分值，则我们定义RT_M(KB，N，k，M，Diff(·，k))＝{θ_i∈N|Diff(θ_i，k)＞Best_k-(M-k)}，这由RT_M子例程完成，见表5。

下面描述最后一种方法，即QE(“快速求值”)。由于以上分析，我们仅对变换的一个子集，即仅对集合RT_I(KB，N，C_k)∩RT_p(KB，N，Err_k，Diff(·，k))∩RT_M(KB，N，k，M，Diff(·，k))中的θ_i只需计算acc(θ_i，C_k)的值。

我们先综合每个KB_i＝θ_i(KB)，然后在每个C_j＝<π_j，r_j>事例上“运行”每个KB_i以获取各自的修补及相关的精度分值，以此我们可以计算这些acc(θ_i(KB)，C_k)值。然而，D_ELTAD_ELTA算法使用了一种更有效的方法来计算这些精度分值。

首先要注意的是计算Diff(θ_m，C)而不是acc(θ_m(KB)，C)是充分的，此量变得相对地容易计算(尤其是因为对于许多<θ_m，C>对，有diff(θ_m，C)＝0；见上面RT_I的讨论)。

给定一个(部分的)事例π和正确的修补r_cor，则子例程QE_C_OMPUTER_HOT_AU用初始KB中的每一个节点给出S_KB可能达到r_cor的概率ρ(n)。假定其已达到n。注意，acc(KB，<π，r_cor>)＝ρ(n_root)，其中n_root是KB的根；也有ρ(n)＝p′(n)×A_CCKB^*(n，π，r_cor)，采用：

        {0        如πt((n))＝-

p′(n)＝{1        如π(t(n))＝+

        {p(t(n))  如π(t(n))＝？

QE_C_OMPUTER_HOT_AU还找出KB中的具有S_KB达到并越过弧a的概率τ(a)的每一个弧；以及找出具有到达n的可能性的每个节点n。显然τ(n_root)＝1。给定一个有子点n_i＝child(n，i)的内部节点n，令e_i＝<n，n_i>是连接n到n_i的弧，再反复定义

τ(e_l)＝τ(n)×p′(n)

τ(e_j+1)＝τ(e_j)×(1-p′(n_j))最后，为计算每一个τ(n_j)，只要把达到n_j的各弧的τ值加起来；即一般来说τ(m)＝∑_<n，m>∈Eτ(<n，m>)。注意，这可以在层的大小中的时间线性中计算。

然后，对每个变换θ∈T，QE_DIFF以基本上恒定时间使用这些ρ(°)和τ(·)值计算diff((θ，<π，r_cor>)。(时间实际上由从任意假定为一小常数的节点所下降到的弧的最大数量来界定。)

注意，D_ELTAD_ELTA修正算法并不产生一个明确的S_θj(KB)执行系统，也不对事例π明确地计算值acc(θ_j(KB)，π)。相反，它利用ρ(·)和τ(·)值来直接产生它所需要的信息。

下面描述QE_DIFF计算diff(τ_k，C)＝acc(θ_k(KB)，C)-acc(KB，C)的值的方法。对于每个“删除链接”变换Delete_a，b，令KB′＝Delete_a，b(KB)是从连接节点a到节点b的链接KB经删除而产生的层。显然acc(KB′，<π，r>)＝acc(KB，<π，r>)，只要π(t(a))＝-或π(t(b))＝-。因此，仅需处理π(t(a))∈{+，？}和π(t(b))∈{+，？}的情形。不失普遍性，我们有

acc(KB，<π，r_cor>)＝P[紧挨<a，b>之前]

+τ[<a，b>]×ρ(b)

+τ[<a，b>](1-p′(b))×P[紧挨<a，b>之后|已到达<a，b>]

+τ[a](1-p′(a))P[紧挨a之后]

其中，P[紧挨<a，b>之前]是到达r_cor的概率，此r_cor跟随严格在达到<a，b>弧之前发生的各弧(在明显的越过中)；P[紧挨<a，b>之后|已到达<a，b>]是达到r_cor的概率，此r_cor跟随严格地在<a，b>弧之后发生的各弧，假定S_KB已达到<a，b>弧；P[紧挨a之后]是达到r_cor的概率，此r_cor跟随严格在节点a之后发生的弧。

例如，应用图2中的KB₀，找出带有错误节点“A”的a和带有错误节点“E”的b。那么，P[紧挨<a，b>之前]是这样的概率：或者是(1)T_Z，T_A和T_C都成功，并且正确修补为r_c，或者是(2)T_Z，T_A和T_D都成功，T_C失败，正确修补为r_D。这里，P[紧挨<a，b>之后|已到达<a，b>]为0，因为这是严格地在达到并越过<a，b>≡<A，E>之后达到A下的后继节点的概率。(注意E没有在A之下的“左边的兄弟”)。最后，P[紧挨a之后]是这样的概率：T_A失败，T_B成功，及或者T_E成功，正确修补为r_E，或者T_E失败，T_F成功，正确修补为r_F。

类似地，

acc(KB′，<π，r_cor>)＝P[紧挨<a，b>之前]

+τ[<a，b>]×P[紧挨<a，b>之后|已到达<a，b>]

+τ[a](1-p′(a))×P[紧挨a之后]减去这些量，可以发现：diff′(Delete_a，b，<π，r_cor>)＝τ[<a，b>]{[p′(b)×P′]-ρ(b)}其中P′＝P[紧挨<a，b>之后|已到达<a，b>]。唯一剩下的问题是计算此P′：假定b是a的第m个子点，并且a有K≥m个子点，{a₁，...，a_m＝b，a_m+1，...，a_k}这里，P′＝∑^k _l＝m+lτ[<a，a₁>]×ρ(a₁)/τ[<a，b>]。注意，计算此量所需的时间由K限制，K为节点a中的子点数。

为计算diff′(θ，C)，其中θ为一个“增加链接”变换。令KB′＝Add_a，b，i(KB)是通过给KB增加一个链接而产生的层。此链接使b成为a的第i个子点。如前相同，acc(KB′，<π，r>)＝acc(KB，<π，r>)，只要π(t(a))＝-或π(t(b))＝-，因此，我们将仅考虑π(t(a))∈{+，？}和π(t(b))∈{+，？}。

假定在原始层KB中的第i个子点是n_i；注意它在KB′中是第i+1个子。(如果在KB中仅有i-1个子，则假定此n_i是退化(degenerate)节点，此节点立即导致r_⊥修补。)那么，

acc(KB，<π，r_cor>)＝P[紧挨<a，n_i>之前]

+τ[<a，n_i>]×ρ[紧挨<a，n_i>之后|已到达<a，n_i>]

+τ[a](1-p′(a))×P[紧挨a之后]且，acc(KB′，<π，r_cor>)＝P[紧挨<a，n_i>之前]

+τ[<a，n_i>]×ρ(b)

+τ[<a，n_i>](1-p′(b))P[紧挨<a，n_i>之后|已到达<a，n_i>]

+τ[a](1-p′(a))P[紧挨a之后]

其意味着

diff′((Add_{a，b，i，c})＝τ[<a，n_i>]×(ρ(b)p′(b)×P′(b)[紧挨<a，n_i>之后|已到达<a，n_i>]

其中再次P[紧挨<a，n_i>之后|已到达<a，n_i>]＝

∑^k _l＝i+1θ[<a，a₁>]×ρ(a₁)θ[<a，n_i>]。

当然，此方法是基于前面所述的“部分求值”法。见A_CCKB^*子例程中的描述。特别是，如前所述，当考虑普通DAG结构的层次时，计算正确精度分值是很困难的，基于这种观察，完成修正是以牺牲效率为代价的。观察这些情况，可以发现潜在的问题：增加一个新链接很容易产生一个包含在层中的新DAG事例，此情况反过来可能引起计算产生不正确的答案。例如，考虑KB_before层，(如图5所示)，并设KB_after＝Add_A，B，1(KB_before)包括从A到B的链接，此链接使B成为A的第一个子。

现在考虑一个带标记情况C<π₂，r_B>，其中π₂＝{T_A/+，T_C/+，T_B/？，T_D/+}，并且正确修补为r_B。令p_B＝p(T_B)是在节点B的测试T_B成功的概率。显然acc(KB_before，C)＝p_B，并且，正确答案是acc(KB_affer，C)＝p_B。然而，AccKB^*(A，π₂，r_B)会产生不正确的答案p_B+(1-p_B)×p_B。(见前面，对一般DAG情形计算正确的答案是NP-hard)。因此，如果我们应用A_CCKB来产生精度分值，则

diff′(Add_{A，B，1，C})＝[p_B+(1-p_B)×p_B]-p_B＝(1-p_B)×p_B；

因为此值不大于0，所以这种变换看起来是一个好方法。

然而，这种变换对此事例并不应该是一个好方法，有一种简单的方法修正这种特殊误差。这里，有必要知道：S_KBafter可达到C的唯一途径是测试T_B失败。因此，在对B后的层部分计算精度分值时，有必要只传播这样的信息：达到C表示T_B失败。

既然一般情况下即使正确计算此值也是NP-hard，所以我们很容易提出这种特定的公共情形。将KB中的每个节点n与节点上产生的所有测试的集合联系起来，这样，AllTests(A)＝{T_A，T_B，T_C，T_D}，AllTests(C)＝{T_C，T_B，T_D}，等。现在，当增加一个新链接时，此处是在A下，在D_ELTAD_ELTA计算diff′(Add_{A，B，1，c})值之前增加一个具有测试T_B的B，则它先经过新父(与该变换相关)A的其他子，并潜在地重新计算这些子的ρ值，这里给定如果T_B测试失败，则S_KBafter将仅达到这些子的新约束。为此，D_ELTAD_ELTA先将测试T_B与C的AllTests(·)表中的测试进行比较。如果T_B∈AllTests(C)，则D_ELTAD_ELTA就直接使用ρ(C)；不需要其他工作。然而注意，这里T_B∈AllTests(C)，在稍加修改的带标记事例C<π₂，r>的上下文，D_ELTAD_ELTA将因此重新计算ρ(C)，其中π₂包括赋值T_B/-：因此π₂＝{T_A/+，T_C/+，T_B/-，T_D/+}。在此新赋值之下，ρ(B)＝0，即有ρ(C)＝0。故此，ρ(A)＝acc(Add_{A，B，1，c})＝ρ_B象所希望的那样。

下面描述如何处理“移动链接”变换。为处理KB′＝Move_{par，par2，n，i}(KB)，注意KB′＝Add_par2，n，i(KB₁)其中KB₁＝Delete_par1，n(KB)。因此，diff′(Move_{par，par2，n，i，c})＝acc(Move _{par，par2，n，i}(KB)，c)-acc(KB，c)＝(acc(Add_par2，n，i(KB₁)，c)-acc(KB₁，c)+(acc(KB₁，c)-acc(KB，c))＝diff′^KB1(Add_{par2，n，i，c})+diff′^KB(KB(Delete_par1，n，c))其中每项已于前描述，并且上标标示出其所属层。

下面描述“交换-链接变换”Switch_parn1，n2：应用n1＝child(par，i₁)及n2＝child(par，i₂)，注意Switch_parn1，n2(KB)＝Move_{par，par，n1，i2}(KB₁)其中KB₁＝Move_{par，par，n2，i1}(KB)，(这里，如果|i₁-i₂|＝1，则忽略第一变换Move_{par，par，n1，i2}(KB₁))。从而，diff′((Switch_{par，n1，n2，c})＝acc(Switch_{par，n1，n2}(KB)，c)-acc(KB，c)＝

(acc(Move_{par，par，n1，i2}(KB₁)，c)-acc(KB₁，c))+(acc(KB₁，c)-acc(KB，c)＝diff′^KB1(Move _{par，par，n1，i2})，c)+diff′^KB(Move _{par，par，n2，i1})，c)。

上述描述都隐含地假定在上述的方式中，基础的专家系统能越过错误层；特别是在达到一个修补时即停止。有些专家系统会允许用户“验证”所给修补能否有效工作，如果第一修补失败，则接下去继续要求变换修补。这就叫“修补后验证”(VAR)，本发明还能对使用VAR的理论给出适当的理论修正。

本发明并不局限于以上公开的软件配置或操作过程，本发明包括落在所附权利要求书范围内的所有改变及其变化形式。Procedure E_VALKB(KB：fault_hierarchy，

    π：problem_instance)：repairreturn(E_VALN_ODE(_ROOT(KB)，π))End E_VALKBProcedure E_VALN_ODE(n：node，

 π：(total)_problem_instance)：repairIf n  是一叶节点Then return(r(n))Else For i：＝1..k(n)

    n_i：＝child(n，i)

    Ifπ(t(n_i))＝+

    Then return(E_VALN_ODE(n_i，π))

   End For

   return(r_⊥)End E_VALNODE

                     表1Procedure A_CCN_ODE(n：node，

    π：(partial)_problem_instance，

    r：repair)：RealIf n 是一叶节点Then return(r(n)＝r？1：0)Else tot：＝0；reach_me＝1；

   For i：＝1..k(n)

    n_i：＝child(n，i)

    If_π(t(n_i))＝+

    Then tot+＝reach_me×

          A_CCN_ODE(n_i，π，r)

          return(tot)

    ElseIf π(t(n_i))＝？

           tot+＝reach_me×

             p′(n_i)×A_CCN_ODE(n_i，π，r)

           reach_me×＝1-p′(n_i)

    End For

    return(tot)End A_CCN_ODE

                          表2Procedure A_CCN_ODE ^*(n：node，

        π：(partial)_problem_instance，

        r：repair)：Real

  If n 是一叶节点

  Then return(r(n)＝r？1：0)

  Else tot＝0；reachme＝1；

   unknowns＝{}

   For i＝1..k(n)

    n_i＝child(n，i)

    If _π(t(n_i))＝+

    Then tot+＝reach_me

           × A_CCN_ODE ^*(n_i，π，r)

         return(tot)

    ElseIfπ(t(n_i))＝？

    Then If t(n_i)∈unknowns

      Then tot+＝reach_me

              × A_CCN_ODE ^*(n_i，π，r)

           return(tot)

    ElseIf t(n_i)

unknowns

      Then unknowns＝urnknowns∪t(n_i)

           tot+＝reach_me×p(n_i)×

               ACCNODE^*(n_i，π，r)

           reach_me×＝1-p(n_i)

    End For

 return(tot)

End A_CCN_ODE ^*

                        表3Procedure D_ELTAD_ELTA(KB：fault_hierarchy，

C：set_of_problem_instances)：fault_hierarchy；Q：＝{}reminsts：＝|C|； $\mathrm{Err}:={\mathrm{\&Sigma;}}_{c_i\&Element;C}(1-\mathrm{acc}(\mathrm{KB},c))$ s^*：＝0；For <π，r> in CQE_C_OMPUTER_HOT_AU(KB，π，r)；For θ in GoodThetasIf(RT_P(s，Err)

      &&RT_M(s，rem_insts，s^*))

 s′：＝s+QE_D_IFF(KB，θ)；

 Q：＝R_EPLACE(Q，θ，s′)；End ForErr：＝Err-(1-acc(KB，<π，r>))；<θ^*，s^*>：＝B_EST(Q)；End ForIf(s^*＞0)

    return(D_ELTAD_ELTA(θ^*(KB)，C))Else

    return(KB)End D_ELTAD_ELTA

                     表4-1Procedure B_EST(Q：transform_score_pairs)：

      transform_score；bsfs：＝-999999；bsf_θ：＝NoOp；While(Q not empty)<θ，s>：＝FIRST(Q)；Q：＝REST(Q)If(s＞bsf_s)

bsf_s＝s；bsf_θ＝θEnd Whilereturn(<bsf_θ，bsf_s>)；End B_EST

Procedure R_EPLACE(

          Q：transform_score_pairs，

          θ：transform，s：Real)：

          transform_score_pairs；

 Q′＝Q

 While(Q′not empty)

 <θ′，s′>：＝FIRST(Q′)；Q′：＝REST(Q′)

 If (θ′＝θ)

  Replace 2nd part of<θ′，s′>with s

  Return(Q)

End While

return(Q∪<θ，s>)；End R_EPLACE

                        表4-2Procedure RT_P(s：Real，Err：Real)：boolean；return(s＞-Err)；End RT_PProcedure RT_M(s：Real，rem_insts：Int，

      s^*：Real)：boolean；return(s＞s^*-rem_insts)；End RT_M

                     表5Procedure RT_I_E_LIGIBLE(KB：fault_hierarchy，

 <π，r>：training_example)：

 list_of_transformationsN：＝append(RT_IA_DD(KB，<π，r>)，

          RT_ID_ELETE(KB，(π，r>)，

          RT_IM_OVE(KB，<π，r>)，

          RT_IS_WITCH(KB，<π，r>))return(N)End RT_I_E_LIGIBLEProcedure G_OODN_ODE(n：node，

 π：problem_instance)：booleanreturn(τ(n)＞0&&π(t(n))∈{+，？})End G_OODN_ODEProcedure I_SA_NCESTOR(n₁，n₂)If (l(n₂)＝0)Then return(FALSE)Else for i：＝1..l(n₂)p₂：＝parent(n₂，i)If((n₁＝p₂)∨I_SA_NCESTOR(n₁，p₂))Then return(TRUE)endforreturn(FALSE)End I_SA_NCESTOR

                        表6-1Procedure RT_IA_DD(KB：fault_hierarchy，

 <π，r>：training_example)：

 list_of_transformationsN：＝{}for p∈AllNodes(KB)Such that

  k(p)≥1 and GoodNode(p，π)for c∈AllNodes(KB) such that

      c≠p and π(c)∈{+，？}

  If(child_p(p，c)

       &&IsAncestor(c，p))

  Then for j：＝1..(k(p)+1)

   N：＝append(N，ADD(p，c，j))

   endfor；endfor；endforreturn(N)End RT_IA_DD

                         表6-2Procedure RT_ID_ELETE(KB：fault_hierarchy，

 <π，r>：training_example)：

 list_of_transformationsN：＝{}for p∈AllNodes(KB)Such that

    k(p)>0 and GoodNode(p)for j：＝1..k(p)

 If GoodNode(child(p，j))

 Then N：＝append(N，Delete(p，child(p，j)))endforendforreturn(N)End RT_ID_ELFTE

                         表6-3Procedure RT_IM_OVE(KB：fault_hierarchy，

 <π，r>：training_example)：

 list_of_transformationsN：＝{ }for p∈AllNodes(KB)Such that

    k(p)≥2 and GoodNode(p，π)for i：＝1..k(p)

 If GoodNode(child(p，i)，π) Then

   for j：＝1..k(p)；j≠i

     N：＝append(N，MOVE(p，p，child(p，i)，i，j))

   endfor；endfor：endfor

                           表6-4for from_par∈AllNodes(KB)Such that

    k(from_par)＞0for to_par∈AllNodes(KB)such that

   to_par≠from_par and k(to_par)＞O

   and(GoodNode(to_par，π)∨

           GoodNode(from_par，π))for i：＝1..k(from_par)

 ch：＝child(from_par，i)

 If(GoodNode(ch，π)

       &&IsAncestor(ch，to_par))

 Then for j：＝1..k(to_par)+1

  N：＝append(N，

        MOVE(from_par，to_par，ch，i，j))

 endfor；endfor；endfor；endforreturn(N)End RT_IM_OVE

                       表6-5Procedure RT_IS_WITCH(KB：fault_hierarchy，

      <π，r>：training_example)：

      list_of_transformationsN：＝{}for p∈AllNodes(KB) Such that

    k(p)≥2 and GoodNode(p，π)for i：＝1..(k(p)-1)

 If GoodNode(child(p，i)，π)

 Then for j：＝i..k(p)

  If GoodNode(child(p，j)，π)

  Then N：＝append(N，

      SWITCH(p，child(p，i)，child(p，j)))

 endfor；endfor；endforreturn(N)End RT_IS_WITCH

                     表6-6

Claims (11)

1、一种高效数据驱动理论修正系统，包括：

高效学习装置；

与所述高效学习装置相接口并能接受本领域专家的输入的专家系统装置；

与所述专家系统装置连接的编译装置；

与所述编译装置相连接的现场用户输入装置；

连接于所述现场用户输入装置和上述高效学习装置之间的会话转录装置。

2、如权利要求1所述的高效数据驱动理论修正系统，其中高效学习装置包括：

RT_I-E_LIGBLE装置；

C_OMPUTER_HOT_AU装置；

RT_P装置；

RT_M装置。

3、如权利要求2所述的高效数据驱动理论修正系统，其中RT_I-E_LIGBLE装置包括：

多个修正操作符，所述多个操作符中的每一个上述专家系统装置中的初始知识库上工作并高效地产生一个修正的知识库，所有修正的知识库的集合是该初始知识库的邻域。

4、如权利要求3所述的高效数据驱动理论修正系统，其中的多个修正操作符包括：

增加操作符(RT_IA_DD)；

删除操作符(RT_ID_ELETE)；

移动操作符(RT_IM_OVE)；

交换操作符(RT_IS_WITCH)。

5、如权利要求3所述的高效数据驱动理论修正系统，其中：

所述的多个修正操作符移动穿过错误层的间隔，并且每个所述多个操作符高效地将一层映射成稍有不同的层。

6、由计算机实现的高效数据驱动理论修正系统，包括以下步骤：

应用与专家系统装置接口的学习装置，该专家系统装置与编译装置相连，该编译装置与现场用户输入装置相连，该现场用户输入装置与会话转录装置连接，会话转录装置与所述的学习装置相连，其中使用学习装置包括以下步骤：

使用RT_I_E_LIGIBLE子例程；

使用C_OMPUTER_HOT_AU子例程；

使用RT_P子例程；

使用RT_M子例程。

7、如权利要求6所述的由计算机实现的高效数据驱动理论修正系统，其中使用RT_I_E_LIGBLE子例程包括以下步骤：

使用多个修正操作符，每个所述操作符在专家系统装置中的知识库上高效地工作，并产生包括一已修正的知识库的邻域。

8、如权利要求7所述的由计算机实现的高效数据驱动理论修正系统，其中使用多个修正操作符包括以下步骤：

使用一个增加操作符；

使用一个删除操作符；

使用一个移动操作符；

使用一个交换操作符。

9、如权利要求7所述的由计算机实现的高效数据驱动理论修正系统，其中使用多个修正操作符包括下面步骤：

高效地移动穿过错误层的间隙，每个所述多个修正操作符将一个层映射成稍有不同的层。

10、由计算机实现的高效数据驱动理论修正系统，包括：

高效的学习装置；

与所述高效的学习装置相接口并能接受本领域专家输入的专家系统装置；

与所述专家系统装置相连的编译装置；

与所述编辑装置相连的现场用户输入装置；

连接于所述现场用户输入装置和高效学习装置之间的会话转录装置，其中所述高效学习装置包括：

RT_I_E_LIGIBLE装置；

C_OMPUTER_HOT_AU装置；

RT_P装置；

RT_M装置。

11、如权利要求10所述的由计算机实现的高效数据驱动理论修正系统，其中RT_I_E_LIGIBLE装置包括：

一个增加操作符(RT_IA_DD)；

一个删除操作符(RT_ID_ELETE)；

一个移动操作符(RT_IM_OVE)；

一个交换操作符(RT_IS_WTTCH)。

Images