【大数据】关于呆板学习----------规则学习

一、基本概念

   注：本博文所含流程图引用知乎博主 deephub
  1. 规则学习

• 规则学习是从数据中主动提取出能表示数据规律的规则的呆板学习方法。这些规则通常以 if-then 形式出现，可用于分类、猜测和决策等使命。比方：if (feature1 > 5) and (feature2 == 'value') then class = 'A'。
  
• 规则学习的优点在于规则具有较好的可解释性，易于理解和推理，适用于对可解释性要求较高的领域，如医疗、金融等。
  

二、序贯覆盖

1. 基本头脑

• 序贯覆盖是一种常见的规则学习策略，其焦点头脑是逐条天生规则，并在训练集上覆盖尽大概多的正例，同时尽量避免覆盖反例。具体步骤如下：
  
  
  • 从空规则开始，不断添加条件，使规则能覆盖更多正例。
    
  • 当规则覆盖了充足多的正例或达到肯定的性能指标时，将其添加到规则集中。
    
  • 从训练集中移除该规则覆盖的正例，并重复上述步骤，直到满足终止条件（如达到预设的规则数量或性能要求）。
    
  
  

一、示例配景

• 这是一个判断“好瓜”的规则学习过程，通过对瓜的差别特征进行分析和筛选，来天生判断好瓜的规则。
  
  
  
  

二、具体内容

• 第一轮候选集：
  
  
  
  • 色泽 = 青绿（2/4）：表示在全部样本中，色泽为青绿的瓜有2个是好瓜，总共有4个色泽为青绿的瓜。
    
  • 色泽 = 乌黑（3/4）：色泽为乌黑的瓜有3个是好瓜，共4个乌黑的瓜。
    
  • 根蒂 = 蜷缩（3/5）：根蒂蜷缩的瓜有3个是好瓜，总共有5个根蒂蜷缩的瓜。
    
  • 敲声 = 浊响（4/6）：敲声为浊响的瓜有4个是好瓜，共6个敲声浊响的瓜。
    
  • 纹理 = 清晰（4/6）：纹理清晰的瓜有4个是好瓜，共6个纹理清晰的瓜。
    
  • 脐部 = 凹陷（3/4）：脐部凹陷的瓜有3个是好瓜，共4个脐部凹陷的瓜。
    
  • 触感 = 硬滑（3/6）：触感硬滑的瓜有3个是好瓜，共6个触感硬滑的瓜。
    
  
  
• 第二轮候选集：
  
  
  
  • 根蒂 = 蜷缩（2/2）：在经过第一轮筛选后，根蒂蜷缩的瓜中，有2个是好瓜，且此时只剩下2个根蒂蜷缩的瓜。
    
  • 敲声 = 沉闷（1/1）：敲声沉闷的瓜有1个是好瓜，此时只有1个敲声沉闷的瓜。
    
  • 纹理 = 稍糊（1/1）：纹理稍糊的瓜有1个是好瓜，此时只有1个纹理稍糊的瓜。
    
  • 脐部 = 凹陷（2/2）：脐部凹陷的瓜有2个是好瓜，此时只有2个脐部凹陷的瓜。
    
  • 触感 = 硬滑（2/2）：触感硬滑的瓜有2个是好瓜，此时只有2个触感硬滑的瓜。
    
  
  

三、最终规则

• 
  

   经过两轮之后产生单条规则：好瓜 ←（色泽 = 乌黑）∧（根蒂 = 蜷缩），即当瓜的色泽为乌黑且根蒂蜷缩时，判断为好瓜。
  四、相干知识点

   

• 此示例涉及到呆板学习中的规则学习，特殊是序贯覆盖策略。序贯覆盖是一种规则学习方法，它逐条天生规则，在每一轮中选择一个最优的规则条件，使得该规则能覆盖尽大概多的正例（好瓜），同时尽量少地覆盖反例（非好瓜）。
  
