2 对数几率回归实践

Logistic回归的一般过程

Logistic回归的优缺点

Logistic回归算法描述（改进的随机梯度下降）

《机器学习实战》第五章代码解析

5-1 Logistic回归梯度上升优化方法

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

1 对数几率回归原理分析

1.1 引入

Logistic Regression，对数几率回归，又称逻辑斯谛回归。该模型最初是用来解决0/1二分类问题，明明是分类问题，为何叫回归？科普一下，线性回归是找到一条直线或超平面尽可能地接近所有的训练数据点（就是用线性方程来拟合数据），而对数几率回归是找到一条直线或超平面尽可能地分开两种不同类别的数据点（就是在公式中的线性部分来做了回归）。
首先，我们要解决的问题是：在线性模型 $z=w^Tx+b$ 上做二分类（这里不讨论多分类）。
把问题转化为，让模型输出为0或者1，而且在分界处变化很陡。
直接想法是套一个函数 $y(z)$ 来实现一个单位阶跃函数，如下:

$y=\begin{cases} &0, \text{ if } z<0 \\ & 0.5,\text{ if } z=0 \\ & 1,\text{ if } z>0 \end{cases}$

也就是把线性模型 $z=w^Tx+b$ 看作为一个两种类别的分界线。
由于分段函数性质太差，不符合优化问题的目标函数要连续可微的特点。所以我们找一个形似的函数（由下图可见），Sigmoid 函数（S型函数）中的杰出代表——对数几率函数（一个任意阶可导的凸函数，有良好的数学性质，很适合优化问题）。

$y= \frac{1}{1+e^{-z}}$

将线性模型 $z=w^Tx+b$ 代入就得到总的模型

$y=\frac{1}{1+e^{-w^{T}x+b}}$

其实，对数几率回归模型就是在拟合线性模型 $z=w^Tx+b$ ，使得这条直线尽可能地将原始数据中的两个类别正确的划分开（引用张磊的知乎）。

单位阶跃函数与对数几率函数（来源周志华《机器学习》) — 单位阶跃函数与对数几率函数（来源 **周志华《机器学习》**）

1.2 损失函数

解决机器学习问题就要明确损失函数，回归问题一般用均方误差（平均损失）或者其平均数——平均误差平方损失来作为损失函数（这就是最小二乘法，用来找到一条直线使所有样本到直线的欧式距离之和最小）。
平均误差平方损失公式如下：

$L=\frac{1}{n}\sum_{i=1}^{n}(\widehat{y}-y)^{2}$

Logistic回归模型，要用到的是对数损失来作为损失函数

$L=-y\log{\widehat{y}}+(1-y)\log{(1-\widehat{y)}}$

先来看它的效果，再来说怎么得来的

效果：真实值是有 0/1 两种情况，而推测值由于借助对数几率函数，其输出是介于0~1之间连续概率值。这个损失函数其实在每次计算时永远都只有一项在发挥作用，转换为分段函数如下：

$L=\begin{cases} & -\log{(\widehat{y})}\text{ if } y=1 \\ & -\log{(1-\widehat{y})}\text{ if } y= 0 \end{cases}$

所以该损失函数可以达到这样的效果：当真实值 y为1时，输出值 y越接近1，则 L越小，当真实值 y为 0 时，输出值 y尖越接近于0，则 L越小。

由来：
这与周志华《机器学习》的3.3节的对数几率回归模型最大化“对数似然”的似然项（详细过程看书P59）

$p(y_{i}|x_{i};w,b)=y_{i}p_{1}(\widehat{x_{i}};\beta )+(1-y_{i})p_0(\widehat{x_i};\beta )$

有着异曲同工之妙，可能存在某种联系吧。

1.3 求最优解

对数几率函数作为高阶可导连续凸函数，根据凸优化理论，典型的数值优化算法如梯度下降算法，牛顿法等
牛顿法的求法看周志华《机器学习》的P59~60。
下面我们用的是梯度下降算法（梯度上升同理，符号变为加号）来得到核心参数的更新方式：
w看做是一个向量的话，迭代同样要加减一个向量，α是每次迭代的步长（大小），α后面的偏导表示的是迭代的方向，这种通过多次迭代能够使得函数收敛到局部最小值。

$w\leftarrow w-\alpha \frac{\partial L}{\partial w}$

$b\leftarrow b-\alpha \frac{\partial L}{\partial b}$

具体怎么得来的看张磊知乎梯度下降算法，写得很棒。

通过链式求导法则，（具体推导见张磊知乎梯度下降算法）

