基于pyhton3.6-机器学习实战-AdaBoost代码解释

本人是一名数学系研究生，于2017年底第一次接触python和机器学习，作为一名新手，欢迎与大家交流。

我主要给大家讲解代码，理论部分给大家推荐3本书：

《机器学习实战中文版》

《机器学习》周志华

《统计学习方法》李航

以上3本书，第一本是基于python2的代码实现；剩余两本主要作为第一本书理论省略部分的补充，理论大部分都讲得很细。

博客上关于机器学习实战理论解释都很多，参差不齐，好作品也大都借鉴了以上3本书，网上有很多电子版的书。

与其看看一些没用的博客，真心不如以上3本书有收获。

说实话，学习一定要静下心来，切忌浮躁。不懂可以每天看一点，每天你懂一点，天天积累就多了。

操作系统：windows8.1

python版本：python3.6

运行环境：spyder（anaconda）

# -*- coding: utf-8 -*-
"""
Created on Wed Mar  7 15:53:24 2018

@author: Loulch C.C
"""

from numpy import *
import matplotlib.pyplot as plt

#创建单层决策树的数据集
def loadSimpData():
    datMat = matrix([[ 1. ,  2.1],
        [ 1.5,  1.6],
        [ 1.3,  1. ],
        [ 1. ,  1. ],
        [ 2. ,  1. ]])
    classLabels = [1.0, 1.0, -1.0, -1.0, 1.0]
    return datMat,classLabels

#数据可视化
def showDataSet(dataMat, labelMat):
    data_plus = []                                  #正样本
    data_minus = []                                 #负样本
    for i in range(len(dataMat)):
        if labelMat[i] > 0:
            data_plus.append(dataMat[i])
        else:
            data_minus.append(dataMat[i])
    data_plus_np = array(data_plus)                        #转换为numpy矩阵
    data_minus_np = array(data_minus)                      #转换为numpy矩阵
    plt.scatter(data_plus_np.T[0], data_plus_np.T[1])      #正样本散点图
    plt.scatter(data_minus_np.T[0],data_minus_np.T[1])     #负样本散点图
    plt.show()
"""
if __name__ == '__main__':
    dataArr,classLabels = loadSimpData()
    showDataSet(dataArr,classLabels)
#"""

#单层决策树生成函数
def stumpClassify(dataMatrix,dimen,threshVal,threshIneq):
    """
    函数说明：单层决策树分类函数
    Parameters:
        dataMatrix - 数据矩阵
        dimen - 第dimen列，也就是第几个特征
        threshVal - 阈值
        threshIneq - 标志,不等号
    Returns:
        retArray - 分类结果
    """
    retArray = ones((shape(dataMatrix)[0],1))                #初始化retArray为1
    if threshIneq == 'lt':                                   #lt:less than
        retArray[dataMatrix[:,dimen] <= threshVal] = -1.0   
        #通过数组过滤，如果小于等于阈值,则赋值为-1
    else:
        retArray[dataMatrix[:,dimen] > threshVal] = -1.0    
        #通过数组过滤，如果大于阈值,则赋值为-1
    return retArray

def buildStump(dataArr,classLabels,D):
    """
    函数说明：找到数据集上"最佳"的单层决策树
    Parameters:
        dataArr - 数据矩阵
        classLabels - 数据标签
        D - 样本权重
    Returns:
        bestStump - 最佳单层决策树信息
        minError - 最小误差
        bestClasEst - 最佳的分类结果
    """
    dataMatrix = mat(dataArr); labelMat = mat(classLabels).T
    m,n = shape(dataMatrix)
    numSteps = 10.0; bestStump = {}; bestClasEst =mat(zeros((m,1)))
    minError = float('inf')                  #最小误差初始化为正无穷大
    for i in range(n):                       #第一层循环遍历数据集上所有特征
        rangeMin = dataMatrix[:,i].min(); rangeMax = dataMatrix[:,i].max() 
        #找到特征中最小的值和最大值
        stepSize = (rangeMax - rangeMin) / numSteps         #计算步长
        for j in range(-1, int(numSteps) + 1):  #用来j控制阈值threshVal，然后遍历                        
            for inequal in ['lt', 'gt']:  
                #遍历大于和小于。lt:less than，gt:greater than
                threshVal = (rangeMin + float(j) * stepSize)#计算阈值
                predictedVals = stumpClassify(dataMatrix, i, threshVal, inequal)
                #计算分类结果
                errArr = mat(ones((m,1)))                #初始化误差矩阵
                errArr[predictedVals == labelMat] = 0        
                #通过数组过滤，分类正确的,赋值为0
                weightedError = D.T * errArr             #计算误差
                print("split: dim %d, thresh %.2f, thresh ineqal: %s,\
                      the weighted error is %.3f" % (i, threshVal, inequal, weightedError))
                if weightedError < minError:             #找到误差最小的分类方式
                    minError = weightedError
                    bestClasEst = predictedVals.copy()
                    bestStump['dim'] = i
                    bestStump['thresh'] = threshVal
                    bestStump['ineq'] = inequal
    return bestStump,minError,bestClasEst
