【机器学习】Logistic回归

Logistic回归

1、线性回归

1.1、集美大学三好学生为例

逻辑回归（Logistic Regression）是机器学习中的⼀种分类模型，逻辑回归虽然名字中带有回归，但是⼀种分类算法。由于算法的简单和⾼效，在实际中应⽤⾮常⼴泛。

还是以之前决策树的集美大学三好学生为例

现在我们以数学的角度来看待这张表，如何判断学生是否可以符合三好学生的条件
。我们通常会选取上面五个特征然后进行整合的评估，然后再用评估的结果做出筛选，这里很想之前学习到的线性回归问题，我们这里可以看成
然后在我们在进行简化
之所以选择综测评价，是因为这项方便我们进行量化，而且这项综测评价其实也就是成绩也是三好学生重要的评价指标。

当我们有了上述结果后，我们就可以选出最靠前的同学或者手动设定一个域值，大于域值的同学符合三好学生条件，最后可以得到如下结果，就是这个班评估的分布。

我们通过线性回归对已知的结果进行了整合，然后对整合的结果进行了进一步的分析，找到符合条件的同学，但是如果班级中有一些同学的成绩登记错了，导致这些同学在上图的评估结果远远偏离了正常的分布范围，如下图所示：
那怎么解决这些问题呢？

2、Sigmoid函数

这时候我们便要引入sigmoid函数，先介绍下sigmoid函数
我们能不能用一种分线性边界将下面红绿两点区分呢。如图：

虽然说有些夸张，但是我们可以做非线性的表达。
预测值：

预测函数：
其中：

逻辑回归的输⼊就是⼀个线性回归的结果。
回归的结果输⼊到sigmoid函数当中。
输出结果：[0, 1]区间中的⼀个概率值，默认为0.5为阈值,如果输出结果大于0.5，那么就属于1类别，反之，则属于0类别。如图：
将任意输入映射到了[0,1]区间，我们在线性回归中可以得到一个预测值，再将该值映射到Sigmoid函数中这样就完成了由值到概率的转换，也就是分类任务。

然后对于分类问题我们要分情况进行讨论。分成正例和负例，逻辑回归主要解决二分类问题。
分类任务：

可以整合为
对于二分类问题（0，1），整合后y取0只保留
y取1只保留
在逻辑回归中，当预测结果不对的时候，我们该怎么衡量其损失呢？
逻辑回归的损失，称之为对数似然损失，公式如下：
当y=1时，我们希望h (x)值越⼤越好；
当y=0时，我们希望h (x)值越⼩越好；
综合完整损失函数:

最后，再参数更新：
所以，按照上述Sigmoid函数方法，我们可以得到该同学满足三好学生条件的概率，再通过域值比较最终确定是否符合条件。

3、Logistic回归代码实现

还是以集美大学三好学生为例，数据集里面用了获奖率和同学支持率（可以体现学习，品德和人迹处理方面的突出表现）第一列是获奖率，第二列是同学支持率，最后一列是标签，1表示符合条件，0表示不符合条件，共20项数据

梯度上升算法：

from numpy import *
filename="E:\\workplace\\机器学习\\gradelog.txt" #文件目录
def loadDataSet():   #读取数据（这里只有两个特征）
    dataMat = []
    labelMat = []
    fr = open(filename)
    for line in fr.readlines():
        lineArr = line.strip().split()
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])   #前面的1，表示方程的常量。比如两个特征X1,X2，共需要三个参数，W1+W2*X1+W3*X2
        labelMat.append(int(lineArr[2]))
    return dataMat,labelMat

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

