逻辑回归：原理及python实现

2021/9/28 17:10:47

编程Tag： 逻辑 python self batch 回归 np theta frac

本文主要是介绍逻辑回归：原理及python实现，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1 逻辑回归概述
- 1.1 Sigmoid函数
- 1.2 二项逻辑回归
- 1.3 对数几率理解
2 逻辑回归的参数优化及正则化
- 2.1 梯度下降法优化参数
  - 2.1.1 最大似然法确定损失函数（对数损失）
  - 2.1.2 损失函数的优化
- 2.2 正则化
3 逻辑回归的实现
- 3.1 sklearn实现
- 3.2 python从零实现

逻辑回归概述

逻辑斯蒂回归（Logistics Regression,LR）又叫逻辑回归或对数几率回归（Logit Regression），是一种用于二分类的线性模型。

Sigmoid函数

\[g(z) = \frac{1}{1+e^{-z}} \]

其图像如下，在x=0处函数值为0.5，x趋向于无穷时，函数值分别趋向0和1。

import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

X = np.linspace(-10,10)
y = []
for i in X:
    y.append(1/(1+np.exp(-i)))
plt.plot(X,y)
plt.plot(X,np.ones(len(X))/2,'--',c='black',linewidth='0.8')
plt.xlabel('z')
plt.ylabel('g(z)')
plt.show()

二项逻辑回归

线性回归用于解决回归问题，其输出$z=wx^T+b$是实数，如何将线性回归模型加以改造使其可以用于分类呢？一个朴素的想法就是对线性回归的结果做一个变换

\[y=f(z) \]

使得

\[y\in\{-1,1\} \]

其中

\[{z = X\theta} \]

即把线性回归所得的函数值映射到$\{-1,1\}$。

逻辑回归首先使用Sigmoid函数将线性回归的值映射到区间$[0,1]$，然后将大于0.5（可调整）的值映射为类别1，小于0.5的值映射为类别-1。$g(z)$可以理解为分类为正例的概率，越靠近1，被分类为正例的概率越大，在临界值0.5处最容易被误分类。

对数几率理解

上一节说到，将$g(z)$理解为样本被分类为正例的概率。一个事件的几率(odds)是指该事件发生的概率与该事件不发生的概率的比值。则将

\[ln\frac{g(z)}{1-g(z)} \]

称为对数几率(log odds)或logit函数，且将

\[{z = X\theta} \]

代入sigmoid函数并变形有

\[ln\frac{g(z)}{1-g(z)}=X\theta \]

因此，逻辑回归可以看作对对数几率（Logit）进行的线性回归，这也是对数几率回归名字的由来。

逻辑回归的参数优化及正则化

上一节已经描述了逻辑回归的思路，即将线性回归的结果映射为分类变量，在读这一节之前，需要了解一下最大似然估计的思想。

梯度下降法优化参数

最大似然法确定损失函数（对数损失）

对于每个样本点$(x_i,y_i)$，假设$y_i=1,y_i=0$的概率分别为

\[P(y_i=1|x_i,\theta)=g_\theta(x_i) \]

\[P(y_i=0|x_i,\theta)=1-g_\theta(x_i) \]

将其合并为

\[P(y_i|x_i,\theta)=g_\theta(x_i)^{y_i}(1-g_\theta(x_i))^{1-y_i} \]

假设每个样本点独立同分布，样本数为n，由最大似然法（MLE）构造似然函数得

\[L(\theta)=\prod _{i=1}^nP(y_i|x_i,\theta) \]

由于似然函数表示的是取得现有样本的概率，应当予以最大化，因此，取似然函数的对数的相反数作为损失函数

\[J(\theta) = -lnL(\theta) = -\sum\limits_{i=1}^{m}(y_iln(g_{\theta}(x_i))+ (1-y_i)ln(1-g_{\theta}(x_i))) \]

损失函数的优化

对上一节的损失函数求导可得

\[\frac{\partial J(\theta)}{\partial \theta} = -\sum^m_{i=1}(y_i\frac{\frac{\partial g_{\theta}(x_i)}{\partial \theta}}{g_{\theta}(x_i)}-(1-y_i)\frac{\frac{\partial g_{\theta}(x_i)}{\partial \theta}}{1-g_\theta(x_i)}) \]

对于函数

\[g(z)=\frac 1{1+e^{-z}} \]

有

