Merge pull request #119 from jiangzhonglian/master

优化 7.集成方法的md文件 + 	更新决策树

docs/3.决策树.md

@@ -26,42 +26,52 @@
 
 ### 决策树 须知概念
 
-#### 信息增益
+#### 信息熵 & 信息增益
 
-划分数据集的最大原则是: 将无序的数据变得更加有序。我们可以使用多种方法划分数据集，但是每种方法都有各自的优缺点。组织杂乱无章数据的一种方法就是使用信息论度量信息，信息论是量化处理信息的分支科学。我们可以在划分数据之前或之后使用信息论量化度量信息的内容。
+熵：
+熵（entropy）指的是体系的混乱的程度，在不同的学科中也有引申出的更为具体的定义，是各领域十分重要的参量。
 
-在划分数据集之前之后信息发生的变化称为信息增益，知道如何计算信息增益，我们就可以计算每个特征值划分数据集获得的信息增益，获得信息增益最高的特征就是最好的选择。
-
-集合信息的度量方式称为香农熵或者简称为熵。
-
-学习了如何度量数据集的无序程度之后，分类算法除了需要测量信息熵，还需要划分数据集，度量划分数据集的熵，以便判断当前是否正确地划分了数据集。我们将对每个特征划分数据集的结果计算一次信息熵，然后判断按照哪个特征划分数据集是最好的划分方式。
+信息熵（香农熵）：
+是一种信息的度量方式，表示信息的混乱程度，也就是说：信息越有序，信息熵越低。例如：火柴有序放在火柴盒里，熵值很低，相反，熵值很高。
 
+信息增益：
+在划分数据集前后信息发生的变化称为信息增益。
 
 ### 决策树 工作原理
 
-1. 检测数据集中的每个子项是否属于同一分类:
-    1. 如果属于同一分类，返回对应的类别标签 label
-    2. 如果不属于同一分类:
-        1. 寻找划分数据集的最好特征
-        2. 划分数据集
-        3. 创建分支节点
-            * 对于每个划分的子集，调用函数 createBranch （创建分支的函数）并增加返回结果到分支节点中
-        4. return 分支节点
+如何构造一个决策树?<br/>
+我们使用 createBranch() 方法，如下所示：
 
-### 决策树 一般流程
+```
+检测数据集中的所有数据的分类标签是否相同:
+    If so return 类标签
+    Else:
+        寻找划分数据集的最好特征（划分之后信息熵最小，也就是信息增益最大的特征）
+        划分数据集
+        创建分支节点
+            for 每个划分的子集
+                调用函数 createBranch （创建分支的函数）并增加返回结果到分支节点中
+        return 分支节点
+```
 
-1. 收集数据：可以使用任何方法。
-2. 准备数据：树构造算法只适用于标称型数据，因此数值型数据必须离散化。
-3. 分析数据：可以使用任何方法，构造树完成之后，我们应该检查图形是否符合预期。
-4. 训练算法：构造树的数据结构。
-5. 测试算法：使用经验树计算错误率。
-6. 使用算法：此步骤可以适用于任何监督学习算法，而使用决策树可以更好地理解数据的内在含义。
+### 决策树 开发流程
+
+```
+收集数据：可以使用任何方法。
+准备数据：树构造算法只适用于标称型数据，因此数值型数据必须离散化。
+分析数据：可以使用任何方法，构造树完成之后，我们应该检查图形是否符合预期。
+训练算法：构造树的数据结构。
+测试算法：使用经验树计算错误率。（经验树没有搜索到较好的资料，有兴趣的同学可以来补充）
+使用算法：此步骤可以适用于任何监督学习算法，而使用决策树可以更好地理解数据的内在含义。
+```
 
 ### 决策树 算法特点
 
-* 优点：计算复杂度不高，输出结果易于理解，对中间值的缺失不敏感，可以处理不相关特征数据。
-* 缺点：可能会产生过度匹配问题。
-* 适用数据类型：数值型和标称型。
+```
+优点：计算复杂度不高，输出结果易于理解，对中间值的缺失不敏感，可以处理不相关特征数据。
+缺点：可能会产生过度匹配问题。
+适用数据类型：数值型和标称型。
+```
 
 ## 决策树 项目案例
 

docs/7.集成方法-随机森林和AdaBoost.md

@@ -6,26 +6,26 @@
 
 * 概念：是对其他算法进行组合的一种形式。
 * 通俗来说： 当做重要决定时，大家可能都会考虑吸取多个专家而不只是一个人的意见。
-    机器学习处理问题时又何尝不是如此？ 这就是元算法(meta-algorithm)背后的思想。
+    机器学习处理问题时又何尝不是如此？ 这就是集成方法背后的思想。
 
 * 集成方法：  
