Logistic回归-Machine Learning In Action学习笔记

利用Logistic回归进行分类的主要思想是：根据现有数据对分类边界线建立回归公式，以此进行分类。
训练分类器时的做法就是寻找最佳拟合参数，使用的是最优化算法。

Logistic回归的一般过程
收集数据：采用任意方法收集数据。
准备数据：由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据格式则最佳。
分析数据：采用任意方法对数据进行分析。
训练算法：大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数。
测试算法：一旦训练步骤完成，分类将会很快。
使用算法：首先，我们需要一些输入数据，并将其转换成对应的结构化数值；接着，基于训练好的回归系数就可以对这些数值进行简单的回归计算，判定它们属于哪个类别；在这之后，我们就可以在输出的类别上做一些其他分析工作。

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

我们想要的函数应该是，能接受所有的输入然后预测出类别。例如，在两个类的情况下，上述函数输出0或1。
海维塞德阶跃函数（单位阶跃函数）：该函数在跳跃点上从0瞬间跳跃到1，这个瞬间跳跃过程有时很难处理。（用sigmoid改进）
Sigmoid函数（一种阶跃函数：可以用半开区间上的指示函数的有限次线性组合来表示）：可以输出0或者1，且数学上更易处理。（如果横坐标刻度足够大，在x = 0点处Sigmoid函数看起来很像阶跃函数）
计算公式：

为了实现Logistic回归分类器，我们可以在每个特征上乘以一个回归系数，然后把所有的结果值相加，将这个总和代入Sigmoid函数中，进而得到一个范围在0~1之间的数值。最后，结果大于0.5的数据被归入1类，小于0.5的即被归入0类。所以，Logistic回归也可以被看成是一种概率估计。
（Sigmoid函数的输入记为z）
最优化算法——梯度上升法：
要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻。

梯度上升法的伪代码：
每个回归系数初始化为1
重复R次：
    计算整个数据集的梯度
    使用`alpha × gradient`更新回归系数的向量
    返回回归系数

随机梯度上升算法:（在线学习算法）
一次仅用一个样本点来更新回归系数（梯度上升算法在每次更新回归系数时都需要遍历整个数据集）
在线学习：在新样本到来时对分类器进行增量式更新
批处理：一次处理所有数据

随机梯度上升算法的伪代码：
所有回归系数初始化为1  
对数据集中每个样本
        计算该样本的梯度  
        使用alpha × gradient更新回归系数值  
返回回归系数值

一个判断优化算法优劣的可靠方法是看它是否收敛，也就是说参数是否达到了稳定值，是否还会不断地变化？
存在一些不能正确分类的样本点（数据集并非线性可分），在每次迭代时会引发系数的剧烈改变。我们期望算法能避免来回波动，从而收敛到某个值。另外，收敛速度也需要加快。
改进的随机梯度上升算法：
1. alpha动态减少机制：alpha在每次迭代的时候都会调整，alpha会随着迭代次数不断减小，但永远不会减小到0，一个常数项(0.01)是为了保证在多次迭代之后新数据仍然具有一定的影响。（如果要处理的问题是动态变化的，那么可以适当加大上述常数项，来确保新的值获得更大的回归系数。）
alpha每次减少1/(j+i) ，其中j是迭代次数，i是样本点的下标 。这样当j<<max(i)时，alpha就不是严格下降的。避免参数的严格下降也常见于模拟退火算法等其他优化算法中。
2. 样本随机选择：通过随机选取样本来更新回归系数。这种方法将减少周期性的波动。


示例：使用Logistic回归估计马疝病的死亡率
收集数据：给定数据文件。
准备数据：用Python解析文本文件并填充缺失值。
分析数据：可视化并观察数据。
训练算法：使用优化算法，找到最佳的系数。
测试算法：为了量化回归的效果，需要观察错误率。根据错误率决定是否回退到训练阶段，通过改变迭代的次数和步长等参数来得到更好的回归系数。
使用算法：实现一个简单的命令行程序来收集马的症状并输出预测结果。

几种方法处理数据中的缺失值：
  • 使用可用特征的均值来填补缺失值；
  • 使用特殊值来填补缺失值，如-1；
  • 忽略有缺失值的样本；
  • 使用相似样本的均值添补缺失值；
  • 使用另外的机器学习算法预测缺失值。

此处数据集的预处理：
1. 所有的缺失值必须用一个实数值来替换，因为NumPy数据类型不允许包含缺失值。这里选择实数0来替换所有缺失值，恰好能适用于Logistic回归。原因在于：
  • 我们需要的是一个在更新时不会影响系数的值。
  • sigmoid(0)=0.5，即它对结果的预测不具有任何倾向性。
  • 将缺失值用0代替既可以保留现有数据，也不需要对优化算法进行修改。
  • 该数据集中的特征取值一般不为0，因此在某种意义上说它也满足“特殊值”这个要求。
2. 如果在测试数据集中发现了一条数据的类别标签已经缺失，那么我们的简单做法是将该条数据丢弃。

Logistic回归方法进行分类小结：
把测试集上每个特征向量乘以最优化方法得来的回归系数，再将该乘积结果求和，最后输入到Sigmoid函数中即可。如果对应的Sigmoid值大于0.5就预测类别标签为1，否则为0。