最终迭代方式为（矩阵形式，也是接下来实践用到的公式，其实是通过一系列推导得来的）：

$W\leftarrow W-\alpha X^{T}\(\widehat{Y}-Y)$

( $b$ 归入了矩阵中 $W$ )

2 对数几率回归实践

Logistic回归的一般过程

（1）收集数据：采用任意方法收集数据。
（2）准备数据：由于需要进行距离计算，因此要求数据类型为数值型。（有限）另外，结构化数据格式则最佳。
（3）分析数据：采用任意方法对数据进行分析。
（4）训练算法：大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数
（5）测试算法：一旦训练完成，分类将会很快。
（6）使用算法：首先，我们需要输入一些数据，并将起转化成对应的结构化数值。接着，基于训练好的回归系数既可以对这些数值进行简单的回归计算，在这之后，我们就可以在输出的类别上做一些其他分析工作。

Logistic回归的优缺点

优点：计算代价不高，易于理解和实现。
缺点：容易欠拟合，分类精度可能不高。

Logistic回归算法描述（改进的随机梯度下降）

输入：训练集 $D=\left \{ (x_{i},y_{i}) \right \}_{i=1}^{m}$ ， $x_{i}$ 是 $n$ 维样本向量，即 $x_{i}=(x_{i1},x_{i2},...,x_{in})$ , $y_{i}$ 是对应的分类标签
学习率 $\alpha$
过程：

由对数似然得到代价函数 $J\left ( w \right )=-l(w)$
##下面采用梯度下降对代价函数 $J(w)$ 进行迭代，迭代 $t$ 次（选择一个较大值，如500），得到最终的参数向量 $w=(w_1,w_2...w_m,b)$
初始化 $w$ 为全1矩阵
repeat:
for all $(x_i,y_i)\in D$ do(这里采用随机选取样本来更新回归系数)
动态调整 $\alpha$
$w=w+\Delta w,\Delta w=-\alpha \frac{\partial J(w)}{\partial w},\frac{\partial J(w)}{\partial w}=x_i*(y_i-sigmoid(x_i*w))$
从数据集中删除该样本（避免重复）
util: 迭代了 $t$ 次（要到达 $J(w)$ 达到局部最小的效果）

输出： $w$ 的最优解

《机器学习实战》第五章代码解析

5-1 Logistic回归梯度上升优化方法

算法伪代码：

每个回归系数初始化为1
重复R次：
    计算整个数据集的梯度
    使用 alpha*gradient 更新回归系数的向量
返回回归系数

数据集特点:

testSet.txt每行如下：

-0.017612 14.053064 0
每个样本点包括两个特征值x,y坐标，和对应的分类标签（0或1）

from numpy import *
def loadDataSet():   # 加载数据集
    dataMat = []  # 创建数据列表
    labelMat = []  # 创建标签列表
    fr = open('testSet.txt')  # 打开测试数据文件
    for line in fr.readlines():  # 读取文件每一行
        lineArr = line.strip().split()  # 除去每一行的空格后拆分成列表， 例如 ['0.317029', '14.739025', '0']
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])  # 增加子列表，[1.0,lineArr第一个元素（float）,lineArr第二个元素（float）]
        labelMat.append(int(lineArr[2]))  # 添加元素，元素来源于 lineArr列表的第三个元素（transform str to int first）         
    return dataMat, labelMat  # 返回数据列表，标签列表

# 注：[1.0, float(lineArr[0]), float(lineArr[1])] 中的1.0 表示的是特征X0 的值，一般默认X0 = 1.0（or 1）
def sigmoid(inX):   # 定义sigmoid函数， 同书P74
    return 1.0/(1+exp(-inX))

def gradAscent(dataMatIn, classLabels):  # 定义梯度上升函数
    dataMatrix = mat(dataMatIn)   # 把数据列表转化成矩阵形式（列表和矩阵的简单差别：列表一般是一行，以逗号分隔，而矩阵是多行，没逗号）
    labelMat = mat(classLabels).transpose()  # 把标签列表转化成矩阵形式，然后转置 （行向量 -> 列向量）
    m,n = shape(dataMatrix)   # 取 数据矩阵的行和列   第一个是 行数m=100， 第二个是 列数n=3 
    alpha = 0.001   # 学习率初始化 = 0.001，步长为0.001
    maxCycles = 500   # 最大循环次数 = 500
    weights = ones((n,1))  # 权重初始化为全1矩阵  列向量（形式为n行1列）
    for k in range(maxCycles):  
        h = sigmoid(dataMatrix * weights)  # 1.0/(1+exp(-Z)    f[x,y] = Z = dataMatrix * weights
        error = (labelMat - h)#损失函数，真实值与预测值之间的差值
        weights = weights + alpha * dataMatrix.transpose() * error  # 更新权重  ：要注意矩阵运算，几行几列要对应，注意转置，error(m行1列)，
    return weights  # 返回 权重

