机器学习之logistic回归算法

一:Sigmoid函数和Logistic回归分类器

1:Sigmoid函数

单位阶跃函数(或者称为海维塞德阶跃函数):在二分问题下,函数的输出类别是0和1,Simoid函数就是属于这种函数
其函数表达式为:

其显示的图象为:
                            

2:Logistic回归分类器

Simoid函数的输入记为:z=w0x0 + w1x1 + w2x2 .... + wnxn
如果采用向量的写法,上述公式可以写成z=w^t * x(w^t表示系数w的转置矩阵)
代入到Sigmoid函数可得:
其输出分大于0.5和小于0.5,表示两个类别,也就实现了分类,确定了分类器的函数形式,接下来问题就是求最佳回归系数


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

2.1:梯度上升法

主要思想:要找到某函数的最大值,最好的办法是沿着该函数的梯度方向探寻
下边这种图片是机器学习实战对梯度的数学解释:

       梯度是有方向的,总是沿着函数值上升最快的方向移动(这有点感觉想物理中的加速度),因此我们沿着梯度方向或者反方向行进时,就能达到一个函数的最大值或者最小值,因此梯度上升算法就是不断更新梯度值,直到梯度不再变化或者变化很小,即函数达到了最大值
梯度算法的迭代公式为(alpha为步长,即每一步移动量):

那么问题来了,我们如何求解函数的梯度,在 Machine Learning in Action一书中,作者没有解释,直接给出了代码
[python]  view plain  copy
  1. h = sigmoid(dataMatrix*weights)    
  2. error = (labelMat - h)    
  3. weights = weights + alpha * dataMatrix.transpose()* error  
