20、规则归纳算法自动设计的计算结果

规则归纳算法自动设计的计算结果

1. GGP 设计的规则归纳算法与人工设计算法的比较

在之前的实验中，我们比较了 GGP 系统在不同参数配置下进化出的规则归纳算法的结果，这有助于展示系统在交叉和变异率变化时的鲁棒性。但我们还不清楚这些自动设计的算法与一些知名的人工设计的规则归纳算法相比竞争力如何。

本次实验将 GGP 设计的规则归纳算法（GGP - RIs）与四种知名的规则归纳算法进行比较，分别是有序和无序版本的 CN2、Ripper 以及 C4.5Rules。其中，C4.5Rules 不遵循顺序覆盖方法，而 GGP - RIs 采用此方法，但由于 C4.5Rules 长期用于分类问题的基准测试，所以也将其纳入对比。

需要注意的是，当前语法版本未包含 Ripper 的所有组件，但包含了 CN2 两个版本的所有组件。也就是说，GGP 系统搜索的候选规则归纳算法空间包含 CN2，但不包含 C4.5Rules 或完整版本的 Ripper。

GGP - RIs	Cross/Mut	Better(worse)
	0.5/0.45	3(4)
	0.6/0.35	3(3)
	0.7/0.25	3(1)
	0.8/0.15	3(1)
	0.9/0.05	2(5)

从表 6.3 可以看出，除了 GGP - 0.9 产生的规则归纳算法在两个案例中取得更好结果外，其他 GGP - RIs 在三个案例中获得了比基线算法统计上显著更好的预测准确率。而在比基线算法差的结果数量上，变化范围从 1 到 5。使用 0.7 和 0.8 交叉率的 GGP 产生的 GGP - RIs 略优于其他，有三个统计上更好的结果和一个统计上更差的结果。

我们选择展示 GGP - 0.7（交叉率 0.7，变异率 0.25）的详细结果，因为其他参数配置产生的结果类似，且该配置将用于后续实验。

Dataset	GGP - RIs	OrdCN2	UnordCN2	Ripper	C45Rules
crx	77.46±3.8	80.16 ± 1.27	80.6 ± 0.93	84.37 ± 1.21	84.82 ± 1.53
heart - c	76.72±1.5	77.9 ± 1.96	77.54 ± 2.85	77.53 ± 1.1	74.2 ± 5.43
ionosphere	87.04±2.2	87.6 ± 2.76	90.52 ± 2.03	89.61 ± 1.75	89.06 ± 2.71
monks - 1	99.93±0.07	100 ± 0	100 ± 0	93.84 ± 2.93	100 ± 0
mushroom	99.98±0.02	100 ± 0	100 ± 0	99.96 ± 0.04	98.8 ± 0.06
promoters	78.98±2.93	81.9 ± 4.65	74.72 ± 4.86	78.18 ± 3.62	83.74 ± 3.46
segment	95.06±0.26	95.38 ± 0.28	85.26 ± 0.87	95.44 ± 0.32	88.16 ± 7.72
sonar	72.34±1.91	70.42 ± 2.66	72.42 ± 1.4	72.88 ± 4.83	72.4 ± 2.68
splice	88.68±0.31	90.32 ± 0.74	74.82 ± 2.94	93.88 ± 0.41	89.66 ± 0.78
wisconsin	95.58±0.74	94.58 ± 0.68	94.16 ± 0.93	93.99 ± 0.63	95.9 ± 0.56

从表 6.4 可以看出，GGP - RIs 在 segment 和 splice 数据集上比无序 CN2 准确率显著更好，在 mushroom 数据集上比 C4.5Rules 准确率显著更好。而在 splice 数据集上，GGP - RIs 的准确率显著低于 Ripper。这是因为 Ripper 在 splice 数据集上的准确率远高于其他基线算法，且 GGP - RIs 的搜索空间中未包含 Ripper 的所有算法组件。

总体而言，GGP - RIs 很容易超越那些在某些数据集上竞争力较弱的分类器。同时，由于 GGP 系统的搜索空间包含无序和有序 CN2，所以 GGP - RIs 的预测准确率不应显著低于 CN2 的任何一个版本，实验结果也确实如此。

2. GGP - RIs 与人工设计规则归纳算法的差异程度