\[g'(z) = \frac{dg(z)}{dz}=\frac{e^{-z}}{(1+e^{-z})^2}=\frac1{1+e^{-z}}\frac{1+e^{-z}-1}{1+e^{-z}}=g(z)(1-g(z)) \]

当$z=x_i^T\theta$时

\[\frac{\partial g_{\theta}(x_i)}{\partial \theta}=g_{\theta}(x_i)(1-g_{\theta}(x_i))\frac{dz}{d\theta}=g_{\theta}(x_i)(1-g_{\theta}(x_i))x_i \]

故

\[\frac{\partial J(\theta)}{\partial \theta}=\sum_{i=1}^m x_i(g_\theta(x_i)-y_i)=X(g_\theta(X)-y) \]

使用梯度下降法$$\theta = \theta - \alpha X^T(g_{\theta}(X) - y )$$

其中

\[X=\begin{bmatrix} x_1 \\ x_2 \\...\\x_m\end{bmatrix},y=\begin{bmatrix} y_1 \\ y_2 \\...\\y_m\end{bmatrix} \]

正则化

Logistic Regression也可以使用正则化，方法同样是在损失函数后增加正则化项。

\[J(\mathbf\theta) = -\sum\limits_{i=1}^{m}[y_iln(h_{\theta}(x_i))+ (1-y_i)ln(1-h_{\theta}(x_i))] + \frac{1}{2}C||\theta||_2^2+\alpha||\theta||_1 \]

逻辑回归的实现

sklearn实现

sklearn中LogisticRegression默认使用L2正则化，参数penalty可修改正则化方式。下面是使用sklearn自带的乳腺癌数据集进行逻辑回归训练的代码，下图是不同正则化参数训练所得模型系数，可以看出skleran中正则化项C越小，正则化程度越强，参数的变换范围越小。sklearn中的C应该是上式中的C的相反数。

# 乳腺癌数据上使用Logistic Regression
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

cancer = load_breast_cancer()
X_train,X_test,y_train,y_test = train_test_split(cancer.data,cancer.target,stratify = cancer.target,random_state=42)

for C,maker in zip([0.001,1,100],['o','^','v']):
    logistic = LogisticRegression(C = C,penalty='l2',max_iter=100).fit(X_train,y_train)
    print('训练精度（C={})：{}'.format(C,logistic.score(X_train,y_train)))
    print('测试精度（C={})：{}'.format(C,logistic.score(X_test,y_test)))
    plt.plot(logistic.coef_.T,maker,label = 'C={}'.format(C))
plt.xticks(range(cancer.data.shape[1]),cancer.feature_names,rotation = 90)
plt.xlabel('Coefficient Index')
plt.ylabel('Coefficient')
plt.legend()
plt.show()

训练精度（C=0.001)：0.9530516431924883
测试精度（C=0.001)：0.9440559440559441
训练精度（C=1)：0.9460093896713615
测试精度（C=1)：0.958041958041958
训练精度（C=100)：0.9413145539906104
测试精度（C=100)：0.965034965034965

python从零实现

下面是python从零实现的代码。同样的，先定义了一个LogistcReg类，并初始化参数，在fit过程中，未使用pytorch的自动求导而是直接利用上面推导出的公式来进行梯度下降。在类中还定义了，概率、评分、预测等方法用于输出相关数据。

import numpy as np
import random

import pandas as pd
from sklearn.linear_model import LogisticRegression


class LogisticReg:
    def __init__(self, X, y, batch=10, learning_rate=0.01, epoch=3, threshhold_value=0.5,random_seeds=50):
        self.random_seeds = random_seeds
        self.features = X
        self.labels = y
        self.batch = batch
        self.learning_rate = learning_rate
        self.epoch = epoch
        self.w = np.random.normal(0, 0.01, size=(self.features.shape[1],1))
        self.b = np.random.normal(0, 0.01)
        self.threshhold_value = threshhold_value
        
        random.seed(self.random_seeds)
    def sigmoid(self, features):
        return 1/(1+np.exp(-np.dot(features, self.w)))

    def data_iter(self):
        range_list = np.arange(self.features.shape[0])
        random.shuffle(range_list)
        for i in range(0, len(range_list),self.batch):
            batch_indices = range_list[i:min(i+self.batch, len(range_list))]
            yield self.features[batch_indices], self.labels[batch_indices].reshape(-1,1)

    def fit(self):
        for i in range(self.epoch):
            for batch_features, batch_labels in self.data_iter():
                self.w -= self.learning_rate * np.dot(np.mat(batch_features).T,
                                                       self.sigmoid(batch_features) - batch_labels)

    def pred_prob(self, pre_X):
        return self.sigmoid(pre_X)

    def predict(self, pre_X):
        return self.pred_prob(pre_X) >= self.threshhold_value

    def score(self, pre_y, true_y):
        return sum(pre_y.flatten() == true_y.flatten())/len(pre_y)

    def param(self):
        return self.w.flatten(), self.b


def main():
    # 导入数据
    data = pd.read_excel('../bankloan.xls')
    display(data.head(3))
    X = data.iloc[:, :-1].values
    y = data.iloc[:, -1].values
    
    logit = LogisticReg(X, y)
    logit.fit()
    y_pre = logit.predict(X)
    print(f'前五行正例概率：\n{logit.pred_prob(X)[:5]}')
    print(f'准确率：{logit.score(y_pre,y)}')
    print(f'参数向量：{logit.param()}')

    skl_LogReg = LogisticRegression(max_iter=1000).fit(X, y)
    print(f'sklearn准确率：{skl_LogReg.score(X, y)}')


if __name__ == '__main__':
    main()

	年龄	教育	工龄	地址	收入	负债率	信用卡负债	其他负债	违约
0	41	3	17	12	176	9.3	11.359392	5.008608	1
1	27	1	10	6	31	17.3	1.362202	4.000798	0
2	40	1	15	14	55	5.5	0.856075	2.168925	0

前五行正例概率：
[[2.49612653e-34]
 [7.65762538e-15]
 [4.86626940e-65]
 [1.96369515e-61]
 [1.00000000e+00]]
准确率：0.7828571428571428
参数向量：(array([-1.3659338 ,  0.26429143, -6.6006741 , -2.47473679,  0.24051248,
        4.04122571,  3.14053356,  0.8300533 ]), -0.01447246523912454)
sklearn准确率：0.8085714285714286

这篇关于逻辑回归：原理及python实现的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！