机器学习实战_Python3.7_Logistic回归

Logistic 回归，算法思想是使用 sigmoid( W * X ) 来预测结果，将特征置以不同权制相加，再加上一个偏置量，得到的值经过 sigmoid 函数的处理，进行预测。

其中 W 向量是我们要根据训练集数据得到的，这里用的方法为梯度下降法，以及为了减少运算量而采用的随机梯度下降法。

算法特别的细节是对学习率和迭代次数这两个参数的选取，需要深入理解算法原理以及算法迭代过程中的现象，尽可能用更少的迭代次数得到稳定的预测结果。

当数据特征为 2 个时，可以直观地观察散点图和分割线理解算法的预测效果，在此基础上建立对 Logistic 回归的直观理解，从而拓展到更高维度的数据处理。

---

梯度下降算法

from numpy import *

#加载文本数据，每个数据特征向量 x = [1,x1,x2]
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])])
        labelMat.append(int(lineArr[2]))
    return dataMat, labelMat

#定义 sigmoid 函数
def sigmoid(intX):
    return 1.0 / (1 + exp(-intX))

#梯度下降算法
def gradAscent(dataMatIn, classLabels):
    #转化为 Numpy 矩阵类型
    dataMatrix = mat(dataMatIn)
    labelMat = mat(classLabels).T
    m,n = shape(dataMatrix)
    #设置参数：步长
    alpha = 0.001
    #设置参数：迭代次数
    maxCycles = 500
    #初始化 W 为全 1
    weights = ones((n,1))
    #训练 W
    for k in range(maxCycles):
        h = sigmoid(dataMatrix * weights)
        error = labelMat - h
        weights += alpha * dataMatrix.T * error
    return weights

执行：

dataArr,labelMat = loadDataSet()
weight = gradAscent(dataArr,labelMat)
print(weight)

得到结果：

[[ 4.12414349]
 [ 0.48007329]
 [-0.6168482 ]]

绘图为：

这里可以稍作更改，增加一个 x1 * x2 的特征量，这样就可以得到一个曲线图：

#加载文本数据，每个数据特征向量 x = [1,x1,x2,x1*x2]
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]), float(lineArr[0]) * float(lineArr[1])])
        labelMat.append(int(lineArr[2]))
    return dataMat, labelMat

得到结果为：

[[ 4.11276384]
 [ 0.30313152]
 [-0.6193877 ]
 [ 0.0273798 ]]

绘图为：

---

随机梯度下降算法

#随机梯度下降算法
def stocGradAscent0(dataMatrix, classLabels):
    m,n = shape(dataMatrix)
    alpha = 0.01
    weights = ones(n)
    #每次仅用一个样本点来修正参数
    for i in range(m):
        h = sigmoid(sum(dataMatrix[i] * weights))
        error = classLabels[i] - h
        weights += alpha * error * dataMatrix[i]
    return weights

效果：

dataArr,labelMat = loadDataSet()
weight = stocGradAscent0(array(dataArr),labelMat)
print(weight)

[ 0.81854256  0.73314303 -0.1702128 ]

绘图为：

这里误差是比较大的，但是这里每个样本只使用了一次，我们尝试修改算法，让遍历次数变多：

#随机梯度下降算法
def stocGradAscent0(dataMatrix, classLabels):
    m,n = shape(dataMatrix)
    alpha = 0.01
    weights = ones(n)
    #每次仅用一个样本点来修正参数
    for j in range(200):
        for i in range(m):
            h = sigmoid(sum(dataMatrix[i] * weights))
            error = classLabels[i] - h
            weights += alpha * error * dataMatrix[i]
    return weights

得到的结果绘图为：

这样效果就接近前面的算法了，可以进一步讨论这个算法的收敛性，这里就不展开了。

基于随机梯度下降算法做一些改进用于克服波动：

• 学习率随迭代次数不断减小
• 将样本选取的次序随机化