#运行代码
dataArr, labelMat = loadDataSet()
dataMatrix = mat(dataArr)
#print(dataMatrix)
res = gradAscent(dataArr,labelMat)
print(res)

结果如下：

[[ 4.12414349]
 [ 0.48007329]
 [-0.6168482 ]]

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

def plotBestFit(weights):
    import matplotlib.pyplot as plt
    dataMat, labelMat = loadDataSet()  
    dataArr = array(dataMat)  # 列表要转为数组
    n = shape(dataArr)[0]  # n=100  数组的行n=100，（数组的列m=3）
    xcord1 = []  #类型1的x,y值
    ycord1 = []
    xcord2 = []  #类型0的x,y值
    ycord2 = []
    for i in range(n):  # 遍历 （0->100-1）
        if int(labelMat[i]) == 1:   # 如果第i个元素的标签值是 1
            xcord1.append(dataArr[i,1])   # 把对应数据数组（形似矩阵）的第i行的第2个元素 增加到 xcord1
            ycord1.append(dataArr[i,2])   # 把对应数据数组（形似矩阵）的第i行的第3个元素 增加到 ycord1
        else:   # 如果标签列表（labelMat）中第i个元素的标签是 0
            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(-3.0,3.0)  # x取值范围 起点-3.0， 终点3.0 步长0.1 
    y = (-weights[0]-weights[1]*x)/weights[2]  # weight[1]是1*1的矩阵，z=w[0]+w[1]*x+w[2]*y,
    #print(x)
    #print(y)
    ax.plot(x,y)#绘制拟合直线
    plt.xlabel('X1')
    plt.ylabel('X2')
    plt.show()

#运行代码
%matplotlib inline#在界面上显示
dataArr, LabelMat = loadDataSet()
weights = gradAscent(dataArr,LabelMat)
plotBestFit(weights.getA()) #getA()将numpy矩阵转换为数组

结果如图

“梯度上升法”的不足在于每次更新回归系数时都要遍历整个数据集，计算复杂度高
因此，产生了“随机梯度上升法”，即每次仅使用1个样本点数据来更新回归系数

5-3 随机梯度上升算法

随机梯度上升算法：一次仅用一个样本点来更新回归系数
随机梯度上升伪代码：
每个回归系数初始化为1
    对数据集中每个样本：
    计算该样本的梯度
    使用 alpha*gradient 更新回归系数的向量
返回回归系数

和梯度上升法的区别：第一，后者的变量h和error都是向量，而前者则全是数值；第二，前者没有矩阵的转化过程，所有变量的数据类型都是Numpy数组

def stocGradAscent0(dataMatrix, classLabels):
    m,n = shape(dataMatrix)  # 取数组的行m， 列n
    alpha = 0.01  # 学习率初始化
    weights = ones(n)   # 创建 含有 n 个元素的 数组
    for i in range(m): # 循环每一行的元素
        h = sigmoid(sum(dataMatrix[i]*weights))# sum(dataMatrix[i]*weights)=w0*x0+w1*x1+w2*x2
        error = classLabels[i] - h 
        weights = weights + alpha * error * dataMatrix[i]    # 更新权重
    return weights   # 返回权重

#运行代码：
dataArr,labelMat = loadDataSet()
weights = stocGradAscent0(array(dataArr), labelMat)
plotBestFit(weights)

结果如图

“随机梯度上升法”分错了三分之一，因为原始梯度上升算法（5-1）是在整个数据集上迭代500次得来的，这是不公平，我们对本算法同样进行多次迭代，发现问题如下：
不足在于回归系数存在周期震荡波动。
因此，产生了“改进的随机梯度上升法”，改进之处有两点：
1、动态调整步进因子；
2、随机选取样本来更新回归系数。

5-4 改进的随机梯度上升算法