我们的主要目标是自动设计规则归纳算法，使其在新数据集上与人工设计的算法相比具有有竞争力的预测准确率。上一节表明可以自动生成有竞争力的规则归纳算法，但它们与知名的人工设计算法有多相似呢？GGP - RIs 是否在人工设计算法的某些方面有创新？

下面介绍 CN2 和 Ripper 算法的规则归纳方式，并将它们与发现的 GGP - RIs 进行比较，C4.5Rules 不参与此比较，因为它不遵循顺序覆盖方法。

• 有序 CN2 算法

RuleList = /0
repeat
    bestRule = an empty rule
    candidateRules = /0
    candidateRules = candidateRules ∪ bestRule
    while candidateRules ̸= /0 do
        for each candidateRule CR do
            newCandidateRules = /0
            Add 1 condition at a time to CR
            Evaluate CR using the Laplace estimation
            if CR is significant then
                if CR better than bestRule then
                    bestRule = CR
                    newCandidateRules = newCandidateRules ∪ CR
            candidateRules = 5 best rules selected from newCandidateRules
    RuleList = RuleList ∪ bestRule
    Remove from the training set all examples covered by bestRule
until all examples in the training set are covered

有序 CN2 算法从空条件开始生成规则，每次添加一个条件，使用拉普拉斯估计评估规则，并选择最好的五个规则进行细化。规则只有在通过统计显著性测试时才被视为最佳规则候选，但 CN2 的默认设置忽略了此测试。该算法在训练集中有未覆盖的示例时会不断插入新规则。

无序 CN2 算法与有序 CN2 算法的主要区别在于，它添加了一个外循环，根据数据中的类别数量重复有序 CN2 算法的过程。在应用无序 CN2 生成的规则集到测试集的未见示例时，如果有多个预测不同类别的规则覆盖同一个示例，则通过统计每个类别的覆盖示例数量来决定该示例的类别。

• Ripper 算法

Let m be the number of classes
Let p and n be the number of positive and negative examples covered by a rule
Sort classes in ascendent order, C1,...,Cm, according to their number of examples
RuleSet = /0
for i = 1 to m−1 do
    Positive = examples from Ci
    Negative = examples from remaining classes
    RuleSet’ = /0
    repeat
        Divide the training data in Grow and Prune
        R = an empty rule
        while R covers negative examples do
            newCandidateRules = /0
            newCandidateRules = Add 1 condition at a time to R
            Evaluate newCandidateRules using information gain in Grow
            R = best rule in newCandidateRules
            R’ = Rule produced when removing last condition from R
            Define pruneEval(x) of a rule x as (p−n)/(p+n)
            while pruneEval(R’) > pruneEval(R) in Prune do
                R = R’
                R’ = Rule produced when removing last condition from R
        RuleSet’ = RuleSet’ ∪ R
        Remove examples covered by R from training set
    until Positive ̸= /0 OR MDL of RuleSet’ is d bits > the smallest MDL found so far
    RuleSet = RuleSet ∪ Optimized RuleSet’
    Remove all examples covered by RuleSet’ from the training set
Make class Cm the default class

Ripper 算法更为复杂，它按类别数量对类别进行排序，为每个类别构建一个规则列表，将当前类别与数据集中的其他类别分开。它分为三个阶段：首先通过每次添加一个条件来生长一个不覆盖负示例的规则，使用信息增益准则评估候选规则；找到不覆盖负示例的规则后，通过移除一组最终条件进行预剪枝；剪枝阶段使用公式 (p - n)/(p + n) 评估新规则；规则插入规则集直到规则集的最小描述长度（MDL）大于一个参数 d 加上到目前为止找到的最小 MDL 的大小，或者没有未覆盖的正示例。完成一个类别的规则集后，进入优化阶段，根据 MDL 启发式对每个规则进行分析、替换或修订。

当前语法版本未使用 MDL 准则来停止生成规则，也未实现 Ripper 优化过程的所有步骤。

下面介绍一个 GGP - RIs 的示例：

