《机器学习实战》学习笔记第五章-逻辑回归

目录

逻辑回归算法

sigmoid函数

梯度上升法

基础代码

回归梯度上升优化算法

画出决策线

随机梯度上升算法

从疝气病症预测病马死亡率

准备数据

测试算法

---

逻辑回归算法

用直线拟合的过程称为回归。根据现有数据对分类边界线建立回归公式，以此进行分类的过程即逻辑回归过程。

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

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

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

一般过程：

1.收集数据

2.准备数据：需要距离计算，因此要求数据类型为数值型，结构化数据格式则最佳。

3.分析数据：任意方法

4.训练算法：大部分时间用于训练，训练的目的是为了找到最佳的分类回归系数

5.测试算法：一旦训练完成，分类将会很快

6.使用算法：首先，需要将数据转换为对应的结构化数值，然后基于训练好的回归系数对这些数值进行简单的回归计算，判定它们属于哪个类别，最后做其他分析工作

sigmoid函数

逻辑回归首先将数据性质转换为0-1的函数，一般用到的是sigmoid函数：

 Sigmoid函数的图像：

 Sigmoid函数连续，光滑，严格单调，是一个非常良好的阈值函数，因此是二分类的概率常用的函数。当x趋近负无穷时，y趋近于0；趋近于正无穷时，y趋近于1；x=0时，y=0.5。一般来说，在x=6,-6前后，y值不再发生变化。

梯度上升法

梯度上升法基于的思想是:要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻。如果梯度记为V，则函数f (x,y)的梯度由下式表示:
 

这个梯度意味着要沿x的方向移动 沿y的方向移动 。其中，函数f(x,y)必须要在待计算的点上有定义并且可微。一个具体的函数例子见图5-2。

图5-2中的梯度上升算法沿梯度方向移动了一步。可以看到，梯度算子总是指向函数值增长最快的方向。这里所说的是移动方向，而未提到移动量的大小。该量值称为步长，记做alpha。用向量来表示的话,梯度算法的迭代公式如下:

该公式将一直被迭代执行， 直至达到某个停止条件为止,比如迭代次数达到某个指定值或算法达到某个可以允许的误差范围。

梯度下降法则是求函数的最小值，将上述+改为-。

在二维空间中，同样是改变x,y两个参数找到最小值：

基础代码

回归梯度上升优化算法

创建数据

def loadDataSet():
    dataMat = []
    labelMat = []
    fr = open('testSet.txt')
    for line in fr.readlines():#逐行读取
        lineArr = line.strip().split()
        dataMat.append([1.0,float(lineArr[0]),float(lineArr[1])]) #数据集
        labelMat.append(int(lineArr[2]))  #标签集
    return dataMat,labelMat

sigmoid函数

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

梯度上升求回归系数

def gradAscent(dataMatIn,classLabels):
    dataMatrix = np.mat(dataMatIn) #创建矩阵
    labelMat = np.mat(classLabels).transpose() #将0轴和1轴置换
    m,n = np.shape(dataMatrix) #m行n列
    alpha = 0.001
    maxCycles = 500
    weights = np.ones((n,1)) #n行1列
    for k in range(maxCycles):
        h = sigmoid(dataMatrix*weights)
        error = (labelMat-h)
        weights = weights+alpha*dataMatrix.transpose()*error
    return weights #回归系数

画出决策线

def plotBestFit(weights,dataArr,labelMat):
    n = np.shape(dataArr)[0]
    xcord1 = []
    xcord2 = []
    ycord1 = []
    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)
    ax.scatter(xcord1,ycord1,s=30,c='red',marker='s')
    ax.scatter(xcord2,ycord2,s=30,c='blue')
    x=np.arange(-3.0,3.0,0.1)
    y=(-weights[0]-weights[1]*x)/weights[2]
    ax.plot(x,y)
    plt.xlabel('X1')
    plt.ylabel('X2')
    plt.show()
dataMat,labelMat = loadDataSet()
dataArr = np.array(dataMat)
weights = gradAscent(dataArr,labelMat)
plotBestFit(weights.getA(),dataArr,labelMat)

随机梯度上升算法

def stocGraAscent0(dataMatrix,classLabels,numIter=150):
    m,n = np.shape(dataMatrix)
    alpha = 0.01
    weights = np.ones(n)
    for i in range(m):
        h = sigmoid(sum(dataMatrix[i]*weights))
        error = classLabels[i] - h
        weights = weights +alpha * error * dataMatrix[i]
    return weights

结果

 这个分类器效果并不完美，但是这只是一次算法，下面将其迭代150次：

def stocGraAscent0(dataMatrix,classLabels,numIter=150):
    m,n = np.shape(dataMatrix)
    weights = np.ones(n)
    for j in range(numIter):
        dataIndex = list(range(m))
        for i in range(m):
            alpha = 4/(1.0+j+i)+0.01
            randIndex = int(np.random.uniform(0,len(dataIndex)))
            h = sigmoid(sum(dataMatrix[randIndex]*weights))
            error = classLabels[randIndex] - h
            weights = weights + alpha * error * dataMatrix[randIndex]
            del(dataIndex[randIndex])
    return weights

从疝气病症预测病马死亡率

准备数据

处理缺失值有以下做法：

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

本数据集预处理：

1. 所有的特征缺失值必须用一个实数值来替换，因为numpy数据类型不允许包含缺失值，这里选择0，不会影响系数
2. 如果一条数据的类别标签缺失，那么丢弃该数据。

测试算法

分类函数，输入特征向量和回归系数，输出类别1或0

def classifyVector(inX,weights):
    prob = sigmoid(sum(inX*weights))
    if prob >0.5:
        return 1.0
    else:
        return 0.0

主体参数：先训练再测试

def colicTest():
    frTrain = open('horseColicTraining.txt')
    frTest = open('horseColicTest.txt')
    trainingSet = []
    trainingLabels = []
    for line in frTrain.readlines():
        currLine = line.strip().split('\t')
        lineArr = []
        for i in range(21):
            lineArr.append(float(currLine[i]))
        trainingSet.append(lineArr) #n行22列
        trainingLabels.append(float(currLine[21]))
    trainWeights = stocGraAscent1(np.array(trainingSet),trainingLabels,500)
    errorCount = 0
    numTestVec = 0.0
    for line in frTest.readlines():
        numTestVec += 1.0
        currLine = line.strip().split('\t')
        lineArr = []
        for i in range(21):
            lineArr.append(float(currLine[i]))
        if int(classifyVector(np.array(lineArr),trainWeights))!=int(currLine[21]):
            errorCount+=1
    errorRate = (float(errorCount)/numTestVec)
    print(f'the error rate is {errorRate}')
    return errorRate

多次测试求错误率

def multiTest():
    numTest = 10
    errorSum= 0.0
    for k in range(numTest):
        errorSum += colicTest()
    print(f'after {numTest} iterations the average error rate is {errorSum/float(numTest)}')

 前面的可视化只使用了二维参数，目的是直观表示逻辑回归的可靠性。真实场景运用是输出0或1，int(classifyVector(np.array(lineArr),trainWeights))，最后验算正确率。