def gradAscent(dataMat, labelMat): #梯度上升求最优参数
    dataMatrix=mat(dataMat) #将读取的数据转换为矩阵
    classLabels=mat(labelMat).transpose() #将读取的数据转换为矩阵
    m,n = shape(dataMatrix)
    alpha = 0.001  #设置梯度的阀值，该值越大梯度上升幅度越大
    maxCycles = 500 #设置迭代的次数，一般看实际数据进行设定，有些可能200次就够了
    weights = ones((n,1)) #设置初始的参数，并都赋默认值为1。注意这里权重以矩阵形式表示三个参数。
    for k in range(maxCycles):
        h = sigmoid(dataMatrix*weights)
        error = (classLabels - h)     #求导后差值
        weights = weights + alpha * dataMatrix.transpose()* error #迭代更新权重
    return weights

def plotBestFit(weights):  #画出最终分类的图
    import matplotlib.pyplot as plt
    dataMat,labelMat=loadDataSet()
    dataArr = array(dataMat)
    n = shape(dataArr)[0]
    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)
    ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')
    ax.scatter(xcord2, ycord2, s=30, c='green')
    x = arange(0.0, 1.0, 0.1)
    y = (-weights[0]-weights[1]*x)/weights[2]
    ax.plot(x, y)
    plt.xlabel('X1')
    plt.ylabel('X2')
    plt.show()

def main():
    dataMat, labelMat = loadDataSet()
    weights=gradAscent(dataMat, labelMat).getA()
    print(weights)
    plotBestFit(weights)

随机梯度上升算法：虽然和梯度算法在代码上很相似，但还是有一些区别：1、后面的变量h和误差error都是向量，而前者全是数值。2、前者没有矩阵的转换过程，都是numpy数组。

def stocGradAscent0(dataMat, labelMat):  #随机梯度上升，当数据量比较大时，每次迭代都选择全量数据进行计算，计算量会非常大。所以采用每次迭代中一次只选择其中的一行数据进行更新权重。
    dataMatrix=mat(dataMat)
    classLabels=labelMat
    m,n=shape(dataMatrix)
    alpha=0.01
    maxCycles = 500
    weights=ones((n,1))
    for k in range(maxCycles):
        for i in range(m): #遍历计算每一行
            h = sigmoid(sum(dataMatrix[i] * weights))
            error = classLabels[i] - h
            weights = weights + alpha * error * dataMatrix[i].transpose()
    return weights

	plotBestFit(weights)
    weights1=stocGradAscent0(array(dataMat), labelMat).getA()

改进的随机梯度算法：1、alpha在每次迭代的时候都会调整。2、通过随机取样本来更新回归系数。

def stocGradAscent1(dataMat, labelMat): #改进版随机梯度上升，在每次迭代中随机选择样本来更新权重，并且随迭代次数增加，权重变化越小。
    dataMatrix=mat(dataMat)
    classLabels=labelMat
    m,n=shape(dataMatrix)
    weights=ones((n,1))
    maxCycles=150
    for j in range(maxCycles): #迭代
        dataIndex=[i for i in range(m)]
        for i in range(m): #随机遍历每一行
            alpha=4/(1+j+i)+0.0001  #随迭代次数增加，权重变化越小。
            randIndex=int(random.uniform(0,len(dataIndex)))  #随机抽样
            h=sigmoid(sum(dataMatrix[randIndex]*weights))
            error=classLabels[randIndex]-h
            weights=weights+alpha*error*dataMatrix[randIndex].transpose()
            del(dataIndex[randIndex]) #去除已经抽取的样本
    return weights

4、小结

Logistic 回归是一种被人们广泛使用的算法，因为它非常高效，不需要太大的计算量，又通俗易懂，不需要缩放输入特征，不需要任何调整，且很容易调整，并且输出校准好的预测概率。
Logistic 回归的优点是它非常容易实现，且训练起来很高效。由于其简单且可快速实现的原因，Logistic 回归也是一个很好的基准，你可以用它来衡量其他更复杂的算法的性能。
Logistic 回归的缺点就是我们不能用 logistic 回归来解决非线性问题，因为它的决策边界是线性的。 只能处理两分类问题(在此基础上衍生出来的softmax可以用于多分类)，且必须线性可分；。