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

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

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

《机器学习实战中文版》

《机器学习》周志华

《统计学习方法》李航

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

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

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

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

操作系统：windows8.1

python版本：python3.6

运行环境：spyder（anaconda）

# -*- coding: utf-8 -*-
"""
Created on Wed Feb 14 10:03:44 2018

@author: Lelouch_C.C
"""
from numpy import *

#导入样本信息,并储存
#testSet.txt中样本信息：100个样本点，2个数值型特征，最后一列是类别标签
def loadDataSet():
    dataMat = []; labelMat = []
    fr = open('testSet.txt')
    for line in fr.readlines():
        lineArr = line.strip().split()
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
        #dataMat第0列特征设为1.0是为了方便计算，实际上将常数项回归系数初始化为1
        labelMat.append(int(lineArr[2]))#读取标签
    return dataMat,labelMat
"""
if __name__=='__main__':
    dataMat,labelMat=loadDataSet()
    print ('dataMat:\n',dataMat)
#"""
    
def sigmoid(inX):
    return 1/(1+exp(-inX))       

#
def gradAscent(dataMatIn, classLabels):    
    """
    函数说明：logistic回归梯度上升优化算法
    参数：dataMatIn是一个2维numpy数组,100*3以列表为元素的列表                     
        (这里说2维是因为python是从0开始计数的,且第0维均为1.我是这样认为的)
          classLabels是类别标签
    """
    dataMatrix = mat(dataMatIn)             
    #转换为numpy矩阵，100*3（python对numpy数组和矩阵有不同的操作方法）
    #print ('dataMatrix:\n',dataMatrix)
    labelMat = mat(classLabels).transpose() #同上，1*100，并转置
    #print ('labelMat:\n',labelMat)
    m,n=shape(dataMat)                      #获取数据集矩阵的行数和列数
    alpha = 0.001                           #步长/学习速率
    maxCycles = 500                         #迭代次数
    weights = ones((n,1))           #初始化回归系数向量，每个维度均为1.0，3行1列
    #print(type(weights))           #,weights是array类型
    for k in range(maxCycles):              
        h = sigmoid(dataMatrix*weights)     
        #*对矩阵做代数上的矩阵乘法，（*对数组做对应位置元素相乘），这点要记清楚。
        #尽管这里是matrix*array，但这里执行矩阵乘法操作，这里array形状像矩阵
        error = (labelMat - h)              
        weights = weights + alpha * dataMatrix.transpose()* error 
        #梯度上升更新公式，这部分涉及到一个数学推理，见附图，
    #print(type(weights))           
    #此处weights是matrix类型
    return weights
"""
if __name__=='__main__':
    dataMat,labelMat=loadDataSet()
    weights=gradAscent(dataMat,labelMat)
    print (weights)
    #输出：[[ 4.12414349]
    #       [ 0.48007329]
    #       [-0.6168482 ]]
#"""
    
import matplotlib.pyplot as plt

#画出数据集和logistic回归最佳拟合直线的函数    
def plotBestFit(wei):                             #参数wei是权重weights的省略    
    weights =wei#.getA()      #在梯度上升优化算法中要加上.getA(),将矩阵转换为数组
    dataMat,labelMat=loadDataSet()
    dataArr = array(dataMat)
    n = shape(dataArr)[0]     #读取样本个数
    xcord1 = []; ycord1 = []
    xcord2 = []; ycord2 = []
    for i in range(n):
        if int(labelMat[i])== 1:  #进行分类，将1类横纵坐标分别存入xcord1，ycord1
            xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])
        else:                     #同上
            xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')
    ax.scatter(xcord2, ycord2, s=30, c='green')
    x = arange(-3.0, 3.0, 0.1)  
    #arange是numpy模块中的函数，使用前需要先导入此模块，arange()返回array类型对象，
    #range()中的步长不能为小数，但是np.arange()中的步长可以为小数
    y = (-weights[0]-weights[1]*x)/weights[2]     
    #由公式，0=w0x0+w1x1+w2x2。令x=x1，y=x2，移项即得。
    #此处提醒一句：x是array类型，但形状像列表，weights不能是matrix类型。否则，*计算出错
    #这里我已经尽力讲解了，仔细体会，其实就是作数学运算对应不上。
    ax.plot(x, y)
    plt.xlabel('X1'); plt.ylabel('X2');
    plt.show()
