监督学习—广义线性模型—逻辑回归

深耕智能驾驶

已于 2023-07-26 09:20:37 修改

阅读量245

点赞数

分类专栏：监督学习系列文章标签：学习逻辑回归算法

于 2023-07-24 17:57:03 首次发布

本文链接：https://blog.csdn.net/jane0819/article/details/131901386

版权

监督学习系列专栏收录该内容

8 篇文章 0 订阅

订阅专栏

文章目录

1. Logistic 分布
2. Logistic 回归
3. 代价函数
4. 代价函数求梯度
5. LR连续特征离散化
6. LR连续特征离散化方法
7. 何时使用逻辑回归
8. 逻辑回归假设
9. 逻辑回归的优缺点
10. 解决过拟合的方法
11. 逻辑回归与线性回归的区别与联系
12. 参考文献
13. Python代码
14. Python代码运行结果
15. Python代码运行数据文件txt

1. Logistic 分布

Logistic 分布是一种连续型的概率分布，其分布函数和密度函数如下公式所示，其中， µ表示位置参数， λ > 0 为尺度参数。

在这里插入图片描述

Logistic 分布是由其位置和尺度参数定义的连续分布。Logistic 分布的形状与正态分布的形状相似，但是 Logistic 分布的尾部更长，所以我们可以使用 Logistic 分布来建模比正态分布具有更长尾部和更高波峰的数据分布。在深度学习中常用到的 Sigmoid 函数就是 Logistic 的分布函数在 µ=0， λ=1 的特殊形式。

2. Logistic 回归

逻辑回归的假设函数形式如下，其中 x 是我们的输入，θ 为我们要求取的参数。

在这里插入图片描述

3. 代价函数

在这里插入图片描述

4. 代价函数求梯度

在这里插入图片描述

5. LR连续特征离散化

       LR一般需要连续特征离散化原因：
    a.离散化后特征的增加和减少都很容易，易于模型快速迭代；
    b.稀疏向量内积乘法速度快，计算结果方便存储，容易扩展；
    c.离散化的特征对异常数据有很强的鲁棒性(比如年龄为300异常值可归为年龄>30这一段)；
    d.逻辑回归属于广义线性模型，表达能力受限。单变量离散化为N个后，每个变量有单独的权重，相当于对模型引入了非线性，能够提升模型表达能力，加大拟合；
    e.离散化进行特征交叉，由 m+n 个变量为 m*n 个变量(将单个特征分成 m 个取值)，进一步引入非线性，提升表达能力；
    f.特征离散化后，模型会更稳定(比如对用户年龄离散化，20-30作为一个区间，不会因为用户年龄，增加一岁变成完全不同的人，但区间相邻处样本会相反，所以怎样划分区间很重要)；
    g.特征离散化后，简化了LR模型作用，降低模型过拟合风险；

【李沐曾经说过：模型是使用离散特征还是连续特征，其实是一个“海量离散特征+简单模型” 同 “少量连续特征+复杂模型”的权衡。既可以离散化用线性模型，也可以用连续特征加深度学习。就看是喜欢折腾特征还是折腾模型了。】

6. LR连续特征离散化方法

       数据离散化是指将连续的数据进行分段，使其变为一段段离散化的区间，离散化的方法可以分为两大类，一种是无监督学习的方式，另一种是有监督学习的方式，分段的原则有基于等距离、等频率、聚类或优化的方法。
   1. 等距离散法：无监督式
       等距法也称等宽法，即是将属性值分为具有相同宽度的区间，区间的个数k根据实际情况来决定。比如属性值在[0，60]之间，最小值为0，最大值为60，我们要将其分为3等分，则区间被划分为[0,20] 、[21,40] 、[41，60]，每个属性值对应属于它的那个区间。该等区间法可以较好的保留数据的完整分布性。

