Machine Learning in action --LogisticRegession 逻辑回归

本系列主要参考《机器学习实战》，使用python3编译环境，实现书中的相关代码。

1.基本算法

　　关于梯度上升算法和随机梯度上升算法的选择：

　　　　当数据集较小时，使用梯度上升算法；

　　　　当数据集较大时，使用改进的随机梯度上升算法。

 """
     使用梯度上升和随机梯度上升，解决逻辑回归
     数据的显示
 """

 import numpy as np
 import matplotlib.pyplot as plt
 import random
 """
     加载数据
 """
 def loadDataSet():
     dataMat = [] #数据列表
     labelMat = [] #标签列表
     fr = open('testSet.txt')
     for line in fr.readlines():
         #print(line)
         lineArr = line.strip().split() #去回车，放入列表
         dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])]) #添加数据
         labelMat.append(int(lineArr[2])) #添加标签
     fr.close()
     return dataMat,labelMat

 """
     绘制数据
 """
 def plotDataSet():
     dataMat,labelMat=loadDataSet()
     dataArr = np.array(dataMat) #将list或tuple变量转换成numpy的array数组
     n = np.shape(dataMat)[0] #numpy.shape返回数组每一维的大小
     xcord1 = []; ycord1 = [] #正样本
     xcord2 = []; ycord2 = [] #负样本
     for i in range(n):       #将样本集分类
         if int(labelMat[i]) == 1:
             xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])
         else:
             xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])

     fig = plt.figure()
     ax = fig.add_subplot(111)  #添加subplot
     ax.scatter(xcord1,ycord1,s = 20 , c='red', marker = 's',alpha=0.5) #绘制正样本
     ax.scatter(xcord2,ycord2,s = 20 , c='green', alpha=0.5) #绘制负样本
     plt.title("DataSet") #绘制title
     plt.xlabel('x1'); plt.ylabel('x2') #绘制label
     plt.show() #显示

 """
     sigmoid函数
 """
 def sigmoid(inX):
     return 1.0/(1 + np.exp(-inX))

 """
     梯度上升算法
 """
 def gradientAscent(dataMatIn,classLabels):
     dataMatrix = np.mat(dataMatIn) #转换为numpy矩阵
     labelMat = np.mat(classLabels).transpose() #转换为numpy矩阵，并进行转置
     m,n = np.shape(dataMatrix) #返回数组每一维的大小,m为行数，n为列数
     alpha = 0.001 #步长即学习速率
     maxCycles = 500 #最大迭代次数
     weights = np.ones((n,1)) #构造n*1的元素全为1的矩阵
     for k in range(maxCycles):  #梯度上升公式
         h = sigmoid(dataMatrix * weights)
         error = labelMat - h
         weights = weights + alpha * dataMatrix.transpose() * error
     return weights

 """
     随机梯度上升算法
     相比于梯度上升算法，有两处改进的地方：
     1.alpha在每次迭代更新是都会调整，这会缓解数据波动或者高频运动。此外，alpha还有一个常数项，目的是为了保证在多次迭代后仍然对新数据具有一定的影响，如果要处理的问题是动态变化的，可以适当加大该常数项，从而确保新的值获得更大的回归系数。
     2.更新回归系数(最优参数)时，只使用一个样本点，并且选择的样本点是随机的，每次迭代不使用已经用过的样本点。这样的方法，就有效地减少了计算量，并保证了回归效果。
 """
 def randomGradientAscent(dataMat,classLabels,numIter=150): #numIter为迭代次数默认为150
     dataMatrix = np.array(dataMat) #将list或tuple变量转换成numpy的array数组
     m,n = np.shape(dataMatrix) #返回数组每一维的大小,m为行数，n为列数
     weights = np.ones(n) #构造1*n的元素全为1的矩阵
     for j in range(numIter):
         dataIndex = list(range(m)) #获取数据集行下标列表
         for i in range(m):
             alpha = 4/(1.0+i+j)+0.01 #每次更新参数时设置动态的步长，且为保证多次迭代后对新数据仍然具有一定影响
             randIndex = int(random.uniform(0,len(dataIndex)))#随机选取样本
             h = sigmoid(sum(dataMatrix[randIndex]*weights)) #选择随机选取的一个样本，计算h
             error = classLabels[randIndex] - h #计算误差
             weights= weights + alpha* error * dataMatrix[randIndex] #更新回归系数
             del(dataIndex[randIndex]) #删除已经使用的样本
     return weights

 """
     梯度上升算法，绘制数据集和拟合直线
 """
 def plotBestFit(weights):
     dataMat,labelMat=loadDataSet()
     dataArr = np.array(dataMat) #将list或tuple变量转换成numpy的array数组
     n = np.shape(dataMat)[0] #numpy.shape返回数组每一维的大小
     xcord1 = []; ycord1 = [] #正样本
     xcord2 = []; ycord2 = [] #负样本
     for i in range(n):       #将样本集分类
         if int(labelMat[i]) == 1:
             xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])
         else:
             xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])

     fig = plt.figure()
     ax = fig.add_subplot(111)  #添加subplot
     ax.scatter(xcord1,ycord1,s = 20 , c='red', marker = 's',alpha=0.5) #绘制正样本
     ax.scatter(xcord2,ycord2,s = 20 , c='green', alpha=0.5) #绘制负样本

     x = np.arange(-3.0,3.0,0.1)
     y = (-weights[0] -weights[1] * x) / weights[2]
     ax.plot(x,y)
     plt.title("DataSet") #绘制title
     plt.xlabel('x1'); plt.ylabel('x2') #绘制label
     plt.show() #显示

 if __name__ == '__main__':
     #plotDataSet()
     dataMat,labelMat=loadDataSet()
     #weights = gradientAscent(dataMat,labelMat).getA() #(梯度上升算法)将矩阵转换为数组，返回权重数组,不转化会报错
     weights = randomGradientAscent(dataMat,labelMat) #(随机梯度上升算法)
     plotBestFit(weights)

