机器学习（四）：分而治之（下）——规则学习

• 理解：

  规则分类使用的是独立而治之的探索法。通过确定训练数据中覆盖一个子案例的规则，然后从剩余的数据中分离出该区域。随着案例的增加，更多的数据子集会被分离，直到整个数据集都被覆盖，不再有案例残留。（可以理解为多个嵌套的if-else）。独立而治之算法又称为覆盖算法，规则成为覆盖规则。
  比如说，你在一群不同种类的动物中需要分开哺乳动物和非哺乳动物，你第一个规则可能是陆地动物，然后你发现青蛙也在这一类中，所以要细化规则，第二个规则就变成了在陆地行走且有尾巴，我们还可以定义额外的规则，这时候剩余的动物中你发现蝙蝠也是哺乳动物，所以添加了一条规则有皮毛，就把蝙蝠划分过来。这时候所有动物都被划分了——哺乳或非哺乳。
  这样就有三条规则：

  1. 如果在陆地行走且有尾巴，是哺乳动物
  2. 如果有皮毛，是哺乳动物
  3. 否则，不是哺乳动物。

- 单规则算法（1R）

运作方式：只根据案例的一个特征就划分该案例的类别，最后以投票的方式确定究竟是哪一个特征。还是说刚才动物分类的例子，如果只按照行走途径（海陆空）来划分哺乳非哺乳，导致两个错误（蝙蝠和青蛙），只按照皮毛来分，三个错误（猪，大象，犀牛）（这个例子中我们只知道案例的两个特征——行走途径和是否有皮毛），所以我们最终选择行走途径来划分是哺乳和非哺乳。
产生规则：
1.海洋或空中——非哺乳
2.陆地——哺乳

单一特征往往不能很好划分复杂的问题。

- RIPPER算法

运行方式：是规则学习多次迭代进化而来，一般有三步：生长，修剪，优化。生长时使用独立而治之，直到规则能够完全划分一个数据集，当增加一个指定规则而熵值不再减小，该规则需要立即修剪。最后用各种探索法进行规则优化。可以同时考虑多个属性，比如：会飞并且有皮毛的是哺乳动物。

部分代码：

> str(mushrooms)
'data.frame':   8124 obs. of  22 variables:
 $ type                    : Factor w/ 2 levels "1","2": 1 2 2 1 2 2 2 2 1 2 ...
 $ cap_shape               : Factor w/ 6 levels "b","c","f","k",..: 6 6 1 6 6 6 1 1 6 1 ...
 $ cap_surface             : Factor w/ 4 levels "f","g","s","y": 3 3 3 4 3 4 3 4 4 3 ...
 $ cap_color               : Factor w/ 10 levels "b","c","e","g",..: 5 10 9 9 4 10 9 9 9 10 ...
 $ bruises                 : Factor w/ 2 levels "f","t": 2 2 2 2 1 2 2 2 2 2 ...
 $ odor                    : Factor w/ 9 levels "a","c","f","l",..: 7 1 4 7 6 1 1 4 7 1 ...
 $ gill_attachment         : Factor w/ 2 levels "a","f": 2 2 2 2 2 2 2 2 2 2 ...
 $ gill_spacing            : Factor w/ 2 levels "c","w": 1 1 1 1 2 1 1 1 1 1 ...
 $ gill_size               : Factor w/ 2 levels "b","n": 2 1 1 2 1 1 1 1 2 1 ...
 $ gill_color              : Factor w/ 12 levels "b","e","g","h",..: 5 5 6 6 5 6 3 6 8 3 ...
 $ stalk_shape             : Factor w/ 2 levels "e","t": 1 1 1 1 2 1 1 1 1 1 ...
 $ stalk_root              : Factor w/ 5 levels "?","b","c","e",..: 4 3 3 4 4 3 3 3 4 3 ...
 $ stalk_surface_above_ring: Factor w/ 4 levels "f","k","s","y": 3 3 3 3 3 3 3 3 3 3 ...
 $ stalk_surface_below_ring: Factor w/ 4 levels "f","k","s","y": 3 3 3 3 3 3 3 3 3 3 ...
 $ stalk_color_above_ring  : Factor w/ 9 levels "b","c","e","g",..: 8 8 8 8 8 8 8 8 8 8 ...
 $ stalk_color_below_ring  : Factor w/ 9 levels "b","c","e","g",..: 8 8 8 8 8 8 8 8 8 8 ...
 $ veil_color              : Factor w/ 4 levels "n","o","w","y": 3 3 3 3 3 3 3 3 3 3 ...
 $ ring_number             : Factor w/ 3 levels "n","o","t": 2 2 2 2 2 2 2 2 2 2 ...
 $ ring_type               : Factor w/ 5 levels "e","f","l","n",..: 5 5 5 5 1 5 5 5 5 5 ...
 $ spore_print_color       : Factor w/ 9 levels "b","h","k","n",..: 3 4 4 3 4 3 3 4 3 3 ...
 $ population              : Factor w/ 6 levels "a","c","n","s",..: 4 3 3 4 1 3 3 4 5 4 ...
 $ habitat                 : Factor w/ 7 levels "d","g","l","m",..: 6 2 4 6 2 2 4 4 2 4 ...
> mushrooms_jrip<-JRip(mushrooms$type~.,data = mushrooms)
> mushrooms_jrip
JRIP rules:
===========

(odor = f) => mushrooms$type=1 (2160.0/0.0)
(gill_size = n) and (gill_color = b) => mushrooms$type=1 (1152.0/0.0)
(gill_size = n) and (odor = p) => mushrooms$type=1 (256.0/0.0)
(odor = c) => mushrooms$type=1 (192.0/0.0)
(spore_print_color = r) => mushrooms$type=1 (72.0/0.0)
(stalk_surface_below_ring = y) and (stalk_surface_above_ring = k) => mushrooms$type=1 (68.0/0.0)
(habitat = l) and (cap_color = w) => mushrooms$type=1 (8.0/0.0)
(stalk_color_above_ring = y) => mushrooms$type=1 (8.0/0.0)
 => mushrooms$type=2 (4208.0/0.0)

Number of Rules : 9

> mushrooms_1r<-OneR(mushrooms$type~.,data=mushrooms)
> mushrooms_1r
odor:
    a   -> 2
    c   -> 1
    f   -> 1
    l   -> 2
    m   -> 1
    n   -> 2
    p   -> 1
    s   -> 1
    y   -> 1
(8004/8124 instances correct)

注：在r软件使用过程中，如果数据框里面的数据是字符类型，得转换成因子，因为大多数学习函数，以因子作为参数。