Logistic回归

Logistic回归思想

  Logistic回归或者叫逻辑回归。假设现在有一些数据点，我们用一条直线对这些点进行拟合（该线称为最佳拟合直线），这个拟合过程就称作回归。 虽然名字有回归，但是它是用来做分类的。其主要思想是: 根据现有数据对分类边界线(Decision Boundary)建立回归公式，以此进行分类。这里的’回归’一词源于最佳拟合，表示要找到最佳拟合参数集。

二值型输出分类函数

  我们想要的函数应该是: 能接受所有的输入然后预测出类别。例如，在两个类的情况下，上述函数输出 0 或 1。有一个函数有类似的性质（可以输出 0 或者 1 的性质），且数学上更易处理，这就是 Sigmoid 函数。Sigmoid 函数具体的计算公式如下:$\sigma (z)=\frac{1}{1+e^{-z}}$。
  为了实现 Logistic 回归分类器，我们可以在每个特征上都乘以一个回归系数（如$z=W^{T}X=w_0{x}_0+w_1{x}_1+,,,+w_n{x}_n$,其中向量X是分类器的输入特征数据，向量W就是要找到的最佳参数(系数)），然后把所有结果值相加，将这个总和代入 Sigmoid 函数中，进而得到一个范围在 0~1 之间的数值。任何大于 0.5 的数据被分入 1 类，小于 0.5 即被归入 0 类。所以，Logistic 回归也是一种概率估计，比如这里Sigmoid 函数得出的值为0.5，可以理解为给定数据和参数，数据被分入 1 类的概率为0.5.

基于最优化方法的回归系数确定

  为了找到最佳参数W,使得分类器尽可能地精确，需要用到最优化理论的一些知识，即梯度上升(下降)法。其实这个两个优化方法在本质上是相同的。关键在于代价函数（cost function）或者叫目标函数（objective function）。如果目标函数是损失函数，那就是最小化损失函数来求函数的最小值，就用梯度下降法。 如果目标函数是似然函数（Likelihood function），就是要最大化似然函数来求函数的最大值，那就用梯度上升。在逻辑回归中， 损失函数和似然函数无非就是互为正负关系。
  在本文中采用的优化算法是梯度上升法，对应的迭代公式为$W:=W+\alpha {▽}_{w}f(W)$该公式将一直被迭代执行，直到达到某个停止条件为止，比如迭代次数达到某个指定值或者算法达到某个可以允许的误差范围。相应的如果是梯度下降法，只需要在迭代公式将加法变成减法。

项目案例: 使用 Logistic 回归在简单数据集上的分类

该案例旨在在一个简单的数据集上，采用梯度上升法找到 Logistic 回归分类器在此数据集上的最佳回归系数

开发步骤

• 收集数据: 可以使用任何方法
• 准备数据: 由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据格式则最佳
• 分析数据: 画出决策边界
• 训练算法: 使用梯度上升找到最佳参数
• 测试算法: 使用 Logistic 回归进行分类
• 使用算法: 对简单数据集中数据进行分类

准备数据：采用存储在 TestSet.txt 文本文件中的数据，存储格式如下(前两列为特征数据，最后一列为标签):

-0.017612  14.053064 0
-1.395634  4.662541  1
-0.752157  6.538620  0
-1.322371  7.152853  0
0.423363   11.054677  0

# 解析数据:由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据格式则最佳
def loadDataSet(file_name):
    '''
    Desc: 
        加载并解析数据
    Args:
        file_name -- 要解析的文件路径
    Returns:
        dataMat -- 原始数据的特征
        labelMat -- 原始数据的标签，也就是每条样本对应的类别。即目标向量
    '''
    dataMat = []
    labelMat = []
    fr = open(file_name)
    for line in fr.readlines():
        lineArr = line.strip().split()
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
        #为了方便计算，将X0的值设为1.0，也就是在每一行的开头添加一个1.0作为X0,即z=w_0+w_1x_1+，，，+w_nx_n.
        labelMat.append(int(lineArr[2]))
    return dataMat, labelMat

训练算法: 使用梯度上升找到最佳参数

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

Logistic 回归梯度上升优化算法