所有代码：
  1. # -*- coding:utf8 -*-
  2. from numpy import *
  5. # 梯度上升优化算法
  6. def loadDataSet():
  7.     dataMat, labelMat = [], []
  8.     fr = open('testSet.txt')
  9.     for line in fr.readlines():
  10.         lineArr = line.strip().split()
  11.         dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
  12.         labelMat.append(int(lineArr[2]))
  13.     return dataMat, labelMat
  16. def sigmoid(inX):
  17.     return 1.0 / (1 + exp(-inX))
  20. # 梯度上升算法
  21. def gradAscent(dataMatIn, classLabels):
  22.     dataMatrix = mat(dataMatIn)
  23.     labelMat = mat(classLabels).transpose()
  24.     m, n = shape(dataMatrix)
  25.     alpha = 0.001  # 向目标移动的步长
  26.     maxCycles = 500  # 迭代次数
  27.     weights = ones((n, 1))
  28.     for k in range(maxCycles):
  29.         h = sigmoid(dataMatrix * weights)
  30.         error = (labelMat - h)
  31.         weights = weights + alpha * dataMatrix.transpose() * error
  32.     return weights
  35. def plotBestFit(weights):
  36.     import matplotlib.pyplot as plt
  37.     dataMat, labelMat = loadDataSet()
  38.     dataArr = array(dataMat)
  39.     n = shape(dataArr)[0]
  40.     xcord1, ycord1, xcord2, ycord2 = [], [], [], []
  41.     for i in range(n):
  42.         if int(labelMat[i]) == 1:
  43.             xcord1.append(dataArr[i, 1])
  44.             ycord1.append(dataArr[i, 2])
  45.         else:
  46.             xcord2.append(dataArr[i, 1])
  47.             ycord2.append(dataArr[i, 2])
  48.     fig = plt.figure()
  49.     ax = fig.add_subplot(111)
  50.     ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')
  51.     ax.scatter(xcord2, ycord2, s=30, c='green')
  52.     x = arange(-3.0, 3.0, 0.1)
  53.     y = (-weights[0] - weights[1] * x) / weights[2]
  54.     ax.plot(x, y)
  55.     plt.xlabel('X1')
  56.     plt.ylabel('X2')
  57.     plt.show()
  60. # 随机梯度上升算法
  61. def stocGradAscent0(dataMatrix, classLabels):
  62.     dataMatrix = array(dataMatrix)
  63.     m, n = shape(dataMatrix)
  64.     alpha = 0.01
  65.     weights = ones(n)
  66.     for i in range(m):
  67.         h = sigmoid(sum(dataMatrix[i] * weights))
  68.         error = classLabels[i] - h
  69.         weights = weights + alpha * error * dataMatrix[i]
  70.     return weights
  73. # 改进的随机梯度上升算法
  74. def stocGradAscent1(dataMatrix, classLabels, numIter=150):
  75.     import random
  76.     m, n = shape(dataMatrix)
  77.     weights = ones(n)
  78.     for j in range(numIter):
  79.         dataIndex = range(m)
  80.         for i in range(m):
  81.             # alpha每次迭代时需要调整，一个常数项(0.01)是为了保证在多次迭代之后新数据仍然具有一定的影响
  82.             alpha = 4 / (1.0 + j + i) + 0.01
  83.             # 通过随机选取样本来更新回归系数，将减少周期性的波动
  84.             randIndex = int(random.uniform(0, len(dataIndex)))
  85.             h = sigmoid(sum(dataMatrix[randIndex] * weights))
  86.             error = classLabels[randIndex] - h
  87.             weights = weights + alpha * error * dataMatrix[randIndex]
  88.             del(dataIndex[randIndex])
  89.     return weights
  92. def classifyVector(inX, weights):
  93.     prob = sigmoid(sum(inX * weights))
  94.     if prob > 0.5:
  95.         return 1.0
  96.     else:
  97.         return 0.0
  100. def colicTest():
  101.     frTrain = open('horseColicTraining.txt')
  102.     frTest = open('horseColicTest.txt')
  103.     trainingSet, trainingLabels = [], []
  104.     for line in frTrain.readlines():
  105.         currLine = line.strip().split('\t')
  106.         lineArr = []
  107.         for i in range(21):
  108.             lineArr.append(float(currLine[i]))
  109.         trainingSet.append(lineArr)
  110.         trainingLabels.append(float(currLine[21]))
  111.     trainWeights = stocGradAscent1(array(trainingSet), trainingLabels, 500)
  113.     errorCount, numTestVec = 0, 0.0
  114.     for line in frTest.readlines():
  115.         numTestVec += 1.0
  116.         currLine = line.strip().split('\t')
  117.         lineArr = []
  118.         for i in range(21):
  119.             lineArr.append(float(currLine[i]))
  120.         if int(classifyVector(array(lineArr), trainWeights)) != int(currLine[21]):
  121.             errorCount += 1
  122.     errorRate = (float(errorCount) / numTestVec)
  123.     print "the error rate of this test is: %f" % errorRate
  124.     return errorRate
  127. def multiTest():
  128.     numTests = 10
  129.     errorSum = 0.0
  130.     for k in range(numTests):
  131.         errorSum += colicTest()
  132.     print "after %d iterations the average error rate is:%f" % (numTests, errorSum / float(numTests))

参考资料：
1. Peter Harrington《机器学习实战》第五章




posted @ 2016-05-09 10:42  woaielf  阅读(282)  评论(0)    收藏  举报