机器学习笔记——4 广义线性模型的基本思想和各个常用的回归特例(附logistic模型的python实现)

广义线性模型(Generalized Liner Model)的基本思想和各个常用的回归特例(附logistic模型的python实现)

---

为什么需要广义线性模型？“广义”和“线性”的含义是什么？

首先我们需要解释线性的重要性。线性之所以如此重要，其本质原因在于两方面：

1. 线性形式相对是简单的，而且我们擅长处理线性问题，无论是在工程实现上还是在数学分析上。在线性的世界里，无论是对象本身的描述还是变换的描述，我们都有很好的工具和语言去运用和表述它们，诸如直线、超平面、向量、矩阵和行列式等等，对于线性的优化问题，也已有系统的理论和可行的求解算法。
2. 很多非线性问题，可以通过转化为线性问题进行求解。在这里不得不提起人类智慧的伟大结晶之一——微积分。微积分可以说是利用线性形式处理非线性问题的经典范例。这里我们需要扯开谈一下微积分。
   我们经常谈微积分的基本思想“以直代曲，极限求和”，前者是微分的思想，后者是积分的思想。在微分中，实际上我们关注的是找一个线性变换，将各个独立的自变量增量进行变换，用以近似因变量的增量。这个线性变换是一个确定的变换，它由非线性函数$f$ 在某点$x_0$处确定，需要满足一定的条件。微分和导数是围绕这个线性变换来定义的，导数指的是这个线性变换对应的矩阵，而微分指的是变换后的因变量近似量。而所谓积分，即是将因变量的各个微分求和，这里体现的是极限的思想。

在广义线性模型中，线性体现在，我们的参数$\theta$和各个属性$x_i$之间的结合是线性的形式，即${\theta }^{T}x$，直观地看，我们是在找一个方向$\theta$对$x$进行投影(严格上应该是做内积)。在广义线性模型的各个特例中，这一线性的结合形式是始终不变的。

现在我们讨论“广义”的含义。在简单线性模型中，我们假设标签值$y$服从$N(u,{\sigma }^2)$。从而自然假设输出的形式为 $h_{\theta }(x)={\theta }^{T}x$。这一输出形式带来的问题是，输出的范围不受限制，例如上篇我们讲分类问题的时候，对于取1概率p的输出估计值显然需要落在$[0,1]$之间。因此广义的含义在于，输出的形式限制可以打开，为
$$h_{\theta }(x)=g({\theta }^{T}x)$$这样通过适当选取映射$g()$就能达到范围限制。这里我们称映射$g()$为响应函数，称映射$g^{-1}()$为联系函数。可以看到，简单线性模型选用的响应函数为恒等函数。

典则联系函数和典则响应函数(canonical link function)

响应函数的选择可以有多种，比如在上一篇的二分类问题中，对范围在$[0,1]$的概率p，我们可以选择logistic函数和标准正态的分布函数。本小节讨论一种特殊的响应函数，称为典则响应函数。其来源的基本思想是，我们希望响应函数是从标签值的分布中自然导出来的，因此我们需要对预先假设的分布的密度函数进行变形，使得我们可以${\theta }^{T}x$来估计某个无范围限制的参数。
显然，密度函数的值必须大于0，因此自然的变换为

• 先进行log变换，在进行exp变换。

这样我们就可以提炼出$exp(f(\eta ))$中的参数$\eta$，参数$\eta$必须是充分的，即我们给出它的估计后，这个分布就可以被完全确定下来了。显然$\eta$的范围在$R$中均是有意义的，因为密度函数值始终大于0。此时就可以直接假设 $\eta ={\theta }^{T}x$，假设未进行变换前的参数是$\varphi$，那么根据$\eta$的选取，总有$\eta =g^{-1}(\varphi )$，从而可以反解出$\varphi =g(\eta )$。从而得到
$$\varphi =g(\eta )=g({\theta }^{T}x)$$因此这实际上就等价与我们选用了上式的$g()$作为响应函数，这样选取得到的$g()$称为典则响应函数，其逆函数$g^{-1}()$称为典则联系函数。

广义线性模型的系统化定义

1. 指数型分布簇
   密度函数可以改写为如下形式的分布，属于指数型分布簇：
   $$p(y;\eta )=b(y)exp({\eta }^{{}^{\prime }}T(y)-a(\eta ))$$其中，$\eta$是一个充分统计量，也就是我们要利用${\theta }^{T}x$去估计的，$\eta$给定后，分布就可以确定下来。$a^{{}^{\prime }}(\eta )$是y的期望，而$T(y)$大部分情况下是$y$，而$\eta =g^{-1}(u)$，其中$u$为原来的参数值。

2. $E(T(y)|x)=E(y|x)=u=g(\eta )=g({\theta }^{T}x)$

