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()

巴特西

Machine Learning in action --LogisticRegession 逻辑回归

最新文章

热门文章