当然在实战这本书也没有具体说明(这里有一篇博客对这个公式进行了猜想推测:http://blog.sina.com.cn/s/blog_61f1db170101k1wr.html  

求梯度上升算法的代码,并画出图形:
[python]  view plain  copy
  1. #coding:utf-8  
  2. ''''' 
  3. Created on 2016/4/24 
  4.  
  5. @author: Gamer Think 
  6. '''  
  7. from numpy import *  
  8.   
  9. #加载数据集  
  10. def loadDataSet():  
  11.     dataMat = []  
  12.     labelMat = []  
  13.     fp = open("ex1.txt")  
  14.     for line in fp.readlines():  
  15.         lineArr = line.strip().split("\t"#每行按\t分割  
  16.         dataMat.append([1.0,float(lineArr[0]), float(lineArr[1])])  
  17.         labelMat.append(float(lineArr[2]))  
  18.   
  19.     return dataMat,labelMat  
  20.   
  21. #定义Sigmoid函数  
  22. def sigmoid(inX):  
  23.     return 1.0/(1+exp(-inX))  
  24.   
  25. #定义求解最佳回归系数  
  26. def gradAscent(dataMatIn,classLabels):  
  27.     dataMatrix = mat(dataMatIn) #将数组转为矩阵  
  28.     labelMat = mat(classLabels).transpose()  
  29.     m,n = shape(dataMatrix)      #返回矩阵的行和列  
  30.     alpha = 0.001      #初始化 alpha的值  
  31.     maxCycles = 500    #最大迭代次数  
  32.     weights = ones((n,1)) #初始化最佳回归系数  
  33.     for i in range(0,maxCycles):  
  34.         #引用原书的代码,求梯度  
  35.         h = sigmoid(dataMatrix*weights)  
  36.         error = labelMat - h  
  37.         weights = weights + alpha * dataMatrix.transpose() * error  
  38.   
  39.     return weights  
  40.   
  41. #分析数据,画出决策边界  
  42. def plotBestFit(wei,dataMatrix,labelMat):  
  43.     import matplotlib.pyplot as plt  
  44.     weights = wei.getA()     #将矩阵wei转化为list  
  45.     dataArr = array(dataMatrix)  #将矩阵转化为数组  
  46.     n = shape(dataMatrix)[0]  
  47.     xcord1 = [];ycord1=[]  
  48.     xcord2 = [];ycord2=[]  
  49.   
  50.     for i in range(n):  
  51.         if int(labelMat[i])==1:  
  52.             xcord1.append(dataArr[i,1])  
  53.             ycord1.append(dataArr[i,2])  
  54.         else:  
  55.             xcord2.append(dataArr[i,1])  
  56.             ycord2.append(dataArr[i,2])  
  57.   
  58.     fig = plt.figure()  
  59.     ax = fig.add_subplot(111)  
  60.     ax.scatter(xcord1,ycord1,s=30,c='red', marker='s')  
  61.     ax.scatter(xcord2,ycord2,s=30,c="green")  
  62.     x = arange(-3.0,3.0,0.1)  
  63.     y = (-weights[0]-weights[1] * x)/weights[2]  
  64.     ax.plot(x,y)  
  65.     plt.xlabel("x1")     #X轴的标签  
  66.     plt.ylabel("x2")     #Y轴的标签  
  67.     plt.show()  
  68.   
  69. if __name__=="__main__":  
  70.     dataMatrix,labelMat = loadDataSet()  
  71.     weight = gradAscent(dataMatrix, labelMat)  
  72.     plotBestFit(weight,dataMatrix,labelMat)  
显示效果图:


2.2随机梯度上升算法

      梯度上升算法在每次更新回归系数时都需要遍历整个数据集,该方法在处理100个左右的数据集尚可,但如果数据量增大,那该方法的计算量就太大了,有一种改进方法是一次仅用一个样本点来更新回归系数,该方法称为随机梯度上升算法,由于可以在新样本到来时对分类器进行增量式更新,因而随机梯度上升算法是一个在线学习算法。
随机梯度上升算法的代码如下:
[python]  view plain  copy
  1. <span style="font-size:18px;">#随机梯度上升算法求回归系数  
  2. def stocGradAscent0(dataMatrix,labelMat):   
  3.     dataMatrix = array(dataMatrix)  
  4.     m,n = shape(dataMatrix)  
  5.     alpha = 0.01  
  6.     weights = ones(n)  
  7.     for i in range(0,m):  
  8.         h = sigmoid(sum(dataMatrix[i]*weights))  
  9.         error = labelMat[i] - h  
  10.         weights = weights + alpha *  error * dataMatrix[i]  
  11.   
  12.     return weights</span><span style="font-size: 14px;">  
  13. </span>  

main函数调用代码:
[python]  view plain  copy
  1. #随机梯度上升算法  
  2.     weight = stocGradAscent0(dataMatrix, labelMat)  
  3.     print weight  
  4.     plotBestFit(weight,dataMatrix,labelMat)  

显示效果图如下


2.3改进版的随机梯度上升算法

存在一些不能正确分类的点样本点(数据集并非线性可分),在每次迭代时会引发系数的剧烈变化。我们期望算法能够避免来回波动,从而收列到某个值
[python]  view plain  copy
  1. <span style="font-size:18px;">#改进版的随机梯度上升算法  
  2. def stocGradAscent1(dataMatrix,labelMat,numIter=150):  
  3.     m,n = shape(dataMatrix)  
  4.     weights = ones(n)  
  5.     for i in range(0,numIter):  
  6.         dataIndex = range(m)  
  7.         for j in range(0,m):  
  8.             alpha = 4/(1.0+j+i)+0.01  #(1)  
  9.             randIndex = int(random.uniform(0,len(dataIndex)))    #(2)  
  10.             h = sigmoid(sum(dataMatrix[randIndex] * weights))  
  11.             error = labelMat[randIndex] - h  
  12.             weights = weights + alpha * error * dataMatrix[randIndex]  
  13.             del(dataIndex[randIndex])  
  14.   
  15.     return weights   </span><span style="font-size: 14px;">      
  16. </span>  
(1):alpha在每次 迭代的时候都会调整,会缓解数据波动和高频波动,另外alpha会随着迭代次数不断减小,但永远不会减小到0,这是因为(1)中存在一个常数项,这样做的目的是保证在多次迭代后新数据仍有一定的影响力,如果处理的问题是动态的,可以适当加大上边的常数项,来保证新的书获得更大的回归系数,另外一点值得注意的是,在降低alpha的函数中,alpha每次减小1/(j+i),其中j是迭代次数,i是样本点的下标,这样当j<<max(i)时,alpha就不是严格下降的,避免参数的严格下降也是常见于模拟退火算法等其他优化算法中
(2):通过随机选择样本来更新回归系数,这样方法将减小周期性波动,每次随机从列表中选出一个值,然后从列表中删除该值。
此外增加了一个迭代次数作为第三个参数,如果不给定的话,默认是150次。

main函数调用代码:
[python]  view plain  copy
  1. <span style="font-size:18px;"#改进版的随机梯度上升算法  
  2.     weight = stocGradAscent1(array(dataMatrix), labelMat)  
  3.     print weight  
  4.     plotBestFit(weight,dataMatrix,labelMat)</span>  

显示效果图如下:



数据集内容如下:
-0.017612   14.053064   0  
-1.395634   4.662541    1  
-0.752157   6.538620 0  
-1.322371   7.152853    0  
0.423363 11.054677   0  
0.406704    7.067335    1  
0.667394    12.741452   0  
-2.460150   6.866805    1  
0.569411    9.548755    0  
-0.026632   10.427743   0  
0.850433    6.920334    1  
1.347183    13.175500   0  
1.176813    3.167020    1  
-1.781871   9.097953    0  
-0.566606   5.749003    1  
0.931635    1.589505    1  
-0.024205   6.151823    1  
-0.036453   2.690988    1  
-0.196949   0.444165    1  
1.014459    5.754399    1  
1.985298    3.230619    1  
-1.693453   -0.557540   1  
-0.576525   11.778922   0  
-0.346811   -1.678730   1  
-2.124484   2.672471    1  
1.217916    9.597015    0  
-0.733928   9.098687    0  
-3.642001   -1.618087   1  
0.315985    3.523953    1  
1.416614    9.619232    0  
-0.386323   3.989286    1  
0.556921    8.294984    1  
1.224863    11.587360   0  
-1.347803   -2.406051   1  
1.196604    4.951851    1  
0.275221    9.543647    0  
0.470575    9.332488    0  
-1.889567   9.542662    0  
-1.527893   12.150579   0  
-1.185247   11.309318   0  
-0.445678   3.297303    1  
1.042222    6.105155    1  
-0.618787   10.320986   0  
1.152083    0.548467    1  
0.828534    2.676045    1  
-1.237728   10.549033   0  
-0.683565   -2.166125   1  
0.229456    5.921938    1  
-0.959885   11.555336   0  
0.492911    10.993324   0  
0.184992    8.721488    0  
-0.355715   10.325976   0  
-0.397822   8.058397    0  
0.824839    13.730343   0  
1.507278    5.027866    1  
0.099671    6.835839    1  
-0.344008   10.717485   0  
1.785928    7.718645    1  
-0.918801   11.560217   0  
-0.364009   4.747300    1  
-0.841722   4.119083    1  
0.490426    1.960539    1  
-0.007194   9.075792    0  
0.356107    12.447863   0  
0.342578    12.281162   0  
-0.810823   -1.466018   1  
2.530777    6.476801    1  
1.296683    11.607559   0  
0.475487    12.040035   0  
-0.783277   11.009725   0  
0.074798    11.023650   0  
-1.337472   0.468339    1  
-0.102781   13.763651   0  
-0.147324   2.874846    1  
0.518389    9.887035    0  
1.015399    7.571882    0  
-1.658086   -0.027255   1  
1.319944    2.171228    1  
2.056216    5.019981    1  
-0.851633   4.375691    1  
-1.510047   6.061992    0  
-1.076637   -3.181888   1  
1.821096    10.283990   0  
3.010150    8.401766    1  
-1.099458   1.688274    1  
-0.834872   -1.733869   1  
-0.846637   3.849075    1  
1.400102    12.628781   0  
1.752842    5.468166    1  
0.078557    0.059736    1  
0.089392    -0.715300   1  
1.825662    12.693808   0  
0.197445    9.744638    0  
0.126117    0.922311    1  
-0.679797   1.220530    1  
0.677983    2.556666    1  
0.761349    10.693862   0  
-2.168791   0.143632    1  
1.388610    9.341997    0  
0.317029    14.739025   0  

猜你喜欢

转载自blog.csdn.net/pql925/article/details/79289169