机器学习实战之——logistic回归算法学习总结

小谢

           机器学习实战之——logistic回归算法学习总结

Sigmoid函数：

     能接受所有的输入然后预测出类别，例如，在两个类的情况下，函数输出0或1.

     Sigmoid函数公式：

                          
        

如图可以看出，当x等于0时，sigmoid函数值为0.5，随着x的增大，sigmoid值将逼近于1；随着x的减少sigmoid值将逼近于0。如果横坐标足够大，sigmoid函数看起来就像一个阶跃函数。

为了实现logistic回归分类器，我们可以在每个特征上都乘以一个回归系数，然后把所有的结果值相加，将这个总和代入sigmoid函数中，进而得到一个函数在0~1之间的数值。任何大于0.5的数据被分入1类，小于0.5即被归入0类。因此，logistic回归也可以被看成是一种概率估计。

上面提到用每个特征都乘以一个回归系数，那么最佳的回归系数是多少？

Sigmoid函数的输入记为z，公式为：

                                   

其中向量x是分类器的输入数据，向量w也就是我们要找到的最佳系数，从而使得分类器尽可能的精确。寻找最佳系数，需要最优化理论知识，下面讲讲几种最优化算法。

梯度上升法：

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

        

从图可以看出，梯度算子总是沿着函数值增长最快的方向。梯度算法的公式如下：

该公式一直被迭代执行，直到达到某个条件。比如达到某个指定值或某个可以允许的误差范围。

1. #打开testSet文件并逐行读取
   
2. def loadDataSet():
   
3.     dataMat = []; labelMat=[]
   
4.     fr = open('testSet.txt')
   
5.     for line in fr.readlines():
   
6.         lineArr = line.strip().split()
   
7.         dataMat.append([1.0,float(lineArr[0]),float(lineArr[1])])
   
8.         labelMat.append(int(lineArr[2])) #标签类别
   
9. return dataMat,labelMat

复制代码

1. def sigmoid(inX):
   
2. return 1.0/(1+exp(-inX))

复制代码

1. #dataMatIn 2维numpy数组，列代表特征，行代表训练样本 classLabels 类别标签
   
2. def gradAscent(dataMatIn,classLabels):
   
3.     #转换为Numpy矩阵数据类型
   
4.     dataMatrix = mat(dataMatIn)
   
5.     labelMat = mat(classLabels).transpose()
   
6.     m,n = shape(dataMatrix)
   
7.     alpha = 0.001 #向目标移动的步长
   
8.     maxCycles= 500 #迭代次数
   
9.     weights =ones((n,1))
   
10.     for k in range(maxCycles):
    
11.         h=sigmoid(dataMatrix*weights)
    
12.         error =(labelMat-h) #h为列向量，列向量的元素个数等于样本个数
    
13.         weights = weights + alpha * dataMatrix.transpose()*error
    
14.     return weights #返回训练好的回归系数

复制代码

运行代码：

    $ python
    >>> import logRegres
    >>> dataArr,labelMat=logRegres.loadDataSet()
    >>> weights=logRegres.gradAscent(dataArr,labelMat)
        matrix([[ 4.12414349],
                [ 0.48007329],
                [-0.6168482 ]])

1. #画出决策边界
   
2. def plotBestFit(weights):
   
3.     import matplotlib.pyplot as plt
   
4.     dataMat,labelMat=loadDataSet()
   
5.     dataArr = array(dataMat)
   
6.     n = shape(dataArr)[0]
   
7.     xcord1=[];ycord1=[]
   
8.     xcord2=[];ycord2=[]
   
9.     for i in range(n):
   
10.         if int(labelMat) == 1:
    
11.            xcord1.append(dataArr[i,1]);ycord1.append(dataArr[i,2])
    
12.         else:
    
13.            xcord2.append(dataArr[i,1]);ycord2.append(dataArr[i,2])
    
14.     fig=plt.figure()
    
15.     ax=fig.add_subplot(111)
    
16.     ax.scatter(xcord1,ycord1,s=30,c='red',marker='s')
    
17.     ax.scatter(xcord2,ycord2,s=30,c='green')
    
