多元逻辑回归 · 数学推导过程及代码实现完全解析

最近修改：2021/6/22

本文是《从二元逻辑回归到多元逻辑回归 · 数学推导过程完全解析》的第二部分，具体介绍多元逻辑回归，及其背后的数学公式推导和具体python代码实现

对于模型概述请参见第一部分：
二元逻辑回归 · 数学推导过程及代码实现完全解析

多元逻辑回归

模型解释

在这个模型中，自变量，因变量和参数的样子如下，可以看到$y_i$的取值由两元变成了多元。

多元逻辑回归有次序多元逻辑回归和无序多元逻辑回归之分，两者区别就在于因变量$y$的取值是否有次序，如$y$的取值类似于1,2,3,4…，则称其为次序多元逻辑回归。

本文这讨论更宽泛的无序情况。

因变量$y$是一个nx1向量，$y_i$∈{$w_1,w_2,w_3,...,w_K$}，$i=1,2,3,...,n$

$$y=\left[\begin{array}{c}{y}_1\\ y_2\\ ⋮\\ y_n\end{array}\right]$$

带截距项的自变量$X$是一个nx(m+1)的矩阵
$$X=\left[\begin{array}{ccccc}1& x_{11}& x_{12}& ...& x_{1m}\\ 1& x_{21}& x_{21}& ...& x_{2m}\\ ⋮& ⋮& & ⋮& \\ 1& x_{n1}& x_{n2}& ...& x_{nm}\end{array}\right]$$

带截距项的参数${\beta }_k$是一个mx1向量，$k=1,2,3,....,K$
$${\beta }_k=\left[\begin{array}{c}{\beta }_{k0}\\ {\beta }_{k1}\\ {\beta }_{k2}\\ ⋮\\ {\beta }_{km}\end{array}\right]$$

与二元逻辑回归的另一个区别就是，多元逻辑回归中用的是softmax函数。

于是我们的自变量和因变量的概率之间的关系可以表示如下

$$p_{ik}\triangleq P(y_i=w_k)=\frac{e^{x_i{\beta }_k}}{{\sum }_{j=1}^K{e}^{x_i{\beta }_j}}\text{\hspace{1em}(5)}$$

怕之后忘记，先来用代码来巩固一下

X是我们的数据dataframe，beta是参数矩阵
X.iloc[i]是测试集的第i行，beta[:,k]是参数矩阵的第k列