#改进的随机梯度下降算法
def stocGradAscent1(dataMatrix, classLabels):
    m, n = shape(dataMatrix)
    weights = ones(n)
    #设置迭代次数
    numIter = 150
    for j in range(numIter):
        #每次迭代以随机顺序读取全部样本对分割线进行修正
        #维护一个 dataIndex 数组用于随机选择样本，并删除已用过的样本
        dataIndex = list(range(m))
        for i in range(m):
            alpha = 4 / (1.0 + i + j) + 0.01
            randIndex = int(random.uniform(0, len(dataIndex)))
            h = sigmoid(sum(dataMatrix[randIndex] * weights))
            error = classLabels[randIndex] - h
            weights += alpha * error * dataMatrix[randIndex]
            del(dataIndex[randIndex])
    return weights

得到的结果绘图为：

效果近似。

这里附上用于打印散点图的函数：

def plotBestFit(weights):
    import matplotlib.pyplot as plt
    dataMat,labelMat=loadDataSet()
    dataArr = array(dataMat)
    n = shape(dataArr)[0]
    xcord1 = []
    ycord1 = []
    xcord2 = []
    ycord2 = []
    for i in range(n):
        if int(labelMat[i])== 1:
            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)
    y = (-weights[0]-weights[1]*x)/weights[2]
    ax.plot(x, y)
    plt.xlabel('X1')
    plt.ylabel('X2')
    plt.show()

---

预测病马的死亡率

使用的是改进的随机梯度下降算法，这部分程序就是数据处理和传送，以及对处理结果对统计：

#根据训练得到的 weight 对训练集数据分类
def classifyVector(inX, weights):
    prob = sigmoid(sum(inX * weights))
    if prob > 0.5:
        return 1.0
    else:
        return 0.0

#训练与测试函数
def colicTest():
    #读取训练集和测试集数据
    frTrain = open('horseColicTraining.txt')
    frTest = open('horseColicTest.txt')
    trainingSet = []
    trainingLabel = []
    for line in frTrain.readlines():
        currLine = line.strip().split('\t')
        lineArr = []
        for i in range(21):
            lineArr.append(float(currLine[i]))
        trainingSet.append(lineArr)
        trainingLabel.append(float(currLine[21]))
    #训练 weight
    trainWeights = stocGradAscent1(array(trainingSet), trainingLabel)
    #测试并统计错误率
    errorCount = 0
    numTestVec = 0.0
    for line in frTest.readlines():
        numTestVec += 1.0
        currLine = line.strip().split('\t')
        lineArr = []
        for i in range(21):
            lineArr.append(float(currLine[i]))
        if int(classifyVector(array(lineArr), trainWeights)) != int(currLine[21]):
            errorCount += 1
    errorRate = (float(errorCount) / numTestVec)
    print("The error rate of this test is: %f" % errorRate)
    return errorRate

#对多次训练结果进行测试，并统计平均错误率
def multiTest():
    numTests = 10
    errorSum = 0.0
    for k in range(numTests):
        errorSum += colicTest()
    errorRate = errorSum / float(numTests)
    print("After %d iterations the average error rate is: %f" % (numTests, errorRate))

得到的结果为：

The error rate of this test is: 0.358209
The error rate of this test is: 0.313433
The error rate of this test is: 0.268657
The error rate of this test is: 0.417910
The error rate of this test is: 0.462687
The error rate of this test is: 0.373134
The error rate of this test is: 0.328358
The error rate of this test is: 0.402985
The error rate of this test is: 0.313433
The error rate of this test is: 0.358209
After 10 iterations the average error rate is: 0.359701

Process finished with exit code 0

值得注意的是，这里的数据集约有 30% 的缺失值，这里引出了缺失值处理的重要话题，本例的处理方式是：

• 缺失 label：直接丢弃
• 缺失特征：置 0

这个算法中，将某个特征置 0，就相当于一个特殊值，在这个样本对分割线/面进行修正时，值为 0 的特征是没有贡献的，不会改变对应的 weight 参数。