# 导入csv文件
def loadDataSet(filename):dataset = []with open(filename, 'r') as fr:for line in fr.readlines():if not line:continuelineArr = []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

def cross_validation_split(dataset, n_folds):"""cross_validation_split(将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取)

    Args:
        dataset     原始数据集
        n_folds     数据集dataset分成n_flods份
    Returns:
        dataset_split    list集合，存放的是：将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取
    """dataset_split = list()dataset_copy = list(dataset)       # 复制一份 dataset,防止 dataset 的内容改变fold_size = len(dataset) / n_foldsfor i in range(n_folds):fold = list()                  # 每次循环 fold 清零，防止重复导入 dataset_splitwhile 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

# Create a random subsample from the dataset with replacement
def subsample(dataset, ratio):   # 创建数据集的随机子样本"""random_forest(评估算法性能，返回模型得分)

    Args:
        dataset         训练数据集
        ratio           训练数据集的样本比例
    Returns:
        sample          随机抽样的训练样本
    """sample = list()# 训练样本的按比例抽样。# round() 方法返回浮点数x的四舍五入值。n_sample = round(len(dataset) * ratio)while len(sample) < n_sample:# 有放回的随机采样，有一些样本被重复采样，从而在训练集中多次出现，有的则从未在训练集中出现，此则自助采样法。从而保证每棵决策树训练集的差异性index = randrange(len(dataset))sample.append(dataset[index])return sample

# 找出分割数据集的最优特征，得到最优的特征 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, Nonefeatures = 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_scorereturn {'index': b_index, 'value': b_value, 'groups': b_groups}

# 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

# 评估算法性能，返回模型得分
def evaluate_algorithm(dataset, algorithm, n_folds, *args):"""evaluate_algorithm(评估算法性能，返回模型得分)

    Args:
        dataset     原始数据集
        algorithm   使用的算法
        n_folds     数据的份数
        *args       其他的参数
    Returns:
        scores      模型得分
    """# 将数据集进行随机抽样，分成 n_folds 份，数据无重复的抽取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

def loadDataSet(fileName):# 获取 feature 的数量, 便于获取numFeat = len(open(fileName).readline().split('\t'))dataArr = []labelArr = []fr = open(fileName)for line in fr.readlines():lineArr = []curLine = line.strip().split('\t')for i in range(numFeat-1):lineArr.append(float(curLine[i]))dataArr.append(lineArr)labelArr.append(float(curLine[-1]))return dataArr, labelArr

def adaBoostTrainDS(dataArr, labelArr, numIt=40):"""adaBoostTrainDS(adaBoost训练过程放大)
    Args:
        dataArr   特征标签集合
        labelArr  分类标签集合
        numIt     实例数
    Returns:
        weakClassArr  弱分类器的集合
        aggClassEst   预测的分类结果值
    """weakClassArr = []m = shape(dataArr)[0]# 初始化 D，设置每个样本的权重值，平均分为m份D = mat(ones((m, 1))/m)aggClassEst = mat(zeros((m, 1)))for i in range(numIt):# 得到决策树的模型bestStump, error, classEst = buildStump(dataArr, labelArr, D)# alpha目的主要是计算每一个分类器实例的权重(组合就是分类结果)# 计算每个分类器的alpha权重值alpha = float(0.5*log((1.0-error)/max(error, 1e-16)))bestStump['alpha'] = alpha# store Stump Params in ArrayweakClassArr.append(bestStump)print "alpha=%s, classEst=%s, bestStump=%s, error=%s " % (alpha, classEst.T, bestStump, error)# 分类正确：乘积为1，不会影响结果，-1主要是下面求e的-alpha次方# 分类错误：乘积为 -1，结果会受影响，所以也乘以 -1expon = multiply(-1*alpha*mat(labelArr).T, classEst)print '(-1取反)预测值expon=', expon.T# 计算e的expon次方，然后计算得到一个综合的概率的值# 结果发现： 判断错误的样本，D对于的样本权重值会变大。D = multiply(D, exp(expon))D = D/D.sum()# 预测的分类结果值，在上一轮结果的基础上，进行加和操作print '当前的分类结果：', alpha*classEst.TaggClassEst += alpha*classEstprint "叠加后的分类结果aggClassEst: ", aggClassEst.T# sign 判断正为1， 0为0， 负为-1，通过最终加和的权重值，判断符号。# 结果为：错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负aggErrors = multiply(sign(aggClassEst) != mat(labelArr).T, ones((m, 1)))errorRate = aggErrors.sum()/m# print "total error=%s " % (errorRate)if errorRate == 0.0:breakreturn weakClassArr, aggClassEst

def adaClassify(datToClass, classifierArr):"""adaClassify(ada分类测试)
    Args:
        datToClass     多个待分类的样例
        classifierArr  弱分类器的集合
    Returns:
        sign(aggClassEst) 分类结果
    """# do stuff similar to last aggClassEst in adaBoostTrainDSdataMat = mat(datToClass)m = shape(dataMat)[0]aggClassEst = mat(zeros((m, 1)))# 循环 多个分类器for i in range(len(classifierArr)):# 前提： 我们已经知道了最佳的分类器的实例# 通过分类器来核算每一次的分类结果，然后通过alpha*每一次的结果 得到最后的权重加和的值。classEst = stumpClassify(dataMat, classifierArr[i]['dim'], classifierArr[i]['thresh'], classifierArr[i]['ineq'])aggClassEst += classifierArr[i]['alpha']*classEstreturn sign(aggClassEst)

# 马疝病数据集
# 训练集合
dataArr, labelArr = loadDataSet("input/7.AdaBoost/horseColicTraining2.txt")
weakClassArr, aggClassEst = adaBoostTrainDS(dataArr, labelArr, 40)
print weakClassArr, '\n-----\n', aggClassEst.T
# 计算ROC下面的AUC的面积大小
plotROC(aggClassEst.T, labelArr)
# 测试集合
dataArrTest, labelArrTest = loadDataSet("input/7.AdaBoost/horseColicTest2.txt")
m = shape(dataArrTest)[0]
predicting10 = adaClassify(dataArrTest, weakClassArr)
errArr = mat(ones((m, 1)))
# 测试：计算总样本数，错误样本数，错误率
print m, errArr[predicting10 != mat(labelArrTest).T].sum(), errArr[predicting10 != mat(labelArrTest).T].sum()/m