18.     x=arange(-3.0,3.0,0.1)
    
19.     y=(-weights[0]-weights[1]*x)/weights[2]
    
20.     ax.plot(x,y)
    
21.     plt.xlabel('X1');plt.ylabel('X2')
    
22.     plt.show()

复制代码

运行代码效果：

>>> logRegres.plotBestFit(weights.getA())

               

随机梯度上升：

梯度上升算法在每次更新回归系数时都需要遍历整个数据集，如果有数十亿样本和成千上万的特征，那该方法的计算复杂度就会大大提高。改进的方法是每次仅用一个样本点来更新回归系数。这种方法称之为随机梯度上升算法。

随机梯度上升算法的实现代码如下：

1. # ①随机梯度上升算法（没有矩阵转换过程）
   
2. def stocGradAscent0(dataMatrix,classLabels):
   
3.     m,n = shape(dataMatrix)
   
4.     alpha= 0.01
   
5.     weights=ones(n)
   
6.     for i in range(m):
   
7.         # ② h,error 都代表数值
   
8.         h = sigmoid(sum(dataMatrix*weights))
   
9.         error = classLabels - h
   
10.         weights=weights + alpha * error * dataMatrix
    
11.     return weights

复制代码

其中①、②是随机梯度上升算法与梯度上升算法的区别

运行代码：

    $ python

    >>> from numpy import *
    >>> dataArr,labelMat=logRegres.loadDataSet()
    >>> weights=logRegres.stocGradAscent0(array(dataArr),labelMat)
    >>> logRegres.plotBestFit(weights)

         

与梯度上升算法相比，这里的效果相差不少，但要知道梯度上升算法的结果在数据集上迭代了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.     #j 迭代次数  i 标本点的下标
   
8.         alpha = 4/(1.0+j+i) +0.01 #①alpha 每次迭代时需要调整
   
9.         randIndex=int(random.uniform(0,len(dataIndex))) #②随机选取更新
   
10.         h = sigmoid(sum(dataMatrix[randIndex]*weights))
    
11.         error=classLabels[randIndex] -h
    
12.         weights=weights + alpha * error * dataMatrix[randIndex]
    
13.         del(dataIndex[randIndex])
    
14.     return weights

复制代码

运行代码：

     $ python

     >>> dataArr,labelMat=logRegres.loadDataSet()

     >>> weights=logRegres.stocGradAscent1(array(dataArr),labelMat)
     >>> logRegres.plotBestFit(weights)

        

使用logistic回归进行分类：

代码如下：

1. # 以回归系数和特征向量计算对应的sigmoid值
   
2. def classifyVector(inX,weights):
   
3.     prob = sigmoid(sum(inX*weights))
   
4.     if prob >0.5:return 1.0
   
5.     else: return 0.0
   
6. def colicTest():
   
7.     frTrain=open('horseColicTraining.txt')
   
8.     frTest = open('horseColicTest.txt')
   
9.     trainingSet=[];trainingLabels=[]
   
10.     for line in frTrain.readlines():
    
11.         currLine = line.strip().split('\t')
    
12.         lineArr=[]
    
13.     for i in range(21):
    
14.         lineArr.append(float(currLine))
    
15.     trainingSet.append(lineArr)
    
16.     trainingLabels.append(float(currLine[21]))
    
17.     trainWeights = stocGradAscent1(array(trainingSet),trainingLabels,500)
    
18.     errorCount = 0;numTestVec = 0.0
    
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))
    
25.         if int(classifyVector(array(lineArr),trainWeights))!=int(currLine[21]):
    
26.            errorCount +=1
    
27.     errorRate = (float(errorCount)/numTestVec)
    
28.     print "the error rate of this test is: %f" % errorRate
    
29.     return errorRate

复制代码

运行代码：

     $ python
     >>> import logRegres
     >>> logRegres.multiTest()

         

可以看到，10次的迭代结果平均错误率为35%，这个结果并不差，因为有30%的数据缺失。通过调整迭代次数和步长，平均错误率可以降到20%左右。

morinson

详细，还带了源码下载。棒