# 两个参数：第一个参数==> dataMatIn 是一个2维NumPy数组，每列分别代表每个不同的特征，每行则代表每个训练样本。
# 第二个参数==> classLabels 是类别标签，它是一个 1*100 的行向量。为了便于矩阵计算，需要将该行向量转换为列向量，做法是将原向量转置，再将它赋值给labelMat。
def gradAscent(dataMatIn, classLabels):
    # 转化为矩阵[[1,1,2],[1,1,2]....]
    dataMatrix = mat(dataMatIn)             # 转换为 NumPy 矩阵
    # 转化为矩阵[[0,1,0,1,0,1.....]]，并转制[[0],[1],[0].....]
    # transpose() 行列转置函数
    # 将行向量转化为列向量   =>  矩阵的转置
    labelMat = mat(classLabels).transpose() # 首先将数组转换为 NumPy 矩阵，然后再将行向量转置为列向量
    # m->数据量，样本数 n->特征数
    m,n = shape(dataMatrix)
    # alpha代表向目标移动的步长
    alpha = 0.001
    # 迭代次数
    maxCycles = 500
    # 生成一个长度和特征数相同的矩阵，此处n为3 -> [[1],[1],[1]]
    # weights 代表回归系数， 此处的 ones((n,1)) 创建一个长度和特征数相同的矩阵，其中的数全部都是 1
    weights = ones((n,1))
    for k in range(maxCycles):       
        # m*3 的矩阵 * 3*1 的矩阵 ＝ m*1的矩阵
        # 那么乘上矩阵的意义，就代表：通过公式得到的理论值
        # n*3   *  3*1  = n*1
        h = sigmoid(dataMatrix*weights)     # 矩阵乘法
        # labelMat是实际值
        error = (labelMat - h)              # 向量相减
        # 0.001* (3*m)*(m*1) 表示在每一个列上的一个误差情况，最后得出 x1,x2,xn的系数的偏移量
        weights = weights + alpha * dataMatrix.transpose() * error # Z=W^T*X,因此Z对W求导，因此梯度为X，也就是dataMatrix.transpose()
    return array(weights)

画出数据集和 Logistic 回归最佳拟合直线的函数

def plotBestFit(dataArr, labelMat, weights):
    '''
        Desc:
            将我们得到的数据可视化展示出来
        Args:
            dataArr:样本数据的特征
            labelMat:样本数据的类别标签，即目标变量
            weights:回归系数
        Returns:
            None
    '''   
    n = shape(dataArr)[0]
    xcord1 = []; ycord1 = []
    xcord2 = []; ycord2 = []
    for i in range(n):
        if int(labelMat[i])== 1:#将正样本存储在xcord1,ycord1中
            xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])
        else:#将负样本存储在xcord2,ycord2中
            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='p')#正样本可视化，s为五边形大小，c表示五边形的颜色，marker表示用p(五边形)表示样本点
    ax.scatter(xcord2, ycord2, s=30, c='green',marker='*')
    x = arange(-3.0, 3.0, 0.1)
    """
    dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
    w0*x0+w1*x1+w2*x2=f(x)
    x0最开始就设置为1， x2就是我们画图的y值，而f(x)被我们磨合误差给算到w0,w1,w2身上去了
    所以： w0+w1*x+w2*y=0 => y = (-w0-w1*x)/w2   
    """
    y = (-weights[0]-weights[1]*x)/weights[2]
    ax.plot(x, y)
    plt.xlabel('X'); plt.ylabel('Y')
    plt.show()

可视化如下图

测试算法: 使用 Logistic 回归进行分类

def testLR():
    # 1.收集并准备数据
    dataMat, labelMat = loadDataSet()
    # 2.训练模型，  f(x)=a1*x1+b2*x2+..+nn*xn中 (a1,b2, .., nn).T的矩阵值
    dataArr = array(dataMat)
    weights = gradAscent(dataArr, labelMat)
    #weights = stocGradAscent0(dataArr, labelMat)
    #weights = stocGradAscent1(array(dataArr), labelMat,500)
    # print '*'*30, weights
    # 数据可视化
    plotBestFit(weights.getA())
    #plotBestFit(weights)

梯度上升算法在每次更新回归系数时都需要遍历整个数据集，该方法在处理 100 个左右的数据集时尚可，但如果有数十亿样本和成千上万的特征，那么该方法的计算复杂度就太高了。一种改进方法是一次仅用一个样本点来更新回归系数，该方法称为 随机梯度上升算法。由于可以在新样本到来时对分类器进行增量式更新，因而随机梯度上升算法是一个在线学习(online learning)算法。与 “在线学习” 相对应，一次处理所有数据被称作是 “批处理” （batch） 。

