【4】Logistic回归

前言

logistic回归的主要思想：根据现有数据对分类边界建立回归公式，以此进行分类
所谓logistic，无非就是True or False两种判断，表明了这其实是一个二分类问题
我们又知道回归就是对一些数据点拟合成线性函数，但是线性函数的值域是无穷的
所以logistic和回归加在一起，就是要把取值范围从无穷映射到（0,1）上，使之成为一个二分类器
所以本文会介绍怎么拟合一个回归函数，然后再把它作为自变量输入丢进一个阶跃函数，然后输出一个（0,1）的二值结果
这就是所谓的logistic回归

本文的参考书是《机器学习实战》

sigmoid函数

由前言中知道，我们需要一个阶跃函数，不管接受什么输入，输出的都是0或1
sigmoid函数刚好满足这样的特性：

它的图形如下：

figure_1.png

当z=0时，函数值为0.5。
把自变量带入函数会得到一个0~1之间的数值，这时就可以把大于0.5的数据分为1类，小于0.5的归为0类。
所以logistic回归可以被看成是一种概率估计。
这样就完成了把无穷取值范围映射到0和1的使命。
接下来需要做的就是就是对数据点进行回归，使回归得到的结果成为sigmoid函数的输入

最佳回归系数

线性回归的形式是：

其中W就是回归系数向量，向量的每个元素对应数据的一个维度也就是一种特征

现在的任务就是确定最佳回归系数，常用的方法有最小二乘法、梯度上升法等最优化方法。

本文主要是使用梯度上升法作为讨论的基础

梯度上升法

梯度上升基于的思想是：要找函数的最大值，最好的方法是沿着该函数的梯度方向探寻，因为梯度总是指向函数增长最快的方向
有了方向，那么还要有步长才能朝着最优值移动，这个步长可以自己指定，这里设步长为alpha，那么算法的迭代公式为：

顺便提一下，相应的有个叫梯度下降的算法，用于求函数的最小值，只用把中间的加号变成减号就行了
梯度上升的伪代码如下：
  1. 每个回归系数初始化为1
  2. 重复R次:
  3.       计算整个数据集的梯度
  4.       使用 alpha * gradient 更新回归系数向量
  5. 返回回归系数

代码实现如下：
  1. # 载入测试数据，返回测试数据集和类别标签
  2. def loadDataSet():
  3.     dataMat = []
  4.     labelMat = []
  5.     fr = open(r'E:\ml\machinelearninginaction\Ch05\testSet.txt')
  6.     dataFromFile =  fr.readlines()
  7.     print len(dataFromFile)
  8.     for line in dataFromFile:
  9.         lineArr = line.strip().split()
  10.         dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
  11.         labelMat.append(int(lineArr[2]))
  12.     return dataMat, labelMat
  14. # sigmoid 函数
  15. def sigmoid(inX):
  16.     return 1.0/(1+exp(-inX))
  18. # =====================================
  19. # 梯度上升算法
  20. # 输入：
  21. #      dataMatIn: 2维数组，每列代表一种特征
  22. #      classLabels: 类别标签
  23. # 返回：逻辑回归参数
  24. # =====================================
  25. def gradAscent(dataMatIn, classLabels):
  26.     dataMat = mat(dataMatIn)# 装换成numpy矩阵
  27.     labelMat = mat(classLabels).transpose()# 转置
  28.     m, n = shape(dataMat)
  29.     weights = ones((n, 1))# 初始化权重都为1
  30.     alpha = 0.001
  31.     maxCycles = 500# 迭代次数
  32.     for i in range(maxCycles):
  33.     	# 以下三行代码是梯度上升算法的具体实现
  34.         h = sigmoid(dataMat * weights)# 矩阵乘法
  35.         error = (labelMat - h)
  36.         weights = weights + alpha * dataMat.transpose() * error
  37.     return weights