• 在这个过程中，通过计算每个特征值对应的正例覆盖率（如色泽 = 青绿的正例覆盖率为2/4），来选择最优的特征和特征值组合，逐步构建规则。第一轮候选集是基于原始的全部特征和特征值，第二轮候选集是在第一轮的基础上，进一步筛选出与第一轮中某个特征值组合后能更好地覆盖正例的其他特征值。
  

  2. 代码示例

1. def sequential_cover(X, y, rule_generator):
2.     rules = []
3.     covered = set()
4.     while True:
5.         rule, performance = rule_generator(X, y, covered)
6.         if rule is None:  # 无法生成更优规则
7.             break
8.         rules.append(rule)
9.         covered.update(get_covered_instances(rule, X))  # 获取该规则覆盖的实例
10.         if performance < threshold:  # 达到性能阈值
11.             break
12.     return rules
15. def rule_generator(X, y, covered):
16.     best_rule = None
17.     best_performance = 0
18.     for feature in features:
19.         for threshold in thresholds:
20.             rule = generate_rule(feature, threshold)  # 生成可能的规则
21.             performance = evaluate_rule(rule, X, y, covered)  # 评估规则性能
22.             if performance > best_performance:
23.                 best_rule = rule
24.                 best_performance = performance
25.     return best_rule, best_performance
28. def generate_rule(feature, threshold):
29.     # 生成具体的 if-then 规则
30.     rule = {'feature': feature, 'threshold': threshold}
31.     return rule
34. def evaluate_rule(rule, X, y, covered):
35.     correct = 0
36.     total = 0
37.     for i, x in enumerate(X):
38.         if i in covered:  # 跳过已覆盖的实例
39.             continue
40.         if satisfies_rule(x, rule):  # 满足规则
41.             total += 1
42.             if y[i] == positive_class:  # 假设 positive_class 是正类
43.                 correct += 1
44.     if total == 0:
45.         return 0
46.     return correct / total
49. def satisfies_rule(x, rule):
50.     # 判断实例 x 是否满足规则
51.     if x[rule['feature']] > rule['threshold']:
52.         return True
53.     return False
56. def get_covered_instances(rule, X):
57.     covered = []
58.     for i, x in enumerate(X):
59.         if satisfies_rule(x, rule):
60.             covered.append(i)
61.     return covered

复制代码

三、剪枝优化

1. 基本概念

   

• 为避免过拟合，对天生的规则进行剪枝操作，去除冗余或不太紧张的条件，以进步规则的泛化能力。剪枝可基于错误率、信息增益等指标。
  

  一、左侧未剪枝的神经网络布局

• 包罗两个层 Layer i 和 Layer j，层与层之间以及层与后续的加法操作（由“+”表示）之间通过箭头连接，箭头上标注了 N，表示数据的维度或通道数等信息。
  

二、右侧剪枝后的神经网络布局

• Layer i 变为 Pruned layer i，Layer j 变为 Pruned layer j，表示这两个层经过了剪枝操作。
  
• 剪枝后，层与层之间以及层与加法操作之间的连接箭头上标注了差别的维度信息，如 N_a、N_b、N_c。
  
• 此中存在一个警告标记（由“!”表示），旁边标注了 N_b ≠ N_c，这表明在剪枝后，原本应该在维度上匹配的地方出现了不匹配的情况，大概会导致后续计算或模型运行出现问题。
  

三、相干知识点

• 神经网络剪枝：是一种用于减少神经网络模型的复杂度和计算量的技能。通过去除一些不紧张的连接（权重）或神经元，在不明显降低模型性能的条件下，使模型更加轻量化，进步推理速率和效率，同时减少内存占用。
  
• 剪枝后的影响：如图片所示，剪枝大概会导致层与层之间的数据维度发生变化，如果不进行得当的处理惩罚（如调解网络布局、进行维度匹配等），大概会引发错误，影响模型的正常运行和性能。
  

一、Classic（经典流程）

• train（训练）：首先对原始的神经网络进行训练，图中用多个黄色方块表示网络的差别层和连接。
  
• prune（剪枝）：在训练后的网络基础上进行剪枝操作，去除一些不紧张的连接或神经元，得到一个精简后的网络布局。
  