# 随机梯度上升
# 梯度上升优化算法在每次更新数据集时都需要遍历整个数据集，计算复杂都较高,而随机梯度上升一次只用一个样本点来更新回归系数
def stocGradAscent0(dataMatrix, classLabels):
    m,n = shape(dataMatrix)
    alpha = 0.01
    # n*1的矩阵
    # 函数ones创建一个全1的数组
    weights = ones(n)   # 初始化长度为n的数组，元素全部为 1
    for i in range(m):
        # sum(dataMatrix[i]*weights)为了求 f(x)的值， f(x)=a1*x1+b2*x2+..+nn*xn,此处求出的 h 是一个具体的数值，而不是一个矩阵,举例如下：
    '''
	>>> d
	matrix([[1, 2, 3],
        [4, 5, 6]])
	>>> c
	matrix([[4],
        	[5],
        	[6]])
	>>> e=d[0]*c
	>>> e
	matrix([[32]])
	>>> e=sum(d[0]*c)
	>>> e
	32
	'''
        h = sigmoid(sum(dataMatrix[i]*weights))
        # print 'dataMatrix[i]===', dataMatrix[i]
        # 计算真实类别与预测类别之间的差值，然后按照该差值调整回归系数
        error = classLabels[i] - h
        # 0.01*(1*1)*(1*n)
        print weights, "*"*10 , dataMatrix[i], "*"*10 , error
        weights = weights + alpha * error * dataMatrix[i]
    return weights

  可以看到，随机梯度上升算法与梯度上升算法在代码上很相似，但也有一些区别: 第一，后者的变量 h 和误差 error 都是向量，而前者则全是数值；第二，前者没有矩阵的转换过程，所有变量的数据类型都是 NumPy 数组。
  判断优化算法优劣的可靠方法是看它是否收敛，也就是说参数是否达到了稳定值，是否还会不断地变化？下图展示了随机梯度上升算法在 200 次迭代过程中回归系数的变化情况。其中的系数2，也就是 X2 只经过了 50 次迭代就达到了稳定值，但系数 1 和 0 则需要更多次的迭代。如下图所示:

针对上述问题，改进了之前的随机梯度上升算法，如下:

# 随机梯度上升算法（随机化）
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m,n = shape(dataMatrix)
    weights = ones(n)   # 创建与列数相同的矩阵的系数矩阵，所有的元素都是1
    # 随机梯度, 循环150,观察是否收敛
    for j in range(numIter):
        # [0, 1, 2 .. m-1]
        dataIndex = range(m)
        for i in range(m):
            # i和j的不断增大，导致alpha的值不断减少，但是不为0
            alpha = 4/(1.0+j+i)+0.0001    # alpha 会随着迭代不断减小，但永远不会减小到0，因为后边还有一个常数项0.0001
            # 随机产生一个 0～len()之间的一个值
            # random.uniform(x, y) 方法将随机生成下一个实数，它在[x,y]范围内,x是这个范围内的最小值，y是这个范围内的最大值。
            randIndex = int(random.uniform(0,len(dataIndex)))
            # sum(dataMatrix[i]*weights)为了求 f(x)的值， f(x)=a1*x1+b2*x2+..+nn*xn
            h = sigmoid(sum(dataMatrix[dataIndex[randIndex]]*weights))
            error = classLabels[dataIndex[randIndex]] - h
            weights = weights + alpha * error * dataMatrix[dataIndex[randIndex]]
            del(dataIndex[randIndex])
    return weights

上面的改进版随机梯度上升算法，修改了两处代码。

• 第一处改进为 alpha 的值。alpha 在每次迭代的时候都会调整，这回缓解上面波动图的数据波动或者高频波动。另外，虽然 alpha 会随着迭代次数不断减少，但永远不会减小到 0，因为我们在计算公式中添加了一个常数项。

• 第二处修改为 randIndex 更新，这里通过随机选取样本拉来更新回归系数。这种方法将减少周期性的波动。这种方法每次随机从列表中选出一个值，然后从列表中删掉该值（再进行下一次迭代）。
  采用改进的随机梯度优化算法的效果如下：
  
  上面的效果分割线达到了与Gradient Ascent()差不多的效果，但是所使用的计算量更少。