关于代码有两点需要指出，第10行中loadData函数在特征列加了一列全是1的特征。
21~23行代码是梯度上升的具体实现，由上面提到的迭代公式到这里的实现需要一些数学推导，大概来说如下：


本文的数据集用的是《机器学习实战》的testSet.txt数据集，概览图如下：

导入数据集到上面的函数得到如下结果：

这就是回归系数

画出决策函数

为了使优化过程便于理解，我们可以把这个数据集已经刚才已经得到的回归线可视化
代码如下：
  1. # 画出数据集合logistic回归最佳拟合直线的函数
  2. # 输入wei是系数向量
  3. def plotBestFit(wei):
  4.     import matplotlib.pyplot as plt
  5.     weight = wei.getA()  # 矩阵转换成数组
  6.     dataMat, labelMat = loadDataSet()
  7.     dataArray = array(dataMat)
  8.     n = shape(dataArray)[0]  # 获得数组的行数
  9.     xcord1 = []
  10.     ycord1 = []
  11.     xcord2 = []
  12.     ycord2 = []
  13.     for i in range(n):
  14.         if labelMat[i] == 1:
  15.             xcord1.append(dataArray[i, 1])
  16.             ycord1.append(dataArray[i, 2])
  17.         else:
  18.             xcord2.append(dataArray[i, 1])
  19.             ycord2.append(dataArray[i, 2])
  20.     fig = plt.figure()
  21.     ax = fig.add_subplot(111)
  22.     ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')
  23.     ax.scatter(xcord2, ycord2, s=30, c='green')
  24.     x = arange(-3.0, 3.0, 0.1)
  25.     y = (-weight[0] - weight[1] * x) / weight[2]
  26.     ax.plot(x, y)
  27.     plt.show()
figure_1.png
这就是使用梯度上升500次得到的结果，效果还不错

随机梯度上升

从上面的代码可以看出梯度上升法每次更新回归系数的时候都要遍历整个数据集，计算复杂度太高
一种改进的方法是一次只用一个样本点来更新回归系数，这种方法叫做随机梯度上升算法
这样的话，每输入一个新的样本就可以对分类器进行一次更新，这种方式叫做增量式更新，所以这个算法是一个在线学习算法
与在线学习算法相对应的，一次处理所有数据被称作“批处理”

改进后代码如下：
  1. # =========================================
  2. # 随机梯度上升算法
  3. # =========================================
  4. def stoGradAsent0(dataMatrix, classLabels):
  5. 	m, n = shape(dataMatrix)
  6. 	weights = ones(n)
  7. 	alpha = 0.001
  8. 	for i in range(m):
  9. 	    h = sigmoid(sum(dataMatrix[i] * weights))
  10. 	    err = h - classLabels[i]
  11. 	    weights = weights + alpha * err * dataMatrix[i]
  12. 	return weights
用下面的代码调用上面的函数：
  1.     data, label = loadDataSet()
  2.     wei = stocGradAscent0(array(data), label)
  3.     plotBestFit(wei)
得到如下分类结果：
figure_1.png
可以看到这个分类效果没有之前的分类效果好。但是之前的效果是迭代500次才得到的，所以不具有可比性。

改进的随机梯度上升

  1. def stocGradAscent1(dataMatrix, classLabels, numIter=150):
  2.     m,n = shape(dataMatrix)
  3.     weights = ones(n)   
  4.     for j in range(numIter):
  5.         dataIndex = range(m)
  6.         for i in range(m):
  7.         	# alpha随着迭代次数减小，但是有常数项保证永远不会小到0
  8.             alpha = 4/(1.0+j+i)+0.0001    
  9.             # 随机选取样本来更新回归系数
  10.             randIndex = int(random.uniform(0,len(dataIndex)))
  11.             h = sigmoid(sum(dataMatrix[randIndex]*weights))
  12.             error = classLabels[randIndex] - h
  13.             weights = weights + alpha * error * dataMatrix[randIndex]
  14.             del(dataIndex[randIndex])
  15.     return weights