"""
if __name__ == '__main__':
    dataArr,classLabels = loadSimpData()
    D = mat(ones((5, 1)) / 5)
    bestStump,minError,bestClasEst = buildStump(dataArr,classLabels,D)
    print('bestStump:\n', bestStump)
    print('minError:\n', minError)
    print('bestClasEst:\n', bestClasEst)
#"""
#基于单层决策树的AdaBoost训练过程
def adaBoostTrainDS(dataArr, classLabels, numIt = 40):   #numIt迭代次数
    weakClassArr = []
    m = shape(dataArr)[0]
    D = mat(ones((m, 1)) / m)                            #初始化权重
    aggClassEst = mat(zeros((m,1))) #用于记录每个数据点的类别估计累计值，初始化为零
    for i in range(numIt):
        bestStump, error, classEst = buildStump(dataArr, classLabels, D)     
        #print("D:",D.T)
        alpha = float(0.5 * log((1.0 - error) / max(error, 1e-16))) 
        #计算弱学习算法权重alpha,使error不等于0,因为分母不能为0
        bestStump['alpha'] = alpha                       #存储弱学习算法权重
        weakClassArr.append(bestStump)                   #存储单层决策树
        #print("classEst: ", classEst.T)
        expon = multiply(-1 * alpha *mat(classLabels).T, classEst)#计算e的指数项
        D = multiply(D, exp(expon))                                      
        D = D / D.sum()                           #根据样本权重公式，更新样本权重
        aggClassEst += alpha * classEst        
        #alpha是每个弱分类器的权重值，每个弱分类器给出预测值都会与相应的alpha进行加权，最后输出值                         
        print("aggClassEst: ", aggClassEst.T)
        aggErrors = multiply(sign(aggClassEst) !=mat(classLabels).T, ones((m,1)))
        errorRate = aggErrors.sum() / m
        print("total error: ", errorRate)
        if errorRate == 0.0: break                   #误差为0，退出循环
    return weakClassArr, aggClassEst
"""
if __name__ == '__main__':
    dataArr,classLabels = loadSimpData()
    weakClassArr, aggClassEst = adaBoostTrainDS(dataArr, classLabels)
    print(weakClassArr)
    print(aggClassEst)
#"""

#测试算法：基于AdaBoost的分类


def adaClassify(datToClass,classifierArr):
    """
    函数说明：AdaBoost分类函数
    Parameters:
        datToClass - 待分类样例
        classifierArr - 训练好的分类器
    Returns:
        分类结果
    """
    dataMatrix =mat(datToClass)
    m = shape(dataMatrix)[0]
    aggClassEst =mat(zeros((m,1)))
    for i in range(len(classifierArr)):               #遍历所有分类器，进行分类
        classEst = stumpClassify(dataMatrix, classifierArr[i]['dim'],\
                                 classifierArr[i]['thresh'], classifierArr[i]['ineq'])            
        aggClassEst += classifierArr[i]['alpha'] * classEst
        print(aggClassEst)
    return sign(aggClassEst)
"""
if __name__ == '__main__':
    dataArr,classLabels = loadSimpData()
    weakClassArr, aggClassEst = adaBoostTrainDS(dataArr, classLabels)
    print(adaClassify([[0,0],[5,5]], weakClassArr))
#"""  
    
#示例：在一个难数据集——马疝病数据集上应用AdaBoost
def loadDataSet(fileName):
    numFeat = len((open(fileName).readline().split('\t')))
    dataMat = []; labelMat = []
    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]))
        dataMat.append(lineArr)
        labelMat.append(float(curLine[-1]))
    return dataMat, labelMat
"""
if __name__ == '__main__':
    dataArr, LabelArr = loadDataSet('horseColicTraining2.txt')
    weakClassArr, aggClassEst = adaBoostTrainDS(dataArr, LabelArr)
    testArr, testLabelArr = loadDataSet('horseColicTest2.txt')
    print(weakClassArr)
    predictions = adaClassify(dataArr, weakClassArr)
    errArr = mat(ones((len(dataArr), 1)))
    print('训练集的错误率:%.3f%%' % float(errArr[predictions !=\
                                          mat(LabelArr).T].sum() / len(dataArr) * 100))
    predictions = adaClassify(testArr, weakClassArr)
    errArr = mat(ones((len(testArr), 1)))
    print('测试集的错误率:%.3f%%' % float(errArr[predictions !=\
                                          mat(testLabelArr).T].sum() / len(testArr) * 100))
"""