2. 等频率离散法：无监督式
根据数据的频率分布进行排序，然后按照频率进行离散，好处是数据变为均匀分布，但是会更改原有数据的分布状态。简而言之，就是根据数据频率分布去划分数据区间。

   3. K-means模型离散法：无监督式
       k-means算法又名k均值算法，K-means算法中的k表示的是聚类为k个簇，means代表取每一个聚类中数据值的均值作为该簇的中心，或者称为质心，即用每一个的类的质心对该簇进行描述。

   4. 分位数离散法：无监督式
       利用四分位、五分位、十分位等分位数进行离散。例如：四分位距，是一种衡量一组数据离散程度的统计量，用IQR表示。其值为第一四分位数和第三四分位数的差距。

   5. 二值化离散法：无监督式
       数据跟阈值比较，大于阈值设置为某一固定值（例如1），小于设置为另一值（例如0），然后得到一个只拥有两个值域的二值化数据集。

   6. 基于卡方分裂的离散法：监督式
       该分裂算法是把整个属性的取值区间当做一个离散的属性值，然后对该区间进行划分，一般是一分为二，即把一个区间分为两个相邻的区间，每个区间对应一个离散的属性值，该划分可以一直进行下去，直到满足某种停止条件，其关键是划分点的选取。
https://zhuanlan.zhihu.com/p/410768632

   7. 1R离散法：监督式
       1R 就是 1-rule，称为1 规则，也就是产生一层的决策树，用一个规则集的形式，只在某个特定的属性上进行测试。1R是一个简单廉价的方法，但却常常能得到令人吃惊的准确率。

7. 何时使用逻辑回归

       应用逻辑回归来预测分类因变量。换句话说，当预测是分类的时使用它，例如，是或否，真或假，0 或 1。逻辑回归的预测概率或输出可以是其中之一，没有中间立场。对于预测变量，它们可以是以下任何类别的一部分：
   ①　连续数据：可以在无限尺度上测量的数据。它可以取两个数字之间的任何值。例如以磅为单位的重量或以华氏度为单位的温度。
   ②　离散的名义数据：适合命名类别的数据。一个简单的例子是头发颜色：金色、黑色或棕色。
   ③　离散、有序的数据：符合某种规模顺序的数据。例如，以 1 到 5 的等级说明您对产品或服务的满意程度。

8. 逻辑回归假设

       在使用逻辑回归时，我们做了一些假设。假设对于正确使用逻辑回归进行预测和解决分类问题是不可或缺的。以下是逻辑回归的主要假设：
   ①　自变量之间几乎没有多重共线性。
   ②　自变量与对数赔率(log (p/(1-p))线性相关。
   ③　因变量是二分的或二元的；它分为两个不同的类别。这仅适用于二元逻辑回归，稍后讨论。
   ④　没有无意义的变量，因为它们可能会导致错误。
   ⑤　数据样本量较大，这是获得更好结果的必要条件。
   ⑥　没有异常值。

9. 逻辑回归的优缺点

       以下是逻辑回归算法的一些优点：
   ①　简单易懂，易于实施，训练高效
   ②　当数据集线性可分时表现良好
   ③　对于较小的数据集具有良好的准确性
   ④　不对类的分布做任何假设
   ⑤　它提供了关联方向（正或负）
   ⑥　用于查找特征之间的关系
   ⑦　提供经过良好校准的概率
   ⑧　在低维数据集中不太容易过度拟合
   ⑨　可以扩展到多类分类

       然而，逻辑回归有许多缺点。如果有一个特征可以完美地分离两个类，那么模型就不能再训练了。这称为完全分离。这主要是因为该特征的权重不会收敛，因为最佳权重是无限的。然而，在大多数情况下，完全分离可以通过定义权重的先验概率分布或引入权重的惩罚来解决。以下是逻辑回归算法的一些缺点：
   ①　构建线性边界
   ②　如果特征数量多于观察数量，则可能导致过度拟合
   ③　预测变量应该具有平均或没有多重共线性
   ④　难以获得复杂的关系。像神经网络这样的算法更适合更强大
   ⑤　只能用于预测离散函数
   ⑥　不能解决非线性问题
   ⑦　对异常值敏感

10. 解决过拟合的方法

     1)增加数据量（万能办法）
   2)减少特征：手动剔除；特征选择算法
   3)正则化：结构风险最小化策略
   4)数据稀疏：L1正则化
   5)其他情况：L2正则化