广义线性模型的参数估计(具有统一形式的梯度更新公式)

我们记$h_{\theta }(x)=g({\theta }^{T}x)$，则模型的训练必须确定参数$\theta$的值。显然我们可以用最小二乘的思想，但是这里我们将使用极大似然估计的方法。我们将看到，利用梯度上升的数值算法求解其偏导函数的零点时，广义线性模型具有统一的梯度更新公式。

现在我们证明这个事情。我们将原来的密度函数 $p(y;\alpha )$变化形式为 $p(y;\eta )$，那么似然函数可以表示为：
$$L(\theta ;x)=\prod _{i=1}^{m}p(y_i;\eta )$$目标为$$\theta =ma{x}_{\theta \in \Theta }L(\theta ;x)$$对数之，求导，得到
$$\begin{array}{rl}{\ell }^{{}^{\prime }}(\theta )=& \frac{\partial logL(\theta ,x)}{\partial \theta }\\ =& \sum _{i=1}^m\frac{1}{p(y_i;\eta )}\frac{\partial p(y_i;\eta )}{\partial y_i}\frac{\partial \eta }{\partial \theta }\\ =& \sum _{i=1}^m\frac{1}{p(y_i;\eta )}[p(y_i;\eta )(y_i-a^{{}^{\prime }}(\eta ))]x_i\\ =& \sum _{i=1}^m(y_i-u)x_i\\ =& \sum _{i=1}^m(y_i-h_{\theta }(x))x_i\end{array}$$这里就解释了上一篇中，为什么简单线性回归和logistic回归具有相同的梯度更新公式，其原因在于logistic函数$$\eta =log(\frac{\varphi }{1-\varphi })$$是二项分布的典则联系函数，而恒等函数$$y=x$$是正态分布的典则联系函数，因此在MLE的意义下，二者必然有相同的梯度更新公式。

广义线性模型下各个特例

有很多的分布是属于指数型分布簇，比如正态分布、二项分布、多项分布、泊松分布、几何分布、伽马分布等等。现在我们选择一些，看看它们在广义线性模型下的典则响应函数的形式。

概率分布	参数	均值(向量)	典则联系函数 ($\eta ={\theta }^{T}x)$	典则响应函数 $h_{\theta }(x)$
正态分布	$\mu$	$\mu$ = $\mu$	$\eta =\mu$	$\mu =\eta$
二项分布	$\varphi$	$\mu$ = $\varphi$	$\eta =log(\frac{\mu }{1-\mu })$	$\mu =\frac{e^{\eta }}{1+e^{\eta }}$
泊松分布	$\lambda$	$\mu$ = $\lambda$	$\eta =log(\mu )$	$\mu =e^{\eta }$
几何分布	$\varphi$	$\mu$ = $\frac{1}{\varphi }$	$\eta =log(\frac{\mu -1}{\mu })$	$\mu =\frac{1}{1-e^{\eta }}$
多项分布	$\varphi$	$\mu =\varphi$	${\eta }_i=log(\frac{{\varphi }_i}{{\varphi }_k})$	${\varphi }_i=\frac{e^{{\eta }_i}}{1+{\sum }_{j=1}^{k-1}{e}^{{\eta }_j}}$

上述公式的推导是简单的，我们只需要将概率密度函数变换为指数型分布簇的形式，就可以得到$\eta$与原参数$\varphi$的联系函数，从而进一步可推得典则联系函数和典则响应函数。
注意，以上各种情况的参数都可采用MLE进行估计。其解可以利用牛顿迭代法或者梯度上升算法进行迭代，值得注意的是，通过上述的证明，我们知道在梯度上升中更新公式具有统一的形式，在随机梯度上升中，其为：
$$\theta :=\theta +\alpha (y_i-h_{\theta }(x_i))x_i$$

实战项目:利用二项分布假设下的logistic回归进行数据分类(python)

注：在本实验中，我们可以通过上述梯度上升公式使得预测准确率达到72%左右，对外部的测试数据也有72%左右的预测准确率。通过实践，可以认识到随机梯度上升可以在较短的迭代次数下达到收敛。本实验中，对迭代步长进行一些动态的修改，具体来讲，就是求解函数我们允许用户传入最大最小两个步长值，在迭代过程中进行步长修改。修改可以是线性也可以是非线性的，但方向应该是从大步长逐渐减弱到小步长，个中原因在于在迭代伊始时，大步长有利于加速收敛，而越接近局部优解时，小步长有利于收敛的稳定。本例采用线性的步长下降。
myLogistic.py

import numpy as np
from numpy import dot
import random

def sigmoid(X):
    return  1/(1+np.exp(-1*X))