2.从疝气病症预测病马的死亡率

 """
     使用随机梯度上升算法，解决病马死亡率问题
 """
 import numpy as np
 import random

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

 """
     随机梯度上升算法
     相比于梯度上升算法，有两处改进的地方：
     1.alpha在每次迭代更新是都会调整，这会缓解数据波动或者高频运动。此外，alpha还有一个常数项，目的是为了保证在多次迭代后仍然对新数据具有一定的影响，如果要处理的问题是动态变化的，可以适当加大该常数项，从而确保新的值获得更大的回归系数。
     2.更新回归系数(最优参数)时，只使用一个样本点，并且选择的样本点是随机的，每次迭代不使用已经用过的样本点。这样的方法，就有效地减少了计算量，并保证了回归效果。
 """
 def randomGradientAscent(dataMat,classLabels,numIter=150): #numIter为迭代次数默认为150
     dataMatrix = np.array(dataMat) #将list或tuple变量转换成numpy的array数组
     m,n = np.shape(dataMatrix) #返回数组每一维的大小,m为行数，n为列数
     #print(m,n)
     #print(len(classLabels))
     weights = np.ones(n) #构造1*n的元素全为1的矩阵
     for j in range(numIter):
         dataIndex = list(range(m)) #获取数据集行下标列表
         for i in range(m):
             alpha = 4/(1.0+i+j)+0.01 #每次更新参数时设置动态的步长，且为保证多次迭代后对新数据仍然具有一定影响
             randIndex = int(random.uniform(0,len(dataIndex)))#随机选取样本
             #print(i ,randIndex)
             h = sigmoid(sum(dataMatrix[randIndex]*weights)) #选择随机选取的一个样本，计算h
             error = classLabels[randIndex] - h #计算误差
             weights= weights + alpha* error * dataMatrix[randIndex] #更新回归系数
             del(dataIndex[randIndex]) #删除已经使用的样本
     return weights

 """
     分类函数，判断分类
 """
 def classifyVector(inX , weights):
     prob = sigmoid(sum(inX*weights))
     if prob>0.5:
         return 1.0
     else:
         return 0.0

 """
     测试分类器
 """
 def colicTest():
     dataMat,labelMat = loadDataSet()
     trainWeigths = randomGradientAscent(dataMat,labelMat,500)
     frTest = open('horseColicTest.txt')
     numTestVec =0.0 #测试样例总数
     errorCount =0 #错误样例数
     for line in frTest.readlines():
         numTestVec += 1.0
         currArr = line.strip().split('\t')
         lineArr = []
         for i in range(len(currArr)-1):
             lineArr.append(float(currArr[i]))
         if int(classifyVector(np.array(lineArr),trainWeigths)) != int(currArr[-1]):
             errorCount += 1
     errorRate = (float(errorCount)/numTestVec)*100
     print("测试集错误率为：%.2f%%" %errorRate)

 """
     加载数据
 """
 def loadDataSet():
     dataSet = [] #数据列表
     labelMat = [] #标签列表
     frTrain = open('horseColicTraining.txt')
     for line in frTrain.readlines():
         #print(line)
         currArr = line.strip().split('\t')
         lineArr = []
         for i in range(len(currArr)-1):
             lineArr.append(float(currArr[i]))
         dataSet.append(lineArr)
         labelMat.append(float(currArr[-1])) #添加标签
     frTrain.close()
     return dataSet, labelMat

 if __name__ == '__main__':
     colicTest()

3.使用sklearn预测病马的死亡率

 """
     使用sklearn构建逻辑回归分类器
 """
 from sklearn.linear_model import LogisticRegression
 """
     加载数据
 """
 def loadDataSet():
     dataSet = [] #数据列表
     labelMat = [] #标签列表
     frTrain = open('horseColicTraining.txt')
     for line in frTrain.readlines():
         #print(line)
         currArr = line.strip().split('\t')
         lineArr = []
         for i in range(len(currArr)-1):
             lineArr.append(float(currArr[i]))
         dataSet.append(lineArr)
         labelMat.append(float(currArr[-1])) #添加标签
     frTrain.close()
     return dataSet, labelMat

 """
     加载测试数据
 """
 def loadTestDataSet():
     dataSet = [] #数据列表
     labelMat = [] #标签列表
     frTrain = open('horseColicTest.txt')
     for line in frTrain.readlines():
         #print(line)
         currArr = line.strip().split('\t')
         lineArr = []
         for i in range(len(currArr)-1):
             lineArr.append(float(currArr[i]))
         dataSet.append(lineArr)
         labelMat.append(float(currArr[-1])) #添加标签
     frTrain.close()
     return dataSet, labelMat

 """
     测试分类器
 """
 def colicTest():
     dataMat,labelMat = loadDataSet()
     testMat,testLabelMat = loadTestDataSet()
     classifier = LogisticRegression(solver ='liblinear',max_iter =10).fit(dataMat,labelMat)
     accurcyRate = classifier.score(testMat,testLabelMat)*100
     print("测试集正确率为：%.2f%%" %accurcyRate)

 if __name__ == '__main__':
     colicTest()