RuleList = /0
repeat
    bestRule = an empty rule
    candidateRules = /0
    candidateRules = candidateRules ∪ bestRule
    while candidateRules ̸= /0 do
        for each candidateRule CR do
            newCandidateRules = /0
            if size(CR) < 2 then
                Add 1 condition at a time to CR
            else
                Add 2 conditions at a time to CR
            Evaluate CR using the Laplace estimation
            if CR better than bestRule then
                bestRule = CR
                newCandidateRules = newCandidateRules ∪ CR
            candidateRules = 2 best rules selected from newCandidateRules
            if accuracy(bestRule) < 0.8 then break
            else RuleList = RuleList ∪ bestRule
            Remove from the training set all examples covered by bestRule
until all examples in the training set are covered

该算法的主要创新点在于根据规则中条件的数量来决定每次添加一个还是两个条件。一般来说，人工设计的规则归纳算法没有这种灵活性，它们在算法运行过程中通常使用固定数量的条件添加到当前规则。这种灵活策略先每次添加一个条件创建规则，当规则中的条件数量达到两个时，开始每次添加两个条件。虽然每次添加两个条件比每次添加一个条件不那么贪婪（可能更有效），但这种策略违反直觉，因为随着规则中条件数量的增加，规则的统计支持度（满足其前提的示例数量）会降低，直观上找到一个具有良好预测能力的属性 - 值对比找到两个属性 - 值的组合更容易。

Dataset	GGP - RIs	OrdCN2	UnordCN2	Ripper	C45Rules
crx	79.44±2.24	80.16 ± 1.27	80.6 ± 0.93	84.37 ± 1.21	84.82 ± 1.53
balance - scale	79.14±4.93	82.08 ± 1.38	79.48 ± 1.7	81.12 ± 0.88	78.84 ± 1.7
heart - c	76.6±8.01	77.9 ± 1.96	77.54 ± 2.85	77.53 ± 1.1	74.2 ± 5.43
ionosphere	86.94±5.41	87.6 ± 2.76	90.52 ± 2.03	89.61 ± 1.75	89.06 ± 2.71
monks - 1	99.64±0.8	100 ± 0	100 ± 0	93.84 ± 2.93	100 ± 0
mushroom	100±0	100 ± 0	100 ± 0	99.96 ± 0.04	98.8 ± 0.06
promoters	83.92±7.34	81.9 ± 4.65	74.72 ± 4.86	78.18 ± 3.62	83.74 ± 3.46
segment	94.54±1.23	95.38 ± 0.28	85.26 ± 0.87	95.44 ± 0.32	88.16 ± 7.72
sonar	73.12±7.94	70.42 ± 2.66	72.42 ± 1.4	72.88 ± 4.83	72.4 ± 2.68
splice	90.1±1.08	90.32 ± 0.74	74.82 ± 2.94	93.88 ± 0.41	89.66 ± 0.78
wisconsin	96.2±1	94.58 ± 0.68	94.16 ± 0.93	93.99 ± 0.63	95.9 ± 0.56

从表 6.5 可以看出，尽管该算法的策略违反直觉，但与基线（人工设计）算法相比，它大致重现了表 6.4 的结果。它在七个比较案例中统计上具有更好的准确率，在三个比较案例中统计上具有更差的准确率。

总体而言，大多数生成的算法与 CN2 非常相似。这是因为 UCI 数据集在机器学习社区中非常流行，许多规则归纳算法最初设计或后来修改都是针对这些数据集。这表明 CN2 在 UCI 存储库中的一组数据集上的平均预测准确率方面实际上是一个很好的算法。同时，GGP 系统生成的规则归纳算法表明，基本顺序覆盖伪代码有许多其他变体可以获得与 CN2、Ripper 或 C4.5Rules 相当的准确率。

3. 元训练集变化的影响

自动进化规则归纳算法时，GGP 系统需要两组元素：传统遗传编程（GP）算法的参数，如种群大小、代数、交叉和变异率；以及元训练集中使用的数据集数量和具体数据集。

元训练集中的数据集用于计算 GGP 系统个体（候选规则归纳算法）的适应度，因此改变这些数据集会显著影响 GGP 个体的适应度值，进而影响最终生成的规则归纳算法。

本部分研究改变元训练集中数据集数量的影响，将元训练集中的数据集数量分别设置为 6、8、12 和 14（相应地，元测试集中的数据集数量为 14、12、8 和 6）。选择移除或添加哪些数据集的依据与之前相同，即执行时间。在所有实验中，GGP 系统的参数值固定，交叉率和变异率分别为 0.7 和 0.25。

