《机器学习实战》笔记之五——Logistic回归

第五章 Logistic回归

回归：对一些数据点，算法训练出直线参数，得到最佳拟合直线，能够对这些点很好的拟合。

训练分类器主要是寻找最佳拟合参数，故为最优化算法。

5.1 基于Logistic回归和sigmoid函数的分类

实现Logistic回归分类器：在每个特征上都乘以一个回归系数，然后把所有的结果值相加，总和带入sigmoid函数，其结果大于0.5分为第0类，结果小于0.5分为第0类。

sigmoid函数公式：

Figure 5-1: sigmoid函数公式

Figure 5-2: sigmoid曲线

sigmoid函数具有很好的性质，如其导数可以用其本身表示等等。

5.2 基于最优化方法的最佳回归系数确定

sigmoid函数输入z:

其可以写成z=w.T*x，向量x为分类器的输入数据， w为训练器寻找的最佳参数。

梯度上升法：

思想：要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻。

函数f(x,y)的梯度：

沿x的方向移动，沿y的方向移动，最后能够到达最优点，但是f(x,y)在待计算点需要有定义并且可微。

梯度算子总是指向函数值增长最快的方向。移动方向为梯度方向，移动量大小需要乘以一个参数，称之为步长。参数迭代公式为：

公式可一直执行，直到某个条件停止为止。如迭代次数或者算法达到某个可以允许的误差范围。

训练算法：使用梯度上升找到最佳参数

梯度上升法伪代码：

数据点：

算法：

[python]  view plain  copy

1. def loadDataSet():  
2.     dataMat  = []  
3.     labelMat = []  
4.     fr = open("testSet.txt")  
5.     for line in fr.readlines():  
6.         lineArr = line.strip().split("\t")  
7.         dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])]) #对应三个参数，第一个对应着常熟  
8.         labelMat.append(int(lineArr[2]))  
9.     return dataMat, labelMat  
10.   
11. def sigmoid(inX):  
12.     return 1.0/(1+exp(-inX))  
13.       
14. def gradAscent(dataMatIn, classLabels):  
15.     '''''Logistic回归梯度上升优化算法'''  
16.     dataMatrix = mat(dataMatIn)                         #100行3列  
17.     labelMat   = mat(classLabels).transpose()           #transpose()将1行100列的矩阵转为100行1列mat(classLabels).T也可破  
18.     m,n        = shape(dataMatrix)                      #m=100,n=3  
19.     alpha      = 0.001  
20.     maxCycles  = 500  
21.     weights    = ones((n,1))                            #100行1列  
22.     for k in range(maxCycles):  
23.         h       = sigmoid(dataMatrix*weights)           #dataMatrix*weights，100×3和3×1的矩阵相乘，得到100×1的矩阵  
24.         error   = (labelMat - h)  
25.         weights = weights + alpha*dataMatrix.transpose()*error  
26.     return weights  
27. dataMat, labelMat = loadDataSet()  
28. weights = gradAscent(dataMat, labelMat)  
29. print weights     

Figure5-4: 算法参数

分析数据：画出决策边界

上一步确定了回归系数，确定了不同类别数据之间的分割线。这一步画出分割线：

[python]  view plain  copy

1. def plotBestFit(weights):  
2.     dataMat, labelMat = loadDataSet()  
3.     dataArr           = array(dataMat)              #将每个数据点的x,y坐标存为矩阵的形式  
4.     n                 = shape(dataArr)[0]           #取其行数,也即数据点的个数  
5.     #======画数据点  
6.     xcord1 = []  
7.     ycord1 = []      
8.     xcord2 = []  
9.     ycord2 = []  
10.     for i in range(n):  
11.         if int(labelMat[i]) == 1:                   #若是正例，存到(x1,y1)中  
12.             xcord1.append(dataArr[i,1])  
13.             ycord1.append(dataArr[i,2])  
14.         else:  
15.             xcord2.append(dataArr[i,1])  
16.             ycord2.append(dataArr[i,2])  
17.     fig = plt.figure()  
18.     ax  = fig.add_subplot(111)  
19.     ax.scatter(xcord1,ycord1,s=30,c="red",marker = "s")  
20.     ax.scatter(xcord2,ycord2,s=30,c="green")  
21.     #============  
22.     x = arange(-3.0,3.0,0.1)                    #x为numpy.arange格式，并且以0.1为步长从-3.0到3.0切分。  
23.     #拟合曲线为0 = w0*x0+w1*x1+w2*x2, 故x2 = (-w0*x0-w1*x1)/w2, x0为1,x1为x, x2为y,故有  
24.     y = (-weights[0] - weights[1]*x)/weights[2]   
25.     #x为array格式，weights为matrix格式，故需要调用getA()方法，其将matrix()格式矩阵转为array()格式  
26.     ax.plot(x,y)  
27.     plt.xlabel("X1")  
28.     plt.ylabel("X2")  
29.     plt.show()  
30. dataMat, labelMat = loadDataSet()  
31. weights = gradAscent(dataMat, labelMat)  
32. #getA()方法，其将matrix()格式矩阵转为array()格式，type(weights),type(weights.getA())可观察到。  
33. plotBestFit(weights.getA())  