11. 逻辑回归与线性回归的区别与联系

     1）区别
    a.线性回归假设响应变量服从正态分布，逻辑回归假设响应变量服从伯努利分布
    b.线性回归优化的目标函数是均方差（最小二乘），而逻辑回归优化的是似然函数（交叉熵）
    c.线性归回要求自变量与因变量呈线性关系，而逻辑回归没有要求
    d.线性回归分析的是因变量自身与自变量的关系，而逻辑回归研究的是因变量取值的概率与自变量的概率
    e.逻辑回归处理的是分类问题，线性回归处理的是回归问题，这也导致了两个模型的取值范围不同：0-1和实数域
    f.参数估计上，都是用极大似然估计的方法估计参数（高斯分布导致了线性模型损失函数为均方差，伯努利分布导致逻辑回归损失函数为交叉熵）

     2）联系
    a.两个都是线性模型，线性回归是普通线性模型，逻辑回归是广义线性模型
    b.表达形式上，逻辑回归是线性回归套上了一个Sigmoid函数

12. 参考文献

https://blog.csdn.net/jane0819/article/details/131092909
https://zhuanlan.zhihu.com/p/74874291
https://blog.csdn.net/iqdutao/article/details/109478633
https://zhuanlan.zhihu.com/p/403755566
https://zhuanlan.zhihu.com/p/61049356
https://zhuanlan.zhihu.com/p/442837780

13. Python代码

import matplotlib
import matplotlib.pyplot as plt
import csv
import numpy as np
import math


def loadDataset():
    data = []
    labels = []
    with open('dotForLogistic Regression.txt', 'r') as f:
        reader = csv.reader(f, delimiter='\t')
        for row in reader:
            data.append([1.0, float(row[0]), float(row[1])])
            labels.append(int(row[2]))
    return data, labels


def plotBestFit(W):
    # 把训练集数据用坐标的形式画出来
    dataMat, labelMat = loadDataset()
    dataArr = np.array(dataMat)
    n = np.shape(dataArr)[0]
    xcord1 = []
    ycord1 = []
    xcord2 = []
    ycord2 = []
    for i in range(n):
        if int(labelMat[i]) == 1:
            xcord1.append(dataArr[i, 1]);
            ycord1.append(dataArr[i, 2])
        else:
            xcord2.append(dataArr[i, 1]);
            ycord2.append(dataArr[i, 2])
    fig = plt.figure(1)
    ax = fig.add_subplot(111)
    ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')
    ax.scatter(xcord2, ycord2, s=30, c='green')

    # 把分类边界画出来
    x = np.arange(-30.0, 30.0, 0.1)
    y = (-W[0] - W[1] * x) / W[2]
    # y = (-W[0] - W[1] * x) / (W[2] + W[3] * x)
    ax.plot(x, y)
    plt.show()


def plotloss(loss_list):
    x = np.arange(0, 30, 0.01)
    fig = plt.figure(2)
    ax = fig.add_subplot(111)
    ax.plot(x, np.array(loss_list), label='linear')

    plt.xlabel('time')  # 梯度下降的次数
    plt.ylabel('loss')  # 损失值
    plt.title('loss trend')  # 损失值随着W不断更新，不断变化的趋势
    plt.legend()  # 图形图例
    plt.show()


def main():
    # 读取训练集(txt文件)中的数据,
    data, labels = loadDataset()
    # 将数据转换成矩阵的形式，便于后面进行计算
    # 构建特征矩阵X
    X = np.array(data)
    # 增加一维特征
    # Xnew = X[:, 1]*X[:, 2]
    # X = np.insert(X, 3, Xnew, axis=1)
    Wnum = X.shape[1]
    # 构建标签矩阵y
    y = np.array(labels).reshape(-1, 1)
    # 随机生成一个w参数(权重)矩阵    .reshape((-1,1))的作用是，不知道有多少行，只想变成一列
    W = 0.001 * np.random.randn(Wnum, 1).reshape((-1, 1))
    # m表示一共有多少组训练数据
    m = len(X)
    # 定义梯度下降的学习率 0.03
    learn_rate = 0.03

    loss_list = []
    # 实现梯度下降算法，不断更新W,获得最优解，使损失函数的损失值最小
    for i in range(3000):
        # 最重要的就是这里用numpy 矩阵计算，完成假设函数计算，损失函数计算，梯度下降计算
        # 计算假设函数 h(w)x
        g_x = np.dot(X, W)
        h_x = 1 / (1 + np.exp(-g_x))

        # 计算损失函数 Cost Function 的损失值loss
        loss = np.log(h_x) * y + (1 - y) * np.log(1 - h_x)
        loss = -np.sum(loss) / m
        loss_list.append(loss)

        # 梯度下降函数更新W权重
        dW = X.T.dot(h_x - y) / m
        W += -learn_rate * dW

    # 得到更新后的W，可视化
    print('W最优解:')
    print(W)
    print('最终得到的分类边界:')
    plotBestFit(W)
    print('损失值随着W不断更新，不断变化的趋势:')
    plotloss(loss_list)

    # 定义一个测试数据，计算他属于那一类别
    test_x = np.array([1, -1.395634, 4.662541])
    # test_x = np.array([1, -1.395634, 4.662541,-1.395634*4.662541])
    test_y = 1 / (1 + np.exp(-np.dot(test_x, W)))
    print(test_y)