Dataset	GGP - RIs	OrdCN2	UnordCN2	Ripper	C45Rules
crx	81.07±0.9	80.16 ± 1.27	80.6 ± 0.93	84.37 ± 1.21	84.82 ± 1.53
heart - c	77.18±0.9	77.9 ± 1.96	77.54 ± 2.85	77.53 ± 1.1	74.2 ± 5.43
hepatitis	82.51±1.89	81.94 ± 5.02	83.34 ± 1.83	86.03 ± 1.14	83.36 ± 0.9
ionosphere	87.33±2.17	87.6 ± 2.76	90.52 ± 2.03	89.61 ± 1.75	89.06 ± 2.71
monks - 1	100±0	100 ± 0	100 ± 0	93.84 ± 2.93	100 ± 0
monks - 3	96.89±0.78	97.46 ± 0.74	99.1 ± 0.4	98.54 ± 0.46	94 ± 4.89
mushroom	100±0	100 ± 0	100 ± 0	99.96 ± 0.04	98.8 ± 0.06
pima	63.86±3.16	69.34 ± 2.13	74.6 ± 0.38	73.91 ± 1.65	71.04 ± 1.67
promoters	81.61±3.08	81.9 ± 4.65	74.72 ± 4.86	78.18 ± 3.62	83.74 ± 3.46
segment	95.14±0.39	95.38 ± 0.28	85.26 ± 0.87	95.44 ± 0.32	88.16 ± 7.72
sonar	73.12±1.44	70.42 ± 2.66	72.42 ± 1.4	72.88 ± 4.83	72.4 ± 2.68
splice	88.76±0.38	90.32 ± 0.74	74.82 ± 2.94	93.88 ± 0.41	89.66 ± 0.78
wisconsin	95.53±0.74	94.58 ± 0.68	94.16 ± 0.93	93.99 ± 0.63	95.9 ± 0.56
zoo	92.89±0.87	92.64 ± 1.33	92.52 ± 2.21	89.47 ± 1.66	92.56 ± 1.45

Dataset	GGP - RIs	OrdCN2	UnordCN2	Ripper	C45Rules
crx	80.57±0.9	80.16 ± 1.27	80.6 ± 0.93	84.37 ± 1.21	84.82 ± 1.53
heart - c	76.38±0.82	77.9 ± 1.96	77.54 ± 2.85	77.53 ± 1.1	74.2 ± 5.43
ionosphere	86.75±2.12	87.6 ± 2.76	90.52 ± 2.03	89.61 ± 1.75	89.06 ± 2.71
monks - 1	99.82±0.18	100 ± 0	100 ± 0	93.84 ± 2.93	100 ± 0
mushroom	100±0	100 ± 0	100 ± 0	99.96 ± 0.04	98.8 ± 0.06
pima	68.6±0.94	69.34 ± 2.13	74.6 ± 0.38	73.91 ± 1.65	71.04 ± 1.67
promoters	80.23±3.29	81.9 ± 4.65	74.72 ± 4.86	78.18 ± 3.62	83.74 ± 3.46
segment	94.99±0.41	95.38 ± 0.28	85.26 ± 0.87	95.44 ± 0.32	88.16 ± 7.72
sonar	72.73±1.74	70.42 ± 2.66	72.42 ± 1.4	72.88 ± 4.83	72.4 ± 2.68
splice	89.04±0.48	90.32 ± 0.74	74.82 ± 2.94	93.88 ± 0.41	89.66 ± 0.78
wisconsin	95.76±0.75	94.58 ± 0.68	94.16 ± 0.93	93.99 ± 0.63	95.9 ± 0.56
zoo	92.65±1.12	92.64 ± 1.33	92.52 ± 2.21	89.47 ± 1.66	92.56 ± 1.45