• fine-tune（微调）：对剪枝后的网络进行微调，以恢复或进步网络的性能。
  

二、Lottery Ticket（彩票假说流程）

• train（训练）：与经典流程相同，先对原始网络进行训练。
  
• prune（剪枝）：进行剪枝操作。
  
• rewind（回退）：将剪枝后网络的权重回退到训练过程中的某个早期状态。
  
• re-train（再训练）：从回退的权重状态开始重新训练网络。
  

三、LR-Rewinding（另一种回退再训练流程）

• train（训练）：原始训练过程。
  
• prune（剪枝）：进行剪枝。
  
• re-train（再训练）：直接对剪枝后的网络进行再训练，但大概接纳了与Lottery Ticket流程中差别的再训练方式或策略。
  

四、相干知识点

• 神经网络剪枝：目的是减少模型的复杂度和计算量，同时尽量保持模型的性能。通过去除冗余的连接或神经元，使模型更加轻量化，有利于在资源受限的设备上部署和运行。
  
• 彩票假说（Lottery Ticket Hypothesis）：该假说认为在一个大型的随机初始化的神经网络中，存在一个子网络（即“中奖彩票”），如果在训练初期就将其分离出来，它可以在与原始网络相似的训练时间内达到与原始网络相当的性能。上述Lottery Ticket流程就是基于这一假说，通过回退权重并重新训练来探求如许的子网络。
  
• 模型微调（Fine-tuning）：在剪枝后，由于网络布局发生了变化，大概会影响模型的性能，因此必要进行微调来适应新的布局，使模型可以或许更好地工作。
  

2. 错误率剪枝示例

1. def prune_rule(rule, X, y):
2.     original_performance = evaluate_rule(rule, X, y, set())
3.     for condition in rule.conditions:
4.         pruned_rule = rule.copy()
5.         pruned_rule.conditions.remove(condition)
6.         pruned_performance = evaluate_rule(pruned_rule, X, y, set())
7.         if pruned_performance >= original_performance:
8.             rule = pruned_rule
9.     return rule
12. class Rule:
13.     def __init__(self):
14.         self.conditions = []
17. def evaluate_rule(rule, X, y, covered):
18.     correct = 0
19.     total = 0
20.     for i, x in enumerate(X):
21.         if i in covered:
22.             continue
23.         if satisfies_rule(x, rule):
24.             total += 1
25.             if y[i] == positive_class:
26.                 correct += 1
27.     if total == 0:
28.         return 0
29.     return correct / total
32. def satisfies_rule(x, rule):
33.     for condition in rule.conditions:
34.         if not check_condition(x, condition):
35.             return False
36.     return True
39. def check_condition(x, condition):
40.     feature, threshold = condition
41.     if x[feature] > threshold:
42.         return True
43.     return False

复制代码

四、一阶规则学习

1. 基本概念

   

• 一阶规则学习处理惩罚具有变量的规则，比命题规则学习更具表达能力。它涉及逻辑变量、谓词和量词，可以或许表达更复杂的关系。比方：for all x, if Parent(x, y) and Male(y) then Father(y, x)。
  

  2. 代码示例（利用 ILP 库，如 Aleph）

1. # 首先需要安装 Aleph 库
2. # 以下是一个简单的使用示例，假设已有背景知识和正、反例数据文件
3. aleph -F learn_file

复制代码

• learn_file 包罗如下内容：
  

1. :- set(i).
2. :- modeh(1,father(+person,-person)).
3. :- modeb(1,parent(+person,-person)).
4. :- modeb(1,male(+person)).
6. father(X,Y) :- parent(X,Y), male(Y).

复制代码

• 上述代码定义了一个简朴的 ILP 规则，利用 Aleph 体系，定义了一个学习使命：学习 father 关系，基于 parent 和 male 关系。
  

五、归纳逻辑程序计划（ILP）

1. 基本概念