#     print(data_arr)
if __name__ == '__main__':
    main()

14. Python代码运行结果

     最终得到的分类边界和损失值随着W不断更新不断变化的趋势：
在这里插入图片描述

15. Python代码运行数据文件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
0.406704	7.067335	1
0.667394	12.741452	0
-2.460150	6.866805	1
0.569411	9.548755	0
-0.026632	10.427743	0
0.850433	6.920334	1
1.347183	13.175500	0
1.176813	3.167020	1
-1.781871	9.097953	0
-0.566606	5.749003	1
0.931635	1.589505	1
-0.024205	6.151823	1
-0.036453	2.690988	1
-0.196949	0.444165	1
1.014459	5.754399	1
1.985298	3.230619	1
-1.693453	-0.557540	1
-0.576525	11.778922	0
-0.346811	-1.678730	1
-2.124484	2.672471	1
1.217916	9.597015	0
-0.733928	9.098687	0
-3.642001	-1.618087	1
0.315985	3.523953	1
1.416614	9.619232	0
-0.386323	3.989286	1
0.556921	8.294984	1
1.224863	11.587360	0
-1.347803	-2.406051	1
1.196604	4.951851	1
0.275221	9.543647	0
0.470575	9.332488	0
-1.889567	9.542662	0
-1.527893	12.150579	0
-1.185247	11.309318	0
-0.445678	3.297303	1
1.042222	6.105155	1
-0.618787	10.320986	0
1.152083	0.548467	1
0.828534	2.676045	1
-1.237728	10.549033	0
-0.683565	-2.166125	1
0.229456	5.921938	1
-0.959885	11.555336	0
0.492911	10.993324	0
0.184992	8.721488	0
-0.355715	10.325976	0
-0.397822	8.058397	0
0.824839	13.730343	0
1.507278	5.027866	1
0.099671	6.835839	1
-0.344008	10.717485	0
1.785928	7.718645	1
-0.918801	11.560217	0
-0.364009	4.747300	1
-0.841722	4.119083	1
0.490426	1.960539	1
-0.007194	9.075792	0
0.356107	12.447863	0
0.342578	12.281162	0
-0.810823	-1.466018	1
2.530777	6.476801	1
1.296683	11.607559	0
0.475487	12.040035	0
-0.783277	11.009725	0
0.074798	11.023650	0
-1.337472	0.468339	1
-0.102781	13.763651	0
-0.147324	2.874846	1
0.518389	9.887035	0
1.015399	7.571882	0
-1.658086	-0.027255	1
1.319944	2.171228	1
2.056216	5.019981	1
-0.851633	4.375691	1
-1.510047	6.061992	0
-1.076637	-3.181888	1
1.821096	10.283990	0
3.010150	8.401766	1
-1.099458	1.688274	1
-0.834872	-1.733869	1
-0.846637	3.849075	1
1.400102	12.628781	0
1.752842	5.468166	1
0.078557	0.059736	1
0.089392	-0.715300	1
1.825662	12.693808	0
0.197445	9.744638	0
0.126117	0.922311	1
-0.679797	1.220530	1
0.677983	2.556666	1
0.761349	10.693862	0
-2.168791	0.143632	1
1.388610	9.341997	0
0.317029	14.739025	0