-    1. 投票选举(bagging: 自举汇聚法 bootstrap aggregating): 是基于数据随机重抽样的分类器构造方法
+    1. 投票选举(bagging: 自举汇聚法 bootstrap aggregating): 是基于数据随机重抽样分类器构造的方法
     2. 再学习(boosting): 是基于所有分类器的加权求和的方法
 
-> bagging 和 boosting 区别是什么？
-
-1. bagging 是一种与 boosting 很类似的技术, 所使用的多个分类器的类型（数据量和特征量）都是一致的。
-2. bagging 是由不同的分类器（1.数据随机的 2.特征随机的）训练，综合得出的出现最多分类结果；boosting 是通过调整已有分类器错分的那些数据来获得新的分类器，得出目前最优的结果。
-3. bagging 中的分类器权重是相等的；而 boosting 中的分类器加权求和，所以权重并不相等，每个权重代表的是其对应分类器在上一轮迭代中的成功度。
-
 
 ## 集成方法 场景
 
-目前 bagging 方法最流行的版本是: 随机森林(random forest)
-选帅哥：美女选择择偶对象的时候，会问几个闺蜜的建议，最后选择一个综合得分最高的一个作为男朋友
+目前 bagging 方法最流行的版本是: 随机森林(random forest)<br/>
+选男友：美女选择择偶对象的时候，会问几个闺蜜的建议，最后选择一个综合得分最高的一个作为男朋友
 
-目前 boosting 方法最流行的版本是: AdaBoost
-追美女：第1个帅哥失败->(传授经验：姓名、家庭情况) 第2个帅哥失败->(传授经验：兴趣爱好、性格特点) 第3个帅哥成功
+目前 boosting 方法最流行的版本是: AdaBoost<br/>
+追女友：3个帅哥追同一个美女，第1个帅哥失败->(传授经验：姓名、家庭情况) 第2个帅哥失败->(传授经验：兴趣爱好、性格特点) 第3个帅哥成功
+
+> bagging 和 boosting 区别是什么？
+
+1. bagging 是一种与 boosting 很类似的技术, 所使用的多个分类器的类型（数据量和特征量）都是一致的。
+2. bagging 是由不同的分类器（1.数据随机化 2.特征随机化）经过训练，综合得出的出现最多分类结果；boosting 是通过调整已有分类器错分的那些数据来获得新的分类器，得出目前最优的结果。
+3. bagging 中的分类器权重是相等的；而 boosting 中的分类器加权求和，所以权重并不相等，每个权重代表的是其对应分类器在上一轮迭代中的成功度。
 
 
 ## 随机森林
@@ -46,6 +46,7 @@
 
 > 数据的随机化：使得随机森林中的决策树更普遍化一点，适合更多的场景。
 
+（有放回的准确率在：70% 以上， 无放回的准确率在：60% 以上）
 1. 采取有放回的抽样方式 构造子数据集，保证不同子集之间的数量级一样（不同子集／同一子集 之间的元素可以重复）
 2. 利用子数据集来构建子决策树，将这个数据放到每个子决策树中，每个子决策树输出一个结果。
 3. 然后统计子决策树的投票结果，得到最终的分类 就是 随机森林的输出结果。
@@ -64,10 +65,224 @@
 
 ![特征重抽样](/images/7.RandomForest/特征重抽样.jpg)
 
+> 随机森林 开发流程
+
+```
+收集数据：任何方法
+准备数据：转换样本集
+分析数据：任何方法
+训练算法：通过数据随机化和特征随机化，进行多实例的分类评估
+测试算法：计算错误率
+使用算法：输入样本数据，然后运行 随机森林 算法判断输入数据分类属于哪个分类，最后对计算出的分类执行后续处理
+```
+
+> 随机森林 算法特点
+
+```
+优点：几乎不需要输入准备、可实现隐式特征选择、训练速度非常快、其他模型很难超越、很难建立一个糟糕的随机森林模型、大量优秀、免费以及开源的实现。
+缺点：劣势在于模型大小、是个很难去解释的黑盒子。
+适用数据范围：数值型和标称型
+```
+
 ### 项目案例: 随机森林
 
 ![随机森林](/images/7.RandomForest/RandomForest_Flow.jpg)
 