Dataset	GGP - RIs	OrdCN2	UnordCN2	Ripper	C45Rules
crx	78.12±3.37	80.16 ± 1.27	80.6 ± 0.93	84.37 ± 1.21	84.82 ± 1.53
heart - c	75.08±2.44	77.9 ± 1.96	77.54 ± 2.85	77.53 ± 1.1	74.2 ± 5.43
mushroom	100±0	100 ± 0	100 ± 0	99.96 ± 0.04	98.8 ± 0.06
promoters	81.05±2.94	81.9 ± 4.65	74.72 ± 4.86	78.18 ± 3.62	83.74 ± 3.46
segment	95.11±0.43	95.38 ± 0.28	85.26 ± 0.87	95.44 ± 0.32	88.16 ± 7.72
sonar	73.69±2.4	70.42 ± 2.66	72.42 ± 1.4	72.88 ± 4.83	72.4 ± 2.68
splice	89.3±0.39	90.32 ± 0.74	74.82 ± 2.94	93.88 ± 0.41	89.66 ± 0.78
wisconsin	95.9±0.6	94.58 ± 0.68	94.16 ± 0.93	93.99 ± 0.63	95.9 ± 0.56

Dataset	GGP - RIs	OrdCN2	UnordCN2	Ripper	C45Rules
crx	78.12±3.37	80.16 ± 1.27	80.6 ± 0.93	84.37 ± 1.21	84.82 ± 1.53
heart - c	75.08±2.44	77.9 ± 1.96	77.54 ± 2.85	77.53 ± 1.1	74.2 ± 5.43
mushroom	100±0	100 ± 0	100 ± 0	99.96 ± 0.04	98.8 ± 0.06
promoters	81.05±2.94	81.9 ± 4.65	74.72 ± 4.86	78.18 ± 3.62	83.74 ± 3.46
segment	95.11±0.43	95.38 ± 0.28	85.26 ± 0.87	95.44 ± 0.32	88.16 ± 7.72
sonar	73.69±2.4	70.42 ± 2.66	72.42 ± 1.4	72.88 ± 4.83	72.4 ± 2.68
splice	89.3±0.39	90.32 ± 0.74	74.82 ± 2.94	93.88 ± 0.41	89.66 ± 0.78
wisconsin	95.9±0.6	94.58 ± 0.68	94.16 ± 0.93	93.99 ± 0.63	95.9 ± 0.56

分析这些结果并与使用 10 个数据集进行训练的结果（表 6.4）对比，发现所有结果具有一致性：GGP - RIs 在特定数据集上比基线算法准确率显著更好或更差的情况保持不变。

当元训练集包含 6 和 8 个数据集时（表 6.6 和 6.7），GGP - RIs 的准确率与基线算法相比总体有所下降。具体来说，在这两个表中，GGP - RIs 仅在三个案例中显著优于基线算法，而在五个案例中情况相反，总体得分 - 2，结果略为负面。

当元训练集包含 12 和 14 个数据集时（表 6.8 和 6.9），GGP - RIs 的得分分别为 +2 和 +1，结果略为正面。

综上所述，本部分的结果与使用 10 个数据集进行元训练和元测试的结果没有显著差异。原本我们认为减少元训练集中的数据集数量可能会导致 GGP 系统生成的算法在元测试集上的性能变差，但总体情况并非如此，只有少数例外。

总结

• 算法性能比较 ：GGP 设计的规则归纳算法（GGP - RIs）在与人工设计的规则归纳算法（如 CN2、Ripper、C4.5Rules）的比较中，整体表现出一定的竞争力。在一些数据集上，GGP - RIs 能够显著超越竞争力较弱的分类器，且其搜索空间包含 CN2 的情况下，预测准确率不会显著低于 CN2 的任何版本。
• 算法差异分析 ：大多数 GGP - RIs 与 CN2 较为相似，这表明 CN2 在 UCI 数据集上的平均预测准确率表现良好。不过，部分 GGP - RIs 也展现出创新策略，如根据规则中条件数量灵活添加条件，虽然这种策略违反直觉，但在一些情况下能取得与基线算法相当的准确率。
• 元训练集影响 ：改变元训练集中的数据集数量会对 GGP - RIs 的性能产生一定影响。总体而言，元训练集包含 12 和 14 个数据集时，GGP - RIs 的表现略优于包含 6 和 8 个数据集的情况，但与使用 10 个数据集时的结果无显著差异。

在未来的研究中，可以进一步探索如何优化 GGP 系统的参数配置和语法规则，以生成更具创新性和竞争力的规则归纳算法。同时，可以考虑扩大数据集的范围，提高算法在不同类型数据集上的泛化能力。