def logistic(X,Y,alphaMax = 0.01,alphaMin = 0.001,epsilon = 0.00000001,numIter = 2000,method = 'SGD'):
    '''
    本函数利用Logstic模型，利用梯度下降法求出似然函数意义下的最优参数
    '''
    # X^T(y - h(X*theta))       \patial
    if(method == 'BGD'):
        theta_0 = np.ones(X.shape[1])
        # alpha = 0.01
        # epsilon = 0.000001
        logValue = sigmoid(dot(X,theta_0))
        errorV = Y - logValue
        error_0  = dot(errorV,errorV)
        error = np.inf
        #n = 0
        while((error > epsilon) & (n < numIter)):
            alpha = alphaMax - (n/numIter)*(alphaMax-alphaMin)
            #alpha = alphaMax
            patial = dot(X.T,errorV)
            theta_0 = theta_0 + alpha*patial
            logValue = sigmoid(dot(X,theta_0))
            errorV = Y - logValue
            error_1 = dot(errorV,errorV)
            error = abs(error_1 - error_0)
            error_0 = error_1
            #n = n + 1
            #print('---------------第',n,'轮迭代--------------')
            # print('theta:',theta_0)
            # print('error:',error)
            #print('errorSUM:',error_1)
            #print('alpha:',alpha)
            #print('patial:',patial) 
        return theta_0
    if(method == 'SGD'):    
        theta_0 = np.ones(X.shape[1])
        error_0  = 0
        error = np.inf
        k = list(range(X.shape[0]))       
        #n = 0
        while((error > epsilon)&(n < numIter)):
            random.shuffle(k)
            alpha = alphaMin + (1-n/numIter)*(alphaMax-alphaMin)
            for i in k:
                patial = (Y[i] - sigmoid(dot(X[i,:],theta_0)))*X[i,:]
                theta_0 = theta_0 + alpha*patial
            logValue = sigmoid(dot(X,theta_0))
            errorV = Y - logValue
            error_1 = dot(errorV,errorV)
            error = abs(error_1 - error_0)
            error_0 = error_1
            #n = n + 1
            logValue = sigmoid(dot(X,theta_0))
            errorV = Y - logValue
            patial1 = dot(X.T,errorV)
            # print('---------------第',n,'轮迭代--------------')
            # print('theta:',theta_0)
            # print('error:',error)
            # print('patial:',patial1)
            # print('errorSUM:',error_1)
            # print('alpha:',alpha)
            # print(n)
        return theta_0

测试代码logisticReg.py

import myLogistic
import numpy as np
import pandas as pd

if __name__ == '__main__':
    #simpleRegre.txt
    samData = pd.read_table('C:/Users/Administrator/Desktop/MLCourseOfWSQ/pythonProject/mlData/Logistic/TestSet.txt',
                            header = None)  
    # 构造样本矩阵
    sample = np.array(samData)
    sampleY = sample[:,sample.shape[1]-1] 
    oneCol = np.ones([sample.shape[0],1])
    sampleX = np.hstack((oneCol,sample[:,0:sample.shape[1]-1]))    
    
    # 调用函数估计参数并预测
    theta = myLogistic.logistic(sampleX,sampleY,alphaMax = 0.0001,alphaMin = 0.0000001,epsilon = 0.000001,numIter = 4000,method = 'SGD')
    predictConfidence = np.dot(sampleX,theta)
    predictY = myLogistic.sigmoid(predictConfidence)
    
    #输出预测结果与真实结果的比较
    result = np.zeros(sample.shape[0])
    result[predictY>0.5] = 1
    compareResult = (sampleY == result)
    for i in range(sample.shape[0]):
        print('Y:',sampleY[i],'    Predict Y:',result[i],'    boolCompare:',compareResult[i],'    predictP:',predictY[i])
    print('right discrimination number:',sum(compareResult))
    print('right discrimination ratio :',sum(compareResult)/sample.shape[0])    
        
    # 测试代码部分        
    # samData = pd.read_table('C:/Users/Administrator/Desktop/MLCourseOfWSQ/pythonProject/mlData/Logistic/HorseColicTest.txt',
                        # header = None) 
    # testSample = np.array(samData)
    # testY = testSample[:,testSample.shape[1]-1] 
    # oneCol = np.ones([testSample.shape[0],1])
    # testX = np.hstack((oneCol,testSample[:,0:testSample.shape[1]-1]))  
    # predictConfidence = np.dot(testX,theta)
    # predictY = myLogistic.sigmoid(predictConfidence)
    # result = np.zeros(testSample.shape[0])
    # result[predictY>0.5] = 1
    # compareResult = (testY == result)
    # for i in range(testSample.shape[0]):
        # print('Y:',testY[i],'    Predict Y:',result[i],'    boolCompare:',compareResult[i],'    predictP:',predictY[i])
    # print('right discrimination number:',sum(compareResult))
    # print('right discrimination ratio :',sum(compareResult)/testSample.shape[0])