Figure 5-5: 分割线

训练算法：随机梯度上升

梯度上升算法中，每次更新回归系数需要遍历整个数据集。数据量若是大了，计算复杂度较高。

改进方法：一次仅用一个样本点更新回归系数，这便是随机梯度上升算法。

伪代码：

代码：

[python]  view plain  copy

1. def stocGradAscent0(dataMatrix, classLabels):  
2.     '''''随机梯度上升算法'''  
3.     m,n     = shape(dataMatrix)  
4.     alpha   = 0.01  
5.     weights = ones(n)  
6.     for i in range(m):  
7.         h       = sigmoid(sum(dataMatrix[i]*weights))           #此处h为具体数值  
8.         error   = classLabels[i] - h                            #error也为具体数值  
9.         weights = weights + alpha*error*dataMatrix[i]           #每次对一个样本进行处理，更新权值  
10.     return weights  
11. dataArr, labelMat = loadDataSet()  
12. weights = stocGradAscent0(array(dataArr), labelMat)  
13. plotBestFit(weights)  

Figure 5-6: 随机梯度上升算法分割线

结果显示其效果还不如梯度上升算法，不过不一样，梯度上升算法，500次迭代每次都用上了所有数据，而随机梯度上升算法总共也只用了500次。需要对其进行改进：

[python]  view plain  copy

1. def stocGradAscent1(dataMatrix, classLabels, numIter=150):  
2.     '''''改进的随机梯度上升算法，收敛得更快'''  
3.     m,n = shape(dataMatrix)  
4.     weights = ones(n)  
5.       
6.     for j in range(numIter):  
7.         dataIndex = range(m)  
8.         for i in range(m):  
9.             alpha = 4/(1.0+i+j)+0.0001                #alpha迭代次数不断变小，1.非严格下降，2.不会到0  
10.             #随机选取样本更新系数weights,每次随机从列表中选取一个值，用过后删除它再进行下一次迭代              
11.             randIndex = int(random.uniform(0, len(dataIndex)))#每次迭代改变dataIndex,而m是不变的，故不用unifor(0, m)  
12.             h = sigmoid(sum(dataMatrix[randIndex]*weights))  
13.             error = classLabels[randIndex] - h  
14.             weights = weights + alpha*error*dataMatrix[randIndex]  
15.             del(dataIndex[randIndex])  
16.     return weights  
17.   
18. dataArr, labelMat = loadDataSet()  
19. weights = stocGradAscent1(array(dataArr), labelMat)  
20. plotBestFit(weights)  

Figure 5-7: 改进的随机梯度上升算法分割线

5.3 示例：从疝气病症预测病马的死亡率

准备数据：处理数据中的缺失值

可选做法：

• 使用可用特征的均值来填补缺失值
• 使用特殊值来填补缺失值，如-1
• 忽略有缺失值的样本
• 使用相似样本的均值添补缺失值
• 使用另外的机器学习算法预测缺失值

数据挖掘软件clementine几乎可以做以上数据预处理的工作。可破有问题的数据。

数据：

Figure 5-8: train data

Figure 5-9: test data

测试算法：用Logistic回归进行分类

[html]  view plain  copy

1. def colicTest():  
2.     frTrain              = open("horseColicTraining.txt")  
3.     frTest                = open("horseColicTest.txt")  
4.     #==========训练数据准备  
5.     trainingSet       = []  
6.     trainingLabels = []  
7.     for line in frTrain.readlines():  
8.         currLine = line.strip().split("\t")  
9.         lineArr   = []  
10.         for i in range(21):  
11.             lineArr.append(float(currLine[i]))  
12.         trainingSet.append(lineArr)  
13.         trainingLabels.append(float(currLine[21]))  
14.     #==========  
15.     trainWeights = stocGradAscent1(array(trainingSet), trainingLabels, 500) #进行500次迭代，计算权重  
16.     errorCount = 0  
17.     numTestVec = 0.0  
18.     #========准备测试集并进行测试计算错误率  
19.     for line in frTest.readlines():  
20.         numTestVec +=1.0  
21.         currLine = line.strip().split("\t")  
22.         lineArr   = []  
23.         for i in range(21):  
24.             lineArr.append(float(currLine[i]))  
25.         if int(classifyVector(array(lineArr), trainWeights)) != int(currLine[21]):  
26.             errorCount +=1  
27.     errorRate = (float(errorCount)/numTestVec)  
28.     #=======  
29.     print "the error rate of this test is: %f" % errorRate  
30.     return errorRate  
31.   
32. def multiTest():                        #多次测试  
33.     numTests = 10  
34.     errorSum = 0.0  
35.     for k in range(numTests):  
36.         errorSum += colicTest()  
37.     print "after %s iterations the average error rate is: %f " % (numTests, errorSum/float(numTests))  

Figure 5-10: 测试结果

5.4 小结

Logistic回归：

优点： 计算代价不高，易于理解和实现。

缺点： 容易欠拟合，分类精度可能不高。

适用数据类型：数值型和标称型数据。