利用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《机器学习实战》第五章