• ILP 结合了逻辑编程和归纳学习，旨在从数据中学习逻辑程序。它利用一阶逻辑表示知识，学习目的是找到一个逻辑程序，能从配景知识和训练数据中推导出观察效果。
  

2. 相干数学公式（基于信息增益）

• 对于规则 (r) 和训练集 (D)，信息增益 (IG) 公式可表示为：
  (IG(r, D) = Entropy(D) - p_{cover} Entropy(D_{cover}) - (1 - p_{cover}) Entropy(D - D_{cover}))
  
• 此中 (Entropy(D)) 是数据集 (D) 的熵，(p_{cover}) 是规则 (r) 覆盖的样本比例，(D_{cover}) 是被 (r) 覆盖的数据集。
  

3. 代码示例（利用 scikit-learn 风格的伪代码）

1. from sklearn.base import BaseEstimator, ClassifierMixin
4. class ILPClassifier(BaseEstimator, ClassifierMixin):
5.     def __init__(self, max_rules=10):
6.         self.max_rules = max_rules
7.         self.rules = []
9.     def fit(self, X, y):
10.         for _ in range(self.max_rules):
11.             rule = self.generate_rule(X, y)  # 生成规则
12.             if rule is None:
13.                 break
14.             self.rules.append(rule)
15.             X, y = self.remove_covered(X, y, rule)  # 移除已覆盖的样本
16.         return self
18.     def generate_rule(self, X, y):
19.         # 生成新规则，这里假设使用序贯覆盖和信息增益
20.         best_rule = None
21.         best_gain = 0
22.         for feature in features:
23.             for threshold in thresholds:
24.                 rule = Rule(feature, threshold)
25.                 gain = self.calculate_information_gain(rule, X, y)
26.                 if gain > best_gain:
27.                     best_rule = rule
28.                     best_gain = gain
29.         return best_rule
31.     def calculate_information_gain(self, rule, X, y):
32.         # 计算信息增益
33.         p_cover = self.rule_coverage(rule, X)
34.         entropy_before = entropy(y)
35.         entropy_cover = entropy(y[self.rule_covers(rule, X)])
36.         entropy_remain = entropy(y[~self.rule_covers(rule, X)])
37.         gain = entropy_before - p_cover * entropy_cover - (1 - p_cover) * entropy_remain
38.         return gain
40.     def rule_coverage(self, rule, X):
41.         # 计算规则覆盖的样本
42.         covered = []
43.         for i, x in enumerate(X):
44.             if satisfies_rule(x, rule):
45.                 covered.append(i)
46.         return np.array(covered)
48.     def remove_covered(self, X, y, rule):
49.         covered = self.rule_coverage(rule, X)
50.         X = np.delete(X, covered, axis=0)
51.         y = np.delete(y, covered)
52.         return X, y
54.     def predict(self, X):
55.         predictions = []
56.         for x in X:
57.             for rule in self.rules:
58.                 if satisfies_rule(x, rule):
59.                     predictions.append(positive_class)
60.                     break
61.             else:  # 未被任何规则覆盖
62.                 predictions.append(negative_class)
63.         return np.array(predictions)
66. def entropy(y):
67.     # 计算熵
68.     classes = np.unique(y)
69.     entropy_value = 0
70.     for c in classes:
71.         p = np.mean(y == c)
72.         if p > 0:
73.             entropy_value -= p * np.log2(p)
74.     return entropy_value
77. class Rule:
78.     def __init__(self, feature, threshold):
79.         self.feature = feature
80.         self.threshold = threshold
83. def satisfies_rule(x, rule):
84.     if x[rule.feature] > rule.threshold:
85.         return True
86.     return False

复制代码

总结

• 规则学习通过序贯覆盖等策略天生规则，利用剪枝优化进步泛化能力，一阶规则学习和归纳逻辑程序计划可处理惩罚更复杂的逻辑关系。
  

注意事项

   

• 以上代码为示例，实际利用时必要根据具体的呆板学习框架和逻辑编程工具进行调解。
  
• 在利用 ILP 库（如 Aleph）时，需认识其语法和参数设置。
  

  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。