"""
if __name__=='__main__':           #运行这一步时，开启67行.getA()，运行完关闭
    dataMat,labelMat=loadDataSet()
    weights=gradAscent(dataMat,labelMat)
    plotBestFit(weights)
#"""
    
"""
#随机梯度上升算法
def stocGradAscent0(dataMatrix, classLabels):
    m,n = shape(dataMatrix)
    alpha=0.01
    weights = ones(n)              #weights是array类型，但形状像列表
    for i in range(m):
        h = sigmoid(sum(dataMatrix[i]*weights))   #此处*执行对应元素相乘
        error = classLabels[i] - h
        weights = weights + alpha*error*dataMatrix[i]        #*作用同上
    #print(type(weights))          #
    #此处weights是array类型
    return weights
if __name__=='__main__':
    dataArr,labelMat=loadDataSet()
    weights=stocGradAscent0(array(dataArr),labelMat)
    plotBestFit(weights)
#"""
#改进的随机梯度上升算法
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m,n = shape(dataMatrix)
    weights = ones(n)   
    for j in range(numIter):
        dataIndex = list(range(m))
        for i in range(m):
            alpha = 4/(1.0+j+i)+0.0001    #alpha学习速率
            #alpha每次迭代的时候都会调整，这会缓解数据波动和高频波动
            #另外，alpha会随着迭代次数不断减小，但永远不会减小到0,每次减小1/(j+i)
            randIndex = int(random.uniform(0,len(dataIndex)))   
            #从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，
            h = sigmoid(sum(dataMatrix[randIndex]*weights))
            error = classLabels[randIndex] - h
            weights = weights + alpha * error * dataMatrix[randIndex]
            #此处*执行array对应元素相乘
            del(dataIndex[randIndex])
    return weights
"""
if __name__=='__main__':
    dataArr,labelMat=loadDataSet()
    weights=stocGradAscent1(array(dataArr),labelMat)
    plotBestFit(weights)
#"""
    
#示例：从疝气病症状预测病马的死亡率
    
#训练+测试算法
    
#logistic回归分类函数    
def classifyVector(inX, weights):
    prob = sigmoid(sum(inX*weights))
    if prob > 0.5: return 1.0
    else: return 0.0

#样本：368个样本点，28个特征，最后一列是类别标签    
def colicTest():
    frTrain = open('horseColicTraining.txt')          #打开训练数据                             
    frTest = open('horseColicTest.txt')               #打开测试数据                                
    trainingSet = []; trainingLabels = []
    for line in frTrain.readlines():                  #遍历训练样本，读取数据
        currLine = line.strip().split('\t')    #currLine是一个字符串列表，下面转换
        lineArr = []
        for i in range(len(currLine)-1):       #遍历训练样本的每个值，除最后一列
            lineArr.append(float(currLine[i]))
        trainingSet.append(lineArr)
        trainingLabels.append(float(currLine[-1]))
    trainWeights = stocGradAscent1(array(trainingSet), trainingLabels, 500)  
    #通过训练数据集求的回归权重/系数，迭代500次      
    errorCount = 0; numTestVec = 0.0
    for line in frTest.readlines():                   #遍历训练样本，读取数据
        numTestVec += 1.0
        currLine = line.strip().split('\t')
        lineArr =[]
        for i in range(len(currLine)-1):              #依次遍历测试样本的每个值
            lineArr.append(float(currLine[i]))
        if int(classifyVector(array(lineArr), trainWeights))!= int(currLine[-1]):
            errorCount += 1
    errorRate = (float(errorCount)/numTestVec) * 100                                 
    print("测试集错误率为: %.2f%%" % errorRate)
    return errorRate

def multiTest():                  #由于用到随机，测试多次取平均值，这里测试10次
    numTests = 10; errorSum=0.0
    for k in range(numTests):
        errorSum += colicTest()   #10次总的错误率
    print ("在%d次迭代后平均错误率是: %.2f%%" % (numTests, errorSum/float(numTests)))
"""            
if __name__=='__main__':
    multiTest()              #这步运行比较慢，由于用到随机，测试多次结果可能不一样
    #测试集错误率为: 28.36%
    #测试集错误率为: 40.30%
    #测试集错误率为: 26.87%
    #测试集错误率为: 29.85%
    #测试集错误率为: 35.82%
    #测试集错误率为: 34.33%
    #测试集错误率为: 41.79%
    #测试集错误率为: 32.84%
    #测试集错误率为: 32.84%
    #测试集错误率为: 34.33%
    #在10次迭代后平均错误率是: 33.73%
#"""