+#### 项目概述
+
+这是 Gorman 和 Sejnowski 在研究使用神经网络的声纳信号分类中使用的数据集。任务是训练一个网络来区分声纳信号。
+
+#### 开发流程
+
+```
+收集数据：提供的文本文件。
+准备数据：转换样本集。
+分析数据：手工检查数据。
+训练算法：在数据上，利用 random_forest() 函数进行优化评估，返回模型的综合分类结果。
+测试算法：在采用自定义 n_folds 循环的随机重抽样就行测试评估，得出综合的预测评分。
+使用算法：本例没有完成此步骤，若你感兴趣可以构建完整的应用程序，从案例进行封装，就可以构造一个实际运行的类似系统
+```
+
+> 收集数据：提供的文本文件。
+
+样本数据：sonar-all-data.txt
+
+```
+0.02,0.0371,0.0428,0.0207,0.0954,0.0986,0.1539,0.1601,0.3109,0.2111,0.1609,0.1582,0.2238,0.0645,0.066,0.2273,0.31,0.2999,0.5078,0.4797,0.5783,0.5071,0.4328,0.555,0.6711,0.6415,0.7104,0.808,0.6791,0.3857,0.1307,0.2604,0.5121,0.7547,0.8537,0.8507,0.6692,0.6097,0.4943,0.2744,0.051,0.2834,0.2825,0.4256,0.2641,0.1386,0.1051,0.1343,0.0383,0.0324,0.0232,0.0027,0.0065,0.0159,0.0072,0.0167,0.018,0.0084,0.009,0.0032,R
+0.0453,0.0523,0.0843,0.0689,0.1183,0.2583,0.2156,0.3481,0.3337,0.2872,0.4918,0.6552,0.6919,0.7797,0.7464,0.9444,1,0.8874,0.8024,0.7818,0.5212,0.4052,0.3957,0.3914,0.325,0.32,0.3271,0.2767,0.4423,0.2028,0.3788,0.2947,0.1984,0.2341,0.1306,0.4182,0.3835,0.1057,0.184,0.197,0.1674,0.0583,0.1401,0.1628,0.0621,0.0203,0.053,0.0742,0.0409,0.0061,0.0125,0.0084,0.0089,0.0048,0.0094,0.0191,0.014,0.0049,0.0052,0.0044,R
+0.0262,0.0582,0.1099,0.1083,0.0974,0.228,0.2431,0.3771,0.5598,0.6194,0.6333,0.706,0.5544,0.532,0.6479,0.6931,0.6759,0.7551,0.8929,0.8619,0.7974,0.6737,0.4293,0.3648,0.5331,0.2413,0.507,0.8533,0.6036,0.8514,0.8512,0.5045,0.1862,0.2709,0.4232,0.3043,0.6116,0.6756,0.5375,0.4719,0.4647,0.2587,0.2129,0.2222,0.2111,0.0176,0.1348,0.0744,0.013,0.0106,0.0033,0.0232,0.0166,0.0095,0.018,0.0244,0.0316,0.0164,0.0095,0.0078,R
+```
+
+> 准备数据：转换样本集
+
+```python
+# 导入csv文件
+def loadDataSet(filename):
+    dataset = []
+    with open(filename, 'r') as fr:
+        for line in fr.readlines():
+            if not line:
+                continue
+            lineArr = []
+            for featrue in line.split(','):
+                # strip()返回移除字符串头尾指定的字符生成的新字符串
+                str_f = featrue.strip()
+                if str_f.isdigit(): # 判断是否是数字
+                    # 将数据集的第column列转换成float形式
+                    lineArr.append(float(str_f))
+                else:
+                    # 添加分类标签
+                    lineArr.append(str_f)
+            dataset.append(lineArr)
+    return dataset
+```
+
+> 分析数据：手工检查数据
+
+> 训练算法：在数据上，利用 random_forest() 函数进行优化评估，返回模型的综合分类结果
+
+* 数据随机化
+
+```python
+def cross_validation_split(dataset, n_folds):
+    """cross_validation_split(将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次list的元素是无重复的)
+
+    Args:
+        dataset     原始数据集
+        n_folds     数据集dataset分成n_flods份
+    Returns:
+        dataset_split    list集合，存放的是：将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次list的元素是无重复的
+    """
+    dataset_split = list()
+    dataset_copy = list(dataset)       # 复制一份 dataset,防止 dataset 的内容改变
+    fold_size = len(dataset) / n_folds
+    for i in range(n_folds):
+        fold = list()                  # 每次循环 fold 清零，防止重复导入 dataset_split
+        while len(fold) < fold_size:   # 这里不能用 if，if 只是在第一次判断时起作用，while 执行循环，直到条件不成立
+            # 有放回的随机采样，有一些样本被重复采样，从而在训练集中多次出现，有的则从未在训练集中出现，此则自助采样法。从而保证每棵决策树训练集的差异性            
+            index = randrange(len(dataset_copy))
+            # 将对应索引 index 的内容从 dataset_copy 中导出，并将该内容从 dataset_copy 中删除。
+            # pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
+            # fold.append(dataset_copy.pop(index))  # 无放回的方式
+            fold.append(dataset_copy[index])  # 有放回的方式
+        dataset_split.append(fold)
+    # 由dataset分割出的n_folds个数据构成的列表，为了用于交叉验证
+    return dataset_split
+```
+
+* 特征随机化
+
+```python
+# 找出分割数据集的最优特征，得到最优的特征 index，特征值 row[index]，以及分割完的数据 groups（left, right）
+def get_split(dataset, n_features):
+    class_values = list(set(row[-1] for row in dataset))  # class_values =[0, 1]
+    b_index, b_value, b_score, b_groups = 999, 999, 999, None
+    features = list()
+    while len(features) < n_features:
+        index = randrange(len(dataset[0])-1)  # 往 features 添加 n_features 个特征（ n_feature 等于特征数的根号），特征索引从 dataset 中随机取
+        if index not in features:
+            features.append(index)
+    for index in features:                    # 在 n_features 个特征中选出最优的特征索引，并没有遍历所有特征，从而保证了每课决策树的差异性
+        for row in dataset:
+            groups = test_split(index, row[index], dataset)  # groups=(left, right), row[index] 遍历每一行 index 索引下的特征值作为分类值 value, 找出最优的分类特征和特征值
+            gini = gini_index(groups, class_values)
+            # 左右两边的数量越一样，说明数据区分度不高，gini系数越大
+            if gini < b_score:
+                b_index, b_value, b_score, b_groups = index, row[index], gini, groups  # 最后得到最优的分类特征 b_index,分类特征值 b_value,分类结果 b_groups。b_value 为分错的代价成本
+    # print b_score
+    return {'index': b_index, 'value': b_value, 'groups': b_groups}
+```
+
+* 随机森林
+
+```python
+# Random Forest Algorithm
+def random_forest(train, test, max_depth, min_size, sample_size, n_trees, n_features):
+    """random_forest(评估算法性能，返回模型得分)
+
+    Args:
+        train           训练数据集
+        test            测试数据集
+        max_depth       决策树深度不能太深，不然容易导致过拟合
+        min_size        叶子节点的大小
+        sample_size     训练数据集的样本比例
+        n_trees         决策树的个数
+        n_features      选取的特征的个数
+    Returns:
+        predictions     每一行的预测结果，bagging 预测最后的分类结果
+    """
+
+    trees = list()
+    # n_trees 表示决策树的数量
+    for i in range(n_trees):
+        # 随机抽样的训练样本， 随机采样保证了每棵决策树训练集的差异性
+        sample = subsample(train, sample_size)
+        # 创建一个决策树
+        tree = build_tree(sample, max_depth, min_size, n_features)
+        trees.append(tree)
+
+    # 每一行的预测结果，bagging 预测最后的分类结果
+    predictions = [bagging_predict(trees, row) for row in test]
+    return predictions
+```
+
+> 测试算法：在采用自定义 n_folds 循环的随机重抽样就行测试评估，得出综合的预测评分。
+
+* 计算随机森林的预测结果的正确率
+
+```python
+# 评估算法性能，返回模型得分
+def evaluate_algorithm(dataset, algorithm, n_folds, *args):
+    """evaluate_algorithm(评估算法性能，返回模型得分)
+
+    Args:
+        dataset     原始数据集
+        algorithm   使用的算法
+        n_folds     树的个数
+        *args       其他的参数
+    Returns:
+        scores      模型得分
+    """
+
+    # 将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次 list 的元素是无重复的
+    folds = cross_validation_split(dataset, n_folds)
+    scores = list()
+    # 每次循环从 folds 从取出一个 fold 作为测试集，其余作为训练集，遍历整个 folds ，实现交叉验证
+    for fold in folds:
+        train_set = list(folds)
+        train_set.remove(fold)
+        # 将多个 fold 列表组合成一个 train_set 列表, 类似 union all
+        """
+        In [20]: l1=[[1, 2, 'a'], [11, 22, 'b']]
+        In [21]: l2=[[3, 4, 'c'], [33, 44, 'd']]
+        In [22]: l=[]
+        In [23]: l.append(l1)
+        In [24]: l.append(l2)
+        In [25]: l
+        Out[25]: [[[1, 2, 'a'], [11, 22, 'b']], [[3, 4, 'c'], [33, 44, 'd']]]
+        In [26]: sum(l, [])
+        Out[26]: [[1, 2, 'a'], [11, 22, 'b'], [3, 4, 'c'], [33, 44, 'd']]
+        """
+        train_set = sum(train_set, [])
+        test_set = list()
+        # fold 表示从原始数据集 dataset 提取出来的测试集
+        for row in fold:
+            row_copy = list(row)
+            row_copy[-1] = None 
+            test_set.append(row_copy)
+        predicted = algorithm(train_set, test_set, *args)
+        actual = [row[-1] for row in fold]
+
+        # 计算随机森林的预测结果的正确率
+        accuracy = accuracy_metric(actual, predicted)
+        scores.append(accuracy)
+    return scores
+```
+
+> 使用算法：本例没有完成此步骤，若你感兴趣可以构建完整的应用程序，从案例进行封装，就可以构造一个实际运行的类似系统
+
+[完整代码地址](https://github.com/apachecn/MachineLearning/blob/master/src/python/7.RandomForest/randomForest.py): <https://github.com/apachecn/MachineLearning/blob/master/src/python/7.RandomForest/randomForest.py>
+
 
 ## AdaBoost 
 
@@ -89,8 +304,8 @@
     当然也可以使用任意分类器作为弱分类器，第2章到第6章中的任一分类器都可以充当弱分类器。
     作为弱分类器，简单分类器的效果更好。
 分析数据：可以使用任意方法。
-训练数据：AdaBoost 的大部分时间都用在训练上，分类器将多次在同一数据集上训练弱分类器。
-测试数据：计算分类的错误率。
+训练算法：AdaBoost 的大部分时间都用在训练上，分类器将多次在同一数据集上训练弱分类器。
+测试算法：计算分类的错误率。
 使用算法：通SVM一样，AdaBoost 预测两个类别中的一个。如果想把它应用到多个类别的场景，那么就要像多类 SVM 中的做法一样对 AdaBoost 进行修改。
 ```
 
@@ -121,8 +336,8 @@
 收集数据：提供的文本文件。
 准备数据：确保类别标签是+1和-1，而非1和0。
 分析数据：手工检查数据。
-训练数据：在数据上，利用 adaBoostTrainDS() 函数训练出一系列的分类器。
-测试数据：我们拥有两个数据集。在不采用随机抽样的方法下，我们就会对 AdaBoost 和 Logistic 回归的结果进行完全对等的比较。
+训练算法：在数据上，利用 adaBoostTrainDS() 函数训练出一系列的分类器。
+测试算法：我们拥有两个数据集。在不采用随机抽样的方法下，我们就会对 AdaBoost 和 Logistic 回归的结果进行完全对等的比较。
 使用算法：观察该例子上的错误率。不过，也可以构建一个 Web 网站，让驯马师输入马的症状然后预测马是否会死去。
 ```
 
@@ -163,7 +378,7 @@ def loadDataSet(fileName):
 
 ![过拟合](/images/7.AdaBoost/过拟合.png)
 
-> 训练数据：在数据上，利用 adaBoostTrainDS() 函数训练出一系列的分类器。
+> 训练算法：在数据上，利用 adaBoostTrainDS() 函数训练出一系列的分类器。
 
 ```python
 def adaBoostTrainDS(dataArr, labelArr, numIt=40):
@@ -218,15 +433,15 @@ def adaBoostTrainDS(dataArr, labelArr, numIt=40):
 
 ```
 发现：
-alpha 目的主要是计算每一个分类器实例的权重(组合就是分类结果)
+alpha （模型权重）目的主要是计算每一个分类器实例的权重(组合就是分类结果)
   分类的权重值：最大的值= alpha 的加和，最小值=-最大值
-D 的目的是为了计算错误概率： weightedError = D.T*errArr，求最佳分类器
+D （特征权重）的目的是为了计算错误概率： weightedError = D.T*errArr，求最佳分类器
   特征的权重值：如果一个值误判的几率越小，那么 D 的特征权重越少
 ```
 
 ![AdaBoost算法权重计算公式](/images/7.AdaBoost/adaboost_alpha.png "AdaBoost算法权重计算公式")
 
-> 测试数据：我们拥有两个数据集。在不采用随机抽样的方法下，我们就会对 AdaBoost 和 Logistic 回归的结果进行完全对等的比较。
+> 测试算法：我们拥有两个数据集。在不采用随机抽样的方法下，我们就会对 AdaBoost 和 Logistic 回归的结果进行完全对等的比较。
 
 ```python
 def adaClassify(datToClass, classifierArr):
@@ -274,7 +489,6 @@ print m, errArr[predicting10 != mat(labelArrTest).T].sum(), errArr[predicting10
 
 #### 要点补充
 
-
 > 非均衡现象：
 
 `在分类器训练时，正例数目和反例数目不相等（相差很大）`

src/python/7.AdaBoost/adaboost.py

@@ -155,16 +155,16 @@ def adaBoostTrainDS(dataArr, labelArr, numIt=40):
         # store Stump Params in Array
         weakClassArr.append(bestStump)
 
-        print "alpha=%s, classEst=%s, bestStump=%s, error=%s " % (alpha, classEst.T, bestStump, error)
+        # print "alpha=%s, classEst=%s, bestStump=%s, error=%s " % (alpha, classEst.T, bestStump, error)
         # -1主要是下面求e的-alpha次方； 如果判断正确，乘积为1，否则成绩为-1，这样就可以算出分类的情况了
         expon = multiply(-1*alpha*mat(labelArr).T, classEst)
-        print '\n'
-        print 'labelArr=', labelArr
-        print 'classEst=', classEst.T
-        print '\n'
-        print '乘积: ', multiply(mat(labelArr).T, classEst).T
+        # print '\n'
+        # print 'labelArr=', labelArr
+        # print 'classEst=', classEst.T
+        # print '\n'
+        # print '乘积: ', multiply(mat(labelArr).T, classEst).T
         # 判断正确的，就乘以-1，否则就乘以1， 为什么？ 书上的公式。
-        print '(-1取反)预测值expon=', expon.T
+        # print '(-1取反)预测值expon=', expon.T
         # 计算e的expon次方，然后计算得到一个综合的概率的值
         # 结果发现： 判断错误的特征，D对于的特征的权重值会变大。
         D = multiply(D, exp(expon))
@@ -173,9 +173,9 @@ def adaBoostTrainDS(dataArr, labelArr, numIt=40):
         print '\n'
 
         # 预测的分类结果值，在上一轮结果的基础上，进行加和操作
-        print '当前的分类结果：', alpha*classEst.T
+        # print '当前的分类结果：', alpha*classEst.T
         aggClassEst += alpha*classEst
-        print "叠加后的分类结果aggClassEst: ", aggClassEst.T
+        # print "叠加后的分类结果aggClassEst: ", aggClassEst.T
         # sign 判断正为1， 0为0， 负为-1，通过最终加和的权重值，判断符号。
         # 结果为：错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负
         aggErrors = multiply(sign(aggClassEst) != mat(labelArr).T, ones((m, 1)))

src/python/7.RandomForest/randomForest.py

@@ -10,7 +10,7 @@ Random Forest Algorithm on Sonar Dataset
 ---
 源代码网址：http://www.tuicool.com/articles/iiUfeim
 Flying_sfeng博客地址：http://blog.csdn.net/flying_sfeng/article/details/64133822
-在此表示感谢你的代码和注解， 我重新也完善了你的注解
+在此表示感谢你的代码和注解， 我重新也完善了个人注解
 '''
 from random import seed, randrange, random
 
@@ -26,7 +26,7 @@ def loadDataSet(filename):
             for featrue in line.split(','):
                 # strip()返回移除字符串头尾指定的字符生成的新字符串
                 str_f = featrue.strip()
-                if str_f.isdigit():
+                if str_f.isdigit():   # 判断是否是数字
                     # 将数据集的第column列转换成float形式
                     lineArr.append(float(str_f))
                 else:
@@ -46,22 +46,23 @@ def cross_validation_split(dataset, n_folds):
         dataset_split    list集合，存放的是：将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次list的元素是无重复的
     """
     dataset_split = list()
-    dataset_copy = list(dataset)  #复制一份dataset,防止dataset的内容改变
+    dataset_copy = list(dataset)       # 复制一份 dataset,防止 dataset 的内容改变
     fold_size = len(dataset) / n_folds
     for i in range(n_folds):
-        fold = list()   #每次循环fold清零，防止重复导入dataset_split
-        while len(fold) < fold_size:   #这里不能用if，if只是在第一次判断时起作用，while执行循环，直到条件不成立
+        fold = list()                  # 每次循环 fold 清零，防止重复导入 dataset_split
+        while len(fold) < fold_size:   # 这里不能用 if，if 只是在第一次判断时起作用，while 执行循环，直到条件不成立
             # 有放回的随机采样，有一些样本被重复采样，从而在训练集中多次出现，有的则从未在训练集中出现，此则自助采样法。从而保证每棵决策树训练集的差异性            
             index = randrange(len(dataset_copy))
-            # 将对应索引index的内容从dataset_copy中导出，并将该内容从dataset_copy中删除。
-            # pop()函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
-            fold.append(dataset_copy.pop(index))
+            # 将对应索引 index 的内容从 dataset_copy 中导出，并将该内容从 dataset_copy 中删除。
+            # pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
+            # fold.append(dataset_copy.pop(index))  # 无放回的方式
+            fold.append(dataset_copy[index])  # 有放回的方式
         dataset_split.append(fold)
     # 由dataset分割出的n_folds个数据构成的列表，为了用于交叉验证
     return dataset_split
 
 
-# Split a dataset based on an attribute and an attribute value #根据特征和特征值分割数据集
+# Split a dataset based on an attribute and an attribute value # 根据特征和特征值分割数据集
 def test_split(index, value, dataset):
     left, right = list(), list()
     for row in dataset:
@@ -73,45 +74,46 @@ def test_split(index, value, dataset):
 
 
 # Calculate the Gini index for a split dataset
-def gini_index(groups, class_values):   #个人理解：计算代价，分类越准确，则gini越小
+def gini_index(groups, class_values):    # 个人理解：计算代价，分类越准确，则 gini 越小
     gini = 0.0
-    for class_value in class_values:  #class_values =[0,1] 
-        for group in groups:          #groups=(left,right)
+    for class_value in class_values:     # class_values = [0, 1] 
+        for group in groups:             # groups = (left, right)
             size = len(group)
             if size == 0:
                 continue
             proportion = [row[-1] for row in group].count(class_value) / float(size)
-            gini += (proportion * (1.0 - proportion))  #个人理解：计算代价，分类越准确，则gini越小
+            gini += (proportion * (1.0 - proportion))    # 个人理解：计算代价，分类越准确，则 gini 越小
     return gini
 
 
-# 找出分割数据集的最优特征，得到最优的特征index，特征值row[index]，以及分割完的数据groups（left,right）
+# 找出分割数据集的最优特征，得到最优的特征 index，特征值 row[index]，以及分割完的数据 groups（left, right）
 def get_split(dataset, n_features):
-    class_values = list(set(row[-1] for row in dataset))  #class_values =[0,1]
+    class_values = list(set(row[-1] for row in dataset))  # class_values =[0, 1]
     b_index, b_value, b_score, b_groups = 999, 999, 999, None
     features = list()
     while len(features) < n_features:
-        index = randrange(len(dataset[0])-1)  #往features添加n_features个特征（n_feature等于特征数的根号），特征索引从dataset中随机取
+        index = randrange(len(dataset[0])-1)  # 往 features 添加 n_features 个特征（ n_feature 等于特征数的根号），特征索引从 dataset 中随机取
         if index not in features:
             features.append(index)
-    for index in features:        #在n_features个特征中选出最优的特征索引，并没有遍历所有特征，从而保证了每课决策树的差异性
+    for index in features:                    # 在 n_features 个特征中选出最优的特征索引，并没有遍历所有特征，从而保证了每课决策树的差异性
         for row in dataset:
-            groups = test_split(index, row[index], dataset)  #groups=(left,right)；row[index]遍历每一行index索引下的特征值作为分类值value，找出最优的分类特征和特征值
+            groups = test_split(index, row[index], dataset)  # groups=(left, right), row[index] 遍历每一行 index 索引下的特征值作为分类值 value, 找出最优的分类特征和特征值
             gini = gini_index(groups, class_values)
+            # 左右两边的数量越一样，说明数据区分度不高，gini系数越大
             if gini < b_score:
-                b_index, b_value, b_score, b_groups = index, row[index], gini, groups  #最后得到最优的分类特征b_index,分类特征值b_value,分类结果b_groups。b_value为分错的代价成本。
-    #print b_score
-    return {'index':b_index, 'value':b_value, 'groups':b_groups}
+                b_index, b_value, b_score, b_groups = index, row[index], gini, groups  # 最后得到最优的分类特征 b_index,分类特征值 b_value,分类结果 b_groups。b_value 为分错的代价成本
+    # print b_score
+    return {'index': b_index, 'value': b_value, 'groups': b_groups}
 
 
-# Create a terminal node value #输出group中出现次数较多的标签
+# Create a terminal node value # 输出group中出现次数较多的标签
 def to_terminal(group):
-    outcomes = [row[-1] for row in group]           #max()函数中，当key参数不为空时，就以key的函数对象为判断的标准;
-    return max(set(outcomes), key=outcomes.count)   # 输出group中出现次数较多的标签  
+    outcomes = [row[-1] for row in group]           # max() 函数中，当 key 参数不为空时，就以 key 的函数对象为判断的标准
+    return max(set(outcomes), key=outcomes.count)   # 输出 group 中出现次数较多的标签  
 
 
-# Create child splits for a node or make terminal  #创建子分割器，递归分类，直到分类结束
-def split(node, max_depth, min_size, n_features, depth):  #max_depth = 10，min_size = 1，n_features = int(sqrt(len(dataset[0])-1)) 
+# Create child splits for a node or make terminal  # 创建子分割器，递归分类，直到分类结束
+def split(node, max_depth, min_size, n_features, depth):  # max_depth = 10, min_size = 1, n_features = int(sqrt((dataset[0])-1))
     left, right = node['groups']
     del(node['groups'])
 # check for a no split
@@ -119,15 +121,15 @@ def split(node, max_depth, min_size, n_features, depth):  #max_depth = 10，min_
         node['left'] = node['right'] = to_terminal(left + right)
         return
 # check for max depth
-    if depth >= max_depth:   #max_depth=10表示递归十次，若分类还未结束，则选取数据中分类标签较多的作为结果，使分类提前结束，防止过拟合
+    if depth >= max_depth:   # max_depth=10 表示递归十次，若分类还未结束，则选取数据中分类标签较多的作为结果，使分类提前结束，防止过拟合
         node['left'], node['right'] = to_terminal(left), to_terminal(right)
         return
 # process left child
     if len(left) <= min_size:
         node['left'] = to_terminal(left)
     else:
-        node['left'] = get_split(left, n_features)  #node['left']是一个字典，形式为{'index':b_index, 'value':b_value, 'groups':b_groups}，所以node是一个多层字典
-        split(node['left'], max_depth, min_size, n_features, depth+1)  #递归，depth+1计算递归层数
+        node['left'] = get_split(left, n_features)  # node['left']是一个字典，形式为{'index':b_index, 'value':b_value, 'groups':b_groups}，所以node是一个多层字典
+        split(node['left'], max_depth, min_size, n_features, depth+1)  # 递归，depth+1计算递归层数
 # process right child
     if len(right) <= min_size:
         node['right'] = to_terminal(right)
@@ -149,19 +151,19 @@ def build_tree(train, max_depth, min_size, n_features):
         root            返回决策树
     """
 
-    # 返回最有列和相关的信息
+    # 返回最优列和相关的信息
     root = get_split(train, n_features)
 
-    # 对左右2变的数据 进行递归的调用，由于最优特征使用过，所以在后面进行使用的时候，就没有意义了
+    # 对左右2边的数据 进行递归的调用，由于最优特征使用过，所以在后面进行使用的时候，就没有意义了
     # 例如： 性别-男女，对男使用这一特征就没任何意义了
     split(root, max_depth, min_size, n_features, 1)
     return root
 
 
 # Make a prediction with a decision tree
-def predict(node, row):   #预测模型分类结果
+def predict(node, row):   # 预测模型分类结果
     if row[node['index']] < node['value']:
-        if isinstance(node['left'], dict):    #isinstance是Python中的一个内建函数。是用来判断一个对象是否是一个已知的类型。
+        if isinstance(node['left'], dict):       # isinstance是Python中的一个内建函数。是用来判断一个对象是否是一个已知的类型。
             return predict(node['left'], row)
         else:
             return node['left']
@@ -189,7 +191,7 @@ def bagging_predict(trees, row):
 
 
 # Create a random subsample from the dataset with replacement
-def subsample(dataset, ratio):   #创建数据集的随机子样本
+def subsample(dataset, ratio):   # 创建数据集的随机子样本
     """random_forest(评估算法性能，返回模型得分)
 
     Args:
@@ -227,7 +229,7 @@ def random_forest(train, test, max_depth, min_size, sample_size, n_trees, n_feat
     """
 
     trees = list()
-    # n_trees表示决策树的数量
+    # n_trees 表示决策树的数量
     for i in range(n_trees):
         # 随机抽样的训练样本， 随机采样保证了每棵决策树训练集的差异性
         sample = subsample(train, sample_size)
@@ -241,7 +243,7 @@ def random_forest(train, test, max_depth, min_size, sample_size, n_trees, n_feat
 
 
 # Calculate accuracy percentage
-def accuracy_metric(actual, predicted):  #导入实际值和预测值，计算精确度
+def accuracy_metric(actual, predicted):  # 导入实际值和预测值，计算精确度
     correct = 0
     for i in range(len(actual)):
         if actual[i] == predicted[i]:
@@ -262,14 +264,14 @@ def evaluate_algorithm(dataset, algorithm, n_folds, *args):
         scores      模型得分
     """
 
-    # 将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次list的元素是无重复的
+    # 将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次 list 的元素是无重复的
     folds = cross_validation_split(dataset, n_folds)
     scores = list()
-    # 每次循环从folds从取出一个fold作为测试集，其余作为训练集，遍历整个folds，实现交叉验证
+    # 每次循环从 folds 从取出一个 fold 作为测试集，其余作为训练集，遍历整个 folds ，实现交叉验证
     for fold in folds:
         train_set = list(folds)
         train_set.remove(fold)
-        # 将多个fold列表组合成一个train_set列表, 类似 union all
+        # 将多个 fold 列表组合成一个 train_set 列表, 类似 union all
         """
         In [20]: l1=[[1, 2, 'a'], [11, 22, 'b']]
         In [21]: l2=[[3, 4, 'c'], [33, 44, 'd']]
@@ -283,11 +285,11 @@ def evaluate_algorithm(dataset, algorithm, n_folds, *args):
         """
         train_set = sum(train_set, [])
         test_set = list()
-        # fold表示从原始数据集dataset提取出来的测试集
+        # fold 表示从原始数据集 dataset 提取出来的测试集
         for row in fold:
             row_copy = list(row)
-            test_set.append(row_copy)
             row_copy[-1] = None
+            test_set.append(row_copy)
         predicted = algorithm(train_set, test_set, *args)
         actual = [row[-1] for row in fold]
 
@@ -307,9 +309,9 @@ if __name__ == '__main__':
     max_depth = 20     # 调参（自己修改） #决策树深度不能太深，不然容易导致过拟合
     min_size = 1       # 决策树的叶子节点最少的元素数量
     sample_size = 1.0  # 做决策树时候的样本的比例
-    # n_features = int(sqrt(len(dataset[0])-1))
-    n_features =15     # 调参（自己修改） #准确性与多样性之间的权衡
-    for n_trees in [1, 5, 10]:  # 理论上树是越多越好
+    # n_features = int((len(dataset[0])-1))
+    n_features = 15     # 调参（自己修改） #准确性与多样性之间的权衡
+    for n_trees in [1, 10, 20]:  # 理论上树是越多越好
         scores = evaluate_algorithm(dataset, random_forest, n_folds, max_depth, min_size, sample_size, n_trees, n_features)
         # 每一次执行本文件时都能产生同一个随机数
         seed(1)