从代码中我们可以看到主要做出了两个改进：
  1. 第八行代码表示alpha随着迭代次数减小，这是为了缓解回归系数的波动，尽快达到收敛状态（收敛是判断一个优化算法是否可靠的重要方法）。并且alpha有常数项保证永远不会小到0
  2. 第十行表示随机选取样本来更新回归系数，这样是为了减少周期波动
对数据集作20次遍历stocGradAscent1(array(data), label, 20)得到的分类效果如下：
figure_1.png
很明显效果比没有改进前的随机梯度上升算法要好多了。

例子：从疝气病预测病马的死亡率

缺失值处理

在正式开始这个例子之前我们想先讨论一下数据中的缺失值处理
因为即将用到这个数据集的原始数据集是有缺失值的，而且缺失值的处理的数据的预处理中非常重要
常用的缺失值处理方法：
  • 使用可用特征的均值填补
  • 使用特殊值来填补缺失值，比如0或-1
  • 忽略有缺失值的样本
  • 使用其他机器学习算法来预测缺失值
  • 使用相似样本对应特征的均值俩填补
以下两种情况的值缺失处理方法是不同的
  1. 特征缺失：可以丢弃此样本；否则的话，由于numpy不支持包含缺失值，所以必须要填补上
  2. 标签缺失：基本上只能直接丢弃，因为和特征值不同，它很难使用某个合适值来替换

用logistic回归进行分类

  1. # 用于为每个输入样本分类
  2. # inX为待分类的样本的特征值
  3. # weights 为训练好的权重
  4. def classifyVector(inX, weights):
  5.     prob = sigmoid(sum(inX * weights))
  6.     if prob > 0.5:
  7.         return 1
  8.     else:
  9.         return 0 
  11. def colicTest():
  12.     frTrain = open(r'E:\ml\machinelearninginaction\Ch05\horseColicTraining.txt')
  13.     frTest = open(r'E:\ml\machinelearninginaction\Ch05\horseColicTest.txt')
  14.     trainData = []
  15.     trainLabels = []
  16.     for line in frTrain.readlines():
  17.         currLine = line.strip().split('\t')
  18.         lineArr = []
  19.         for i in range(21):#这个数据集有21个特征
  20.             lineArr.append(float(currLine[i]))
  21.         trainData.append(lineArr)
  22.         trainLabels.append(float(currLine[21]))
  24.     # 用训练集作500次迭代得到权重
  25.     trainWeights = stocGradAscent1(array(trainData), trainLabels, 500)
  27.     numTestVec = 0 # 记录测试样本的数量
  28.     errorCount = 0 # 预测错误的数量
  29.     for line in frTest.readlines():
  30.         numTestVec += 1
  31.         currLine = line.strip().split('\t')
  32.         lineArr = []
  33.         for i in range(21):
  34.             lineArr.append(float(currLine[i]))
  35.         # 把训练好的权重应用到测试集上
  36.         if int(classifyVector(array(lineArr), trainWeights)) != int(currLine[21]):
  37.             errorCount += 1
  39.     errorRate = float(errorCount)/numTestVec
  40.     print 'The error rate of this test is %f' %errorRate
  41.     return errorRate
  43. def multiTest():
  44.     numTests = 10; errorSum=0.0
  45.     for k in range(numTests):
  46.         errorSum += colicTest()
  47.     print "after %d iterations the average error rate is: %f" % (numTests, errorSum/float(numTests))
测试效果如下：

每次的错误率不同是因为随机策略导致的。

小结

 LR优点：计算代价不高，易于理解和实现
LR缺点：容易欠拟合，分类精度可能不高
使用数据类型：数值型和标称型

梯度上升是非常常用的最优化方法
随机梯度上升算法降低了计算复杂度，而且这是一个在线学习算法

缺失数据处理是数据分析乃至机器学习的重要组成部分，它没有标准的做法，取决于具体情况的不同






posted @ 2016-04-21 15:47  木白的菜园  阅读(500)  评论(0)    收藏  举报