则np.exp(np.array(X.iloc[i]).dot(beta[:,k])是(5)式的分子部分，但为了严格与矩阵运算对应，还需要对其做一下修改：
np.exp(np.array(X.iloc[i]).reshape(1,X.shape[1]).dot(beta[:,k].reshape(X.shape[1],1)))
但这个还只是一个数组，因此为了得到具体的值，还得在后面加上[0][0]

(5)式的分母部分
np.exp(np.array(X.iloc[i]).reshape(1,X.shape[1]).dot(beta)).sum()

整理后的函数p_ik()完整代码请见 代码实现 部分

注：在实际建模中，可能会遇到一个问题， (5)的分母过大，超过计算机能表示的范围，即数据溢出，$p_{ik}$会显示为nan，出现提示：

RuntimeWarning: overflow encountered in exp

解决方案有两个：

法一：
取(5)分母中$x_i{\beta }_j(j=1,2,3,...,K)$中的最大值，令其为max
$$\frac{e^{x_i{\beta }_k}}{{\sum }_{j=1}^K{e}^{x_i{\beta }_j}}=\frac{e^{-max}}{e^{-max}}\frac{e^{x_i{\beta }_k}}{{\sum }_{j=1}^K{e}^{x_i{\beta }_j}}=\frac{e^{x_i{\beta }_k-max}}{{\sum }_{j=1}^K{e}^{x_i{\beta }_j-max}}$$
此方法有个问题就是，max可能会很大，而导致数据下溢，分子分母变为0，0/0会出现如下错误

RuntimeWarning: invalid value encountered in true_divide

法二：
之所以出现数据溢出，不就是因为np.array默认的是np.float64吗，问题出在数据精度不够，那我们可以通过扩大精度的方式来处理溢出的问题，即设定dtype=np.float128，潜在问题就是，数字无论多大或多小都会完全显示出来，有点点显示问题。

参数的估计

这个无序多元逻辑回归模型有以下几个事实

• 我们总共进行了n次试验
• 每次试验的可能结果有K种，分别是$y_i(i=1,2,3,...n)=w_1,w_2,w_3,...w_K$
• 每种结果发生的概率$p_k$如(5)式所示，$p_k\triangleq P(y_i=w_k)$
• 并且(5)具有这样的特点${\sum }_{i=1}^K{p}_i=1$
• n次试验中，结果$k$发生次数$n_k$为${\sum }_{i=1}^{n}I(y_i=w_k)$，这里$I(y_i=w_k)$是指示函数(indicator function)，当$y_i=w_k$成立时取1，不成立时取0

通过上面的分析我们知道，无序多元逻辑回归实质上是一个多项分布
$$P(n_1,n_2,n_3,...,n_K|{\beta }_1,{\beta }_2,...{\beta }_K)=\frac{n!}{n_1!n_2!n_3!...n_K!}{p}_1^{n_1}{p}_2^{n_2}...p_K^{n_K}\text{\hspace{1em}(6)}$$

将(6)式两边取对数，有

$$\begin{gathered} LogP(n_1,n_2,n_3,...,n_K|{\beta }_1,{\beta }_2,...{\beta }_K)\propto \\ \sum _{k=1}^K{n}_{k}Log{p}_k=\sum _{k=1}^K\sum _{i=1}^{n}I(y_i=w_k)Log\frac{e^{x_i{\beta }_k}}{{\sum }_{j=1}^K{e}^{x_i{\beta }_j}}\text{\hspace{1em}(7)} \end{gathered}$$

$\propto$是正比符号，省略的部分是常数，求导之后为零，因此这里就直接省掉了

极大似然估计的方法是最大化(7)式，这里我们采用梯度下降的办法，于是我们的损失函数可以写成

$$L(\beta )=-\sum _{k=1}^K\sum _{i=1}^{n}I(y_i=w_k)Log\frac{e^{x_i{\beta }_k}}{{\sum }_{j=1}^K{e}^{x_i{\beta }_j}}\text{\hspace{1em}(8)}$$

先对$log(p_k)$求导，$p_{ik}$如(5)式所示，$\sum$是${\sum }_{j=1}^K{e}^{x_i{\beta }_j}$的简写，矩阵的求导请参考我的另一篇博文统计里的矩阵导数

$$\begin{gathered} \frac{\partial log(p_{ik})}{\partial {\beta }_k^T}=\frac{\sum }{e^{x_i{\beta }_k}}\cdot \frac{e^{x_i{\beta }_k}\cdot x_i^T\cdot \sum -e^{x_i{\beta }_k}\cdot e^{x_i{\beta }_k}\cdot x_i^T}{{\sum }^2} \\ =x_i^T(1-p_{ik}) \end{gathered}$$
$$\begin{gathered} \frac{\partial log(p_{ik})}{\partial {\beta }_m^T}(m\ne k)=\frac{\sum }{e^{x_i{\beta }_k}}\cdot \frac{0\cdot \sum -e^{x_i{\beta }_k}\cdot e^{x_i{\beta }_k}\cdot x_i^T}{{\sum }^2} \\ =-x_i^T\cdot p_{ik} \end{gathered}$$

$y_i=k$对应的参数是${\beta }_k$，在更新参数${\beta }_k$时，会用${\beta }_k$的偏导。简单的说，$m=k$与$y_i=k$是一回事。综上所述，$m\in${ $1,2,...,K$}
$$\begin{gathered} \frac{\partial log(p_{ik})}{\partial {\beta }_m^T}=\frac{\sum }{e^{x_i{\beta }_k}}\cdot \frac{0\cdot \sum -e^{x_i{\beta }_k}\cdot e^{x_i{\beta }_k}\cdot x_i^T}{{\sum }^2} \\ =x_i^T(I(y_i=w_k)-p_{ik}) \end{gathered}$$

注：${\beta }_m$是列向量
所以(8)式的导数(向量形式)：
$$\frac{\partial L(\beta )}{\partial {\beta }_k^T}=-\sum _{i=1}^n{x}_i^T\cdot (I(y_i=w_k)-p_{ik})$$
其中$x_i$是1x(m+1)的向量

于是${\beta }_m$的更新如下
$${\beta }_m^{(t)}={\beta }_m^{(t-1)}-l\cdot \frac{\partial L(\beta )}{\partial {\beta }_k^T}$$
其中${\beta }_m^{(t)}$是(m+1)x1的向量，$l$是学习速率

如何预测

这里只是大致介绍下思路，具体请见代码实现部分
回忆一下(5)式
$$P(y_i=w_k)=\frac{e^{x_i{\beta }_k}}{{\sum }_{j=1}^K{e}^{x_i{\beta }_j}}$$
到目前为止，我们通过迭代得到了我们的参数$\beta$矩阵(是(m+1)xK的矩阵)，现在就需要把测试集带入查看预测的准确率，即测试集里第i个样本，与$\beta$矩阵第k列对应的(5)式的值p_ik(X_test,beta,i,k)

对每个样本，我们想知道其对应的每个p_ik的值，于是有$p_{i1}=P(y_i=w_1),p_{i2}=P(y_i=w_2),....p_{iK}=P(y_i=w_K)$，这K个值里，假设$p_{im}=P(y_i=w_m)$是最大的那个，则将$w_m$作为$y_i$的预测值

代码实现

# 式(5)p_ik的实现

def p_ik(X,beta,i,k):
 	'''
 	X是标准化+归一化后的训练集，nx(m+1)的dataframe
 	beta是（m+1)xK的参数np数组
 	'''
 	# 防止数据溢出，因为此处设定dtype=np.float128
 	# 分子
    top=np.exp(np.array(X.iloc[i],dtype=np.float128).reshape(1,X.shape[1]).dot(beta[:,k].reshape(X.shape[1],1)))[0][0]
    # 分母
    buttom=np.exp(np.array(X.iloc[i],dtype=np.float128).reshape(1,X.shape[1]).dot(beta)).sum()
    return (top/buttom)

# 式(8)损失函数的实现
def loss_fun(X,y,beta):
	'''
	X是标准化+归一化后的训练集因变量，nx(m+1)的dataframe
	y是训练集自变量，nx1的dataframe，有K种取值
	'''
    s=0
    for k in range(K):#自变量共有K类
        for i in range(y.shape[0]):
        	# 第二个lambda里面p_ik等于0时，np.log(p_ik)取-10**(10)，以免报错
            s+=-(lambda x: 1 if x==k else 0)(y.iloc[i])*(lambda x: np.log(x) if x!=0 else 10**(-10))(p_ik(X,beta,i,k))
    return s

# 梯度下降，此处采用小批量梯度下降的方法
def mini_batch_gradient(X,y,max_iter=100,batch_size=10,alpha=.05,ep=0.001):
	'''
	X是标准化+归一化后的训练集因变量，nx(m+1)的dataframe
	y是训练集自变量，nx1的dataframe，有K种取值
	max_iter：最大迭代次数
	batch_size每次更新参数用的数据大小
	alpha 学习速率
	ep 停止迭代的阈值
	'''
    n_samples,n_features=X.shape
    #初始化参数
    beta=np.ones([n_features,len(np.unique(y))])
    loss=[0]
    iter=0
    while iter < max_iter:
        iter+=1
        print('{}st iteration'.format(iter))
        #shuffle
        X=X.sample(frac=1)
        y=y.loc[X.index]
        for j in tqdm(range(0,n_samples,batch_size)):
            mini_X,mini_y=X[j:j+batch_size],y[j:j+batch_size]
            for id_,w in enumerate(np.sort(np.unique(y))):
                #更新变量
                array=np.zeros([n_features,])
                for i in range(mini_X.shape[0]):
                    array +=(lambda x: 1-p_ik(mini_X,beta,i,id_) if x==w else 0-p_ik(mini_X,beta,i,id_))(mini_y.iloc[i])*mini_X.iloc[i]
                beta[:,id_]=beta[:,id_]+alpha*array
        loss.append(loss_fun(X,y,beta))
        delta_loss=loss[-1]-loss[-2]
        # 若前后两次迭代的损失函数之差小于给定的阈值，停止迭代
        if np.abs(delta_loss)<ep:
            print('delta_loss goes under the threshold')
            break
    return loss,beta
    
# 精确度
n_samples,n_features=X_test.shape
a=0
for i in range(n_samples):
	# 预测值对应的索引
    pred_index=np.array([p_ik(X_test,beta,i,k) for k in range(n_features)]).argmax()
    # 真实值
    y_real=y_test.iloc[i]
    # 如果预测值与真实值相等
    if np.sort(np.unique(y))[pred_index]==y_real:
        a += 1

---

以上就是全部内容了，希望能帮助到各位读者，谢谢阅读~