def stocGradAscent1(dataMatrix, classLabels, numIter = 150):#因为由图可知迭代到150次左右就收敛（达到稳定值）
    m,n = shape(dataMatrix)   # 取数组（narray）的行，列 m=100， n=3  （narray 和 matrix 长的一样）
    weights = ones(n)  # [1. 1. 1.]
    for j in range(numIter):  # 循环到 最大循环次数numIter = 150：
        # dataIndex = range(m) ### 书中需要更改的地方  tip: TypeError: 'range' object doesn't support item deletion
        dataIndex = list(range(m))  # 创建一个0到99， 步长为1 的列表
        for i in range(m):   # 循环listIndex
            alpha = 4/(1.0+j+i)+0.01#动态调整步进因子
            randIndex = int(random.uniform(0, len(dataIndex)))   # 随机选取样本来更新回归系数
            h = sigmoid(sum(dataMatrix[randIndex]*weights))   #  1.0/(1+exp(-Z))    Z = dataMatrix * weights
            error = classLabels[randIndex] - h
            weights = weights + alpha * error * dataMatrix[randIndex]   # 更新权重
            del(dataIndex[randIndex])   # 删除用过的 随机数 （避免重复）
    return weights   # 返回权重

#运行代码
from numpy import *
dataArr,labelMat = loadDataSet()
weights = stocGradAscent1(array(dataArr), labelMat)
plotBestFit(weights)

结果如图

5-5 示例：从疝气病症预测病马的死亡率

def classifyVector(inX, weights):
    prob = sigmoid(sum(inX*weights))  # 输入Z=inX*weights（特征向量*回归系数） 计算Sigmoid值
    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')   # 除去空格，然后用split方法 转化 成list
        lineArr = []   # 定义行数组（处理每行数据）
        for i in range(21):  #数据有22列，前21个为特征，最后一个是分类标签
            lineArr.append(float(currLine[i]))  # 添加currLine的第i个元素到lineArr
        trainingSet.append(lineArr)   # 把 lineArr 作为 子列表 添加到 训练集列表trainingSet[ [],[],[],...]的形式
        trainingLabels.append(float(currLine[21]))  #  把 currLine 最后一个元素（是标签） 添加到训练标签trainingLabels
    trainWeights = stocGradAscent1(array(trainingSet),trainingLabels,500)   # 迭达500次 求 训练权重
    errorCount = 0   #错误计数器
    numTestVec = 0.0 #总数计数器
    #把测试集文本
    for line in frTest.readlines():   # 读取测试文本的每一行
        numTestVec += 1.0  # numTestVec == 1.0
        currLine = line.strip().split('\t')  # 除去空格，然后用split方法 转化 成list
        lineArr = []    # 定义行数组（处理每行数据）
        for i in range(21):  # 数据有22列，前21个为特征，最后一个是分类标签
            lineArr.append(float(currLine[i]))   # 添加currLine的第i个元素到lineArr
        if int(classifyVector(array(lineArr), trainWeights)) != int(currLine[21]):  # 如果分类有错误
            errorCount += 1
    errorRate = (float(errorCount)/numTestVec)   # 计算错误率
    print("the error rate of this test is: %f" % errorRate)
    return errorRate
    # errorCount,numTestVec 各变量结果  25, 67.0

def multiTest():    # 调用colicTest（）函数10次并求平均值
    numTests = 10
    errorSum = 0.0
    for k in range(numTests):
        errorSum += colicTest()
    print("after %d iterations the average error rate is: %f" % (numTests, errorSum/float(numTests)))

print(colicTest())
multiTest()

结果如下：

the error rate of this test is: 0.388060
0.3880597014925373
the error rate of this test is: 0.417910
the error rate of this test is: 0.432836
the error rate of this test is: 0.402985
the error rate of this test is: 0.328358
the error rate of this test is: 0.388060
the error rate of this test is: 0.402985
the error rate of this test is: 0.238806
the error rate of this test is: 0.358209
the error rate of this test is: 0.462687
the error rate of this test is: 0.328358
after 10 iterations the average error rate is: 0.376119

参考资料

【1】https://zhuanlan.zhihu.com/p/36670444
【2】https://zhuanlan.zhihu.com/p/36564434
【3】《机器学习》周志华
【4】《机器学习实战》

（仅供个人学习记录）

对数几率回归（Logistic Regression）分析与实践

1 对数几率回归原理分析

1.1 引入

1.2 损失函数

1.3 求最优解

2 对数几率回归实践

Logistic回归的一般过程

Logistic回归的优缺点

Logistic回归算法描述（改进的随机梯度下降）

《机器学习实战》第五章代码解析

5-1 Logistic回归梯度上升优化方法

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

5-3 随机梯度上升算法

5-4 改进的随机梯度上升算法

5-5 示例：从疝气病症预测病马的死亡率

参考资料

猜你喜欢