精华内容
下载资源
问答
  • 其中在推导多元线性回归使用最小二乘法的求解原理时,对损失函数求导得到参数向量 的方程式上式中有解,即能够得到最后一步的前提条件是存在逆矩阵,而逆矩阵存在的充分必要条件是特征矩阵不存在多重共线性。...

    上篇文章《简单而强大的线性回归详解》(点击跳转)详细介绍了线性回归分析方程、损失方程及求解、模型评估指标等内容,其中在推导多元线性回归使用最小二乘法的求解原理时,对损失函数求导得到参数向量 的方程式

    上式中有解,即能够得到最后一步的前提条件是存在逆矩阵,而逆矩阵存在的充分必要条件是特征矩阵不存在多重共线性。

    本文将详细介绍线性回归中多重共线性问题,以及一种线性回归的缩减(shrinkage)方法 ----岭回归(Ridge Regression),并对其进行了Python实现

    多重共线性

    多重共线性是指线性回归模型中的解释变量之间由于存在精确相关关系或高度相关关系而使模型估计失真或难以估计准确。

    从线性等式理解,对于  个变量,如果存在常数 使得如下公式,可近似表示为

    那么通常称这 个变量存在多重共线性。

    下面从特征矩阵的角度出发,深入探究多重共线性将究竟如何影响对损失函数求解,以便深刻理解改进原理。

    逆矩阵存在的充要条件

    逆矩阵计算公式

    其中 是伴随矩阵,其存在没有限制条件,当然也不会影响逆矩阵的存在性。而矩阵的行列式 存在于分母上,其值不能为零。由此得到,逆矩阵存在的充分必要条件是:矩阵的行列式不能为0。

    即 存在逆矩阵的充要条件为 不能为0。这是使用最小二乘法来求解线性回归的核心条件之一。

    行列式与矩阵

    矩阵(matrix)是一组数按照一定方式排列的数表,它不能从整体上被看成一个数(只有一个数的1阶矩阵除外),记为

    在线性代数中,行列式(determinant)是一个函数,它将每个 矩阵 对应到一个纯量(scalar),简单讲即是行列式是这一组数按照某种运算法则计算出的一个数,记为 或

    行列式不为零的充要条件

    假设特征矩阵 的结构为,则

    一般行列式计算不会通过展开的方式,而是通过行列初等行变换/列变换将其整合成一个梯形的行列式

    由于梯形行列式下半部分为0,整个矩阵的行列式其实就是梯形行列式对角线上的元素相乘。

    由此可见,如果对角线上的任一个元素为0,则行列式结果即为0。反之,如果对角线上的任一元素均不为0,则行列式不为0。

    矩阵满秩是矩阵的行列式不为0的充分必要条件。

    满秩矩阵

    一个结构为 的矩阵 ,若 转换为梯形矩阵后,没有任何全为0的行或者全为0的列,则称 为满秩矩阵。简单来说,只要对角线上没有一个元素为0,则这个矩阵中绝对不可能存在全为0的行或列。

    矩阵满秩的充要条件

    精确相关关系

    即完全相关,矩阵两行之间或两列之间存在完全线性关系,这种精确相关关系会使得矩阵的行列式为0,则矩阵的逆矩阵不存在。在最小二乘法中,如果矩阵 中存在这种精确相关关系,则逆矩阵不存在,线性回归无法使用最小二乘法求出结果

    无解

    即当 则会发生除零错误 。

    高度相关关系

    即不完全相关,这种高度相关关系下,矩阵的行列式不为0,但是一个非常接近0的数,矩阵的逆是存在的,但接近无限大,直接影响参数向量求解。

    这种情况下,结果参数向量 无穷大,直接影响模型结果,造成模型偏差大或不可用。

    精确相关关系和高度相关关系并称"多重共线性"。

    矩阵行与行或列于列之间相互独立,其矩阵的行列式经初等变换后的对角线上没有任何元素特别接近于0,因此矩阵求得的参数向量不会对模型产生影响,对拟合结果也是较理想的。

    正常值

    由此可见,一个矩阵如果要满秩,则要求矩阵中每个向量之间不能存在多重共线性,这也构成了线性回归算法对于特征矩阵的要求。

    多重共线性与相关性

    多重共线性(Multicollinearity)是一种统计现象,是指线性模型中的特征(解释变量)之间由于存在精确相关关系或高度相关关系, 多重共线性的存在会使模型无法建立,或者估计失真。多重共线性使用指标方差膨胀因子(variance inflation factor,VIF)来进行衡量(from statsmodels.stats.outliers_influence import variance_inflation_factor), 通常当我们提到"共线性",都特指多重共线性。

    相关性(Correlation)是衡量两个或多个变量一起波动的程度的指标,它可以是正的,负的或者0。一般而言,变量之间具有相关性,通常是指线性相关性,线性相关一般由皮尔逊相关系数进行衡量,非线性相关可以使用斯皮尔曼相关系数或者互信息法进行衡量。此部分可参见数据探索分析(点击跳转)。

    多重共线性对回归模型的影响

    回归系数的估计值方差变大,回归系数的置信度变宽,估计的精确性大幅度降低,使得估计值稳定性变差。

    会使得一些回归系数通不过显著性检验,回归系数的正负号也可能出现倒置,使得回归方程无法得到合理的解释,直接影响最小二乘法的计算结果。

    多重共线性如果存在,则线性回归就无法使用最小二乘法来进行求解,或者求解就会出现偏差。不能存在多重共线性,不代表不能存在相关性——机器学习不要求特征之间必须独立,必须不相关,只要不是高度相关或者精确相关就好。

    改进线性回归处理多重共线性

    处理多重共线性方法有多种,其中最直接的方法是手动移除共线性的变量。具体做法是先对数据进行相关分析,若两个特征的相关系数大于某特定值(一般为0.7),则手动移除其中一个特征,再继续做回归分析。这种做法会导致估计结果产生偏差,会引起遗漏变量问题。而且有时数据特征本来就很少,或并不想直接删除特征,此时可考虑其他更加有效的方法。

    改进线性回归即是当前解决多重共线性问题的最有效的方法。

    岭回归

    岭回归分析(Ridge Regression)是一种改良的最小二乘法,其通过放弃最小二乘法的无偏性,以损失部分信息为代价来寻找效果稍差但回归系数更符合实际情况的模型方程。该模型求解的回归模型的损失函数为线性最小二乘函数,正则化采用l2-范数。也称为岭回归(Ridge Regression)或吉洪诺夫正则化(Tikhonov regularization)。岭回归与套索回归(Lasso Regression)两个算法不是为了提升模型表现,而是为了修复漏洞而设计的。(Lasso回归将在下一篇章介绍)

    岭回归原理和逻辑是将求解 的过程转化为一个带条件的最优化问题,然后再用最小二乘法求解。岭回归在多元线性回归的损失函数上加上了正则项,表达为系数 的L2-范式(即系数 的平方项)乘以正则化系数 。

    最小化目标函数:

    假设我们的特征矩阵结构为(m,n),系数 的结构是(1,n), 是构为(n,n)单位矩阵则

    最终得到

    从而转化为只需 存在逆矩阵,就能求解出参数向量 。

    假设原本的特征矩阵存在共线性,即非满秩矩阵

    最后得到的这个行列式还是一个梯形行列式,但已经不存在全0行或者全0列了,除非以下两种情况,否则矩阵永远都是满秩。

    (1) 

    (2) 原本的矩阵存在对角线上元素为 ,且其他元素都为0的行或者列

    以上两种情况,在sklearn中都可以轻松应对:自由控制 ;当出现无法求解时,更换 取值即可。则可认为 是存在的

    其中

    通过调整正则化系数 大小,来避免"精确相关关系"及"高度相关关系"带来的影响。如此,多重共线性就被控制住了:最小二乘法一定有解,并且这个解可以通过 来进行调节,以确保不会偏离太多。当然了, 挤占了 中由原始的特征矩阵贡献的空间,因此 如果太大,也会导致的估计出现较大的偏移,无法正确拟合数据的真实面貌。我们在使用中,需要找出 让模型效果变好的最佳取值。

    语法:
    sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True, normalize=False, copy_X=True, max_iter=None, tol=0.001, solver=’auto’, random_state=None)
    重要参数:

    alpha : {float, ndarray of shape (n_targets,)}, default=1.0

    正则化参数,必须是正浮点数。正则化改善了问题的条件,降低了估计的方差。值越大表示正则化惩罚越强。对应于其它线性模型中的 C−1,如LogisticRegression或LinearSVC。如果传递了数组,则惩罚特定目标。

    例:
    >>> from sklearn.linear_model import Ridge
    >>> import numpy as np
    >>> n_samples, n_features = 10, 5
    >>> rng = np.random.RandomState(0)
    >>> y = rng.randn(n_samples)
    >>> X = rng.randn(n_samples, n_features)
    >>> clf = Ridge(alpha=1.0)
    >>> clf.fit(X, y)
    Ridge()

    虽然岭回归和Lasso不是设计来提升模型表现,而是专注于解决多重共线性问题的,但当 在一定范围内变动的时候,消除多重共线性也许能够一定程度上提高模型的泛化能力。

    案例

    波士顿房价数据集中看岭回归处理多重共线性。

    from sklearn.datasets import load_boston
    from sklearn.model_selection import cross_val_score
    import matplotlib.pyplot as plt
    from sklearn.linear_model import Ridge
    import numpy as np
    from sklearn.linear_model import LinearRegression # 线性回归模型
    from sklearn.model_selection import train_test_split# 交叉验证
    X = load_boston().data
    y = load_boston().target
    Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, y, test_size=0.3,random_state=420)
    #先查看方差的变化,再看R2的变化
    alpha_range = np.arange(1,1001,100)
    ridge_var, lr_var, ridge_mean, lr_mean = [], [], [], []
    plt.figure(figsize=(16,10))
    plt.style.use('seaborn')
    for alpha in alpha_range:
        ridge = Ridge(alpha=alpha)
        linear = LinearRegression()
        score_rig = cross_val_score(ridge,X,y,cv=5,scoring="r2")
        score_linear = cross_val_score(linear,X,y,cv=5,scoring="r2")
        ridge_var.append(score_rig.var())
        lr_var.append(score_linear.var())
        ridge_mean.append(score_rig.mean())
        lr_mean.append(score_linear.mean())
    name = ['variance', 'mean']
    for i,j in enumerate([[ridge_var, lr_var], [ridge_mean, lr_mean]]):
        plt.subplot(2,2,i+1)
        plt.plot(alpha_range,j[0],color="green",label="Ridge")
        plt.plot(alpha_range,j[1],color="blue",label="LR")
        plt.title(f"cross_val_score {name[i]} for different alpha values")
        plt.xlabel("alpha")
        plt.ylabel(f"{name[i]}")
        plt.legend()
    #细化学习曲线
    alpha_range = np.arange(100,300,10)
    ridge_score, lr_score = [], []
    for alpha in alpha_range:
        reg = Ridge(alpha=alpha)
        linear = LinearRegression()
        regs = cross_val_score(reg,X,y,cv=5,scoring = "r2").mean()
        linears = cross_val_score(linear,X,y,cv=5,scoring = "r2").mean()
        ridge_score.append(regs)
        lr_score.append(linears)
    for i,j in enumerate([[ridge_score,"Ridge", "green"], [lr_score, "LR", 'blue']]):
        plt.subplot(2,2,i+3)
        plt.plot(alpha_range,j[0],color=j[2],label=j[1])
        plt.title("cross_val_score mean for different alpha values")
        plt.xlabel("alpha")
        plt.ylabel("Mean")
        plt.legend()
    plt.suptitle("cross_val_score of the LR and Ridge for different alpha values", y=0.95, fontsize=18)
    plt.show()  
    输出结果

    38c43ba93c81f92ef9f9370deb04c442.png

    可以发现,比起加利佛尼亚房屋价值数据集,波士顿房价数据集的方差降低明显,偏差也降低明显,可见使用岭回归还是起到了一定的作用,模型的泛化能力是有可能会上升的。

    选择最佳正则化系数

    使用交叉验证类 RidgeCV 来选择最佳的正则化系数。

    sklearn.linear_model.RidgeCV(alphas=(0.1, 1.0, 10.0), fit_intercept=True, normalize=False, scoring=None, cv=None, gcv_mode=None, store_cv_values=False)
    重要参数

    alphas : numpy array of shape [n_alphas]

    需要测试的正则化参数的取值的元祖

    scoring : string, callable or None, optional, default: None

    用来进行交叉验证的模型评估指标,默认是,可自行调整

    store_cv_values : boolean, default=False

    是否保存每次交叉验证的结果,默认False

    cv : int, cross-validation generator or an iterable, optional

    交叉验证的模式,默认是None,表示默认进行留一交叉验证可以输入Kfold对象和StratifiedKFold对象来进行交叉验证 注意,仅仅当为None时,每次交叉验证的结果才可以被保存下来当cv有值存在(不是None)时,store_cv_values无法被设定为True

    重要属性

    alpha_ : float

    查看交叉验证选中的alpha

    cv_values_ : array, shape = [n_samples, n_alphas] or shape = [n_samples, n_targets, n_alphas], optional

    调用所有交叉验证的结果,只有当 store_cv_values=True 的时候才能够调用,因此返回的结构是 (n_samples, n_alphas)

    重要接口

    score

    调用Ridge类不进行交叉验证的情况下返回的

    >>> import numpy as np
    >>> from sklearn import linear_model
    >>> reg = linear_model.RidgeCV(alphas=np.logspace(-6, 6, 13))
    >>> reg.fit([[0, 0], [0, 0], [1, 1]], [0, .1, 1])
    RidgeCV(alphas=array([1.e-06, 1.e-05, 1.e-04, 1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01,
          1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06]))
    >>> reg.alpha_
    0.01

    另一种方式是使用岭迹图来判断正则项参数的最佳取值,了解即可,实际工作中不建议使用。

    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn import linear_model
    #创造10*10的希尔伯特矩阵
    X = 1. / (np.arange(1, 11) + np.arange(0, 10)[:, np.newaxis])
    y = np.ones(10)
    #计算横坐标
    n_alphas = 200
    alphas = np.logspace(-10, -2, n_alphas)
    #建模,获取每一个正则化取值下的系数组合
    coefs = []
    for a in alphas:
        ridge = linear_model.Ridge(alpha=a, fit_intercept=False)
        ridge.fit(X, y)
        coefs.append(ridge.coef_)
    #绘图展示结果
    ax = plt.gca()
    ax.plot(alphas, coefs)
    ax.set_xscale('log')
    ax.set_xlim(ax.get_xlim()[::-1])  #将横坐标逆转
    plt.xlabel('正则化参数alpha')
    plt.ylabel('系数w')
    plt.title('岭回归下的岭迹图')
    plt.axis('tight')
    plt.show()

    c6a6162cdb7d763c13d57cf98d5f61d7.png

    岭迹图

    以正则化参数即岭参数 为横坐标,线性模型求解的系数即岭系数 为纵坐标的图像,其中每一条彩色的线都是一个岭系数 。其目标是建立岭参数 与岭系数 之间的直接关系,以此来观察岭参数的变化如何影响了岭系数 的拟合。

    岭迹图认为,线条交叉越多,则说明特征之间的多重共线性越高。我们应该选择系数较为平稳的喇叭口所对应的 取值作为最佳的正则化参数的取值。不存在奇异性时,岭迹图应稳定的逐渐趋向于0。

    希伯尔特矩阵

    岭回归分析是一种用于存在多重共线性(自变量高度相关)数据的技术。在线性回归基础上增加L2正则化项 。

    除常数项以外,这种回归的假设与最小二乘回归类似;它收缩了相关系数的值,但没有达到零,这表明它没有特征选择功能,这是一个正则化方法,并且使用的是L2正则化。

    转载请联系笔者

    点赞关注转发在看支持笔者,关注持续获取最新数据分析相关干货。

    展开全文
  • 岭回归是一种专用于共线性数据分析的有偏估计回归方法,实质上是一种改良的最小二乘估计法,通过放弃最小二乘法的无偏性,以损失部分信息、降低精度为代价获得回归系数更为符合实际、更可靠的回归方法,对病态数据的...

    1、岭回归

    岭回归是一种专用于共线性数据分析的有偏估计回归方法,实质上是一种改良的最小二乘估计法,通过放弃最小二乘法的无偏性,以损失部分信息、降低精度为代价获得回归系数更为符合实际、更可靠的回归方法,对病态数据的拟合要强于最小二乘法。

    1.1 Ridge线性回归sklearn API

    sklearn.linear_model.Ridge

    class sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True, normalize=False, copy_X=True, max_iter=None, tol=0.001, solver='auto', random_state=None)
    带有L2正则化的线性最小二乘法。
    
    该模型求解回归模型,其中损失函数是线性最小二乘函数,并且正则化由l2范数给出。 也称为Ridge回归或Tikhonov正则化。 该估计器具有对多变量回归的内置支持(即,当y是形状的2d阵列[n_samples,n_targets]时)。
    
    参数:
    alpha:{float,array-like},shape(n_targets)
        正则化强度; 必须是正浮点数。 正则化改善了问题的条件并减少了估计的方差。 较大的值指定较强的正则化。 Alpha对应于其他线性模型(如Logistic回归或LinearSVC)中的C^-1。 如果传递数组,则假定惩罚被特定于目标。 因此,它们必须在数量上对应。  
    copy_X:boolean,可选,默认为True
        如果为True,将复制X; 否则,它可能被覆盖。 
    fit_intercept:boolean
        是否计算此模型的截距。 如果设置为false,则不会在计算中使用截距(例如,数据预期已经居中)。
    max_iter:int,可选
        共轭梯度求解器的最大迭代次数。 对于'sparse_cg''lsqr'求解器,默认值由scipy.sparse.linalg确定。 对于'sag'求解器,默认值为1000。  
    normalize:boolean,可选,默认为False
        如果为真,则回归X将在回归之前被归一化。 当fit_intercept设置为False时,将忽略此参数。 当回归量归一化时,注意到这使得超参数学习更加鲁棒,并且几乎不依赖于样本的数量。 相同的属性对标准化数据无效。 然而,如果你想标准化,请在调用normalize = False训练估计器之前,使用preprocessing.StandardScaler处理数据。
    solver:{'auto''svd''cholesky''lsqr''sparse_cg''sag'}
        用于计算的求解方法:
        'auto'根据数据类型自动选择求解器。
        'svd'使用X的奇异值分解来计算Ridge系数。对于奇异矩阵比'cholesky'更稳定。
        'cholesky'使用标准的scipy.linalg.solve函数来获得闭合形式的解。
        'sparse_cg'使用在scipy.sparse.linalg.cg中找到的共轭梯度求解器。作为迭代算法,这个求解器比大规模数据(设置tol和max_iter的可能性)的“cholesky”更合适。
        'lsqr'使用专用的正则化最小二乘常数scipy.sparse.linalg.lsqr。它是最快的,但可能不是在旧的scipy版本可用。它还使用迭代过程。
        'sag'使用随机平均梯度下降。它也使用迭代过程,并且当n_samples和n_feature都很大时,通常比其他求解器更快。注意,“sag”快速收敛仅在具有近似相同尺度的特征上被保证。您可以使用sklearn.preprocessing的缩放器预处理数据。
    
    所有最后四个求解器支持密集和稀疏数据。但是,当fit_intercept为True时,只有'sag'支持稀疏输入。
    新版本0.17支持:随机平均梯度下降解算器。
    tol:float
        解的精度
    random_state : int seed,RandomState实例或None(默认)
        伪随机数生成器的种子,当混洗数据时使用。仅用于'sag'求解器。
        最新版本0.17:random_sate支持随机平均渐变。
    
    
    属性:
    coef_:array,shape(n_features,)或(n_targets,n_features)
        权重向量。
    intercept_:float | array,shape =(n_targets,)
        决策函数的独立项,即截距。如果fit_intercept
    n_iter_:array或None,shape(n_targets,)
        每个目标的实际迭代次数。 仅适用于sag和lsqr求解器。其他求解器将返回None。在版本0.17中出现。
    
    
    方法:
    fit(self, X, y[, sample_weight])   : Fit Ridge回归模型
    get_params(self[, deep])           : 获取此估计器的参数。
    predict(self, X)                   : 使用线性模型进行预测
    score(self, X, y[, sample_weight]) : 返回预测的确定系数R ^ 2
    set_params(self, \*\*params)       : 设置estimator的参数
    

    案例:

    # -*- coding: utf-8 -*-
    
    from sklearn.linear_model import Ridge
    import numpy as np
    
    n_samples, n_features = 10, 5
    rng = np.random.RandomState(0)
    y = rng.randn(n_samples)
    print(y)
    
    print("---------------------------------")
    
    X = rng.randn(n_samples, n_features)
    print(X)
    
    print("---------------------------------")
    clf = Ridge(alpha=1.0)
    clf.fit(X, y)
    print(clf.coef_)
    

    输出结果:

    [ 1.76405235  0.40015721  0.97873798  2.2408932   1.86755799 -0.97727788
      0.95008842 -0.15135721 -0.10321885  0.4105985 ]
    ---------------------------------
    [[ 0.14404357  1.45427351  0.76103773  0.12167502  0.44386323]
     [ 0.33367433  1.49407907 -0.20515826  0.3130677  -0.85409574]
     [-2.55298982  0.6536186   0.8644362  -0.74216502  2.26975462]
     [-1.45436567  0.04575852 -0.18718385  1.53277921  1.46935877]
     [ 0.15494743  0.37816252 -0.88778575 -1.98079647 -0.34791215]
     [ 0.15634897  1.23029068  1.20237985 -0.38732682 -0.30230275]
     [-1.04855297 -1.42001794 -1.70627019  1.9507754  -0.50965218]
     [-0.4380743  -1.25279536  0.77749036 -1.61389785 -0.21274028]
     [-0.89546656  0.3869025  -0.51080514 -1.18063218 -0.02818223]
     [ 0.42833187  0.06651722  0.3024719  -0.63432209 -0.36274117]]
    ---------------------------------
    [ 0.51088991  0.03729032 -0.65075201  0.0930311   0.93380887]
    

    1.2 线性回归 LinearRegression与Ridge对比

    岭回归: 回归得到的回归系数更符合实际,更可靠。另外,能让估计参数的波动范围变小,变的更稳定。在存在病态数据偏多的研究中有较大的实用价值。

    2 分类算法–逻辑回归

    逻辑回归,用于表达某件事情发生的可能性
    在这里插入图片描述
    通过上面的图获得:

    1. 广告点击率
    2. 判断用户的性别
    3. 预测用户是否会购买给定的商品类
    4. 判断一条评论是正面的还是负面的

    还比如还可以做以下事情:
    1、一封邮件是垃圾邮件的可能性(是,不是)
    2、你购买一件商品的可能性(买、不买)
    3、广告被点击的可能性(点、不点)

    通过上图的数据,获得上面4个方面的信息,就可以使用逻辑回归。

    逻辑回归是解决二分类问题的利器
    在这里插入图片描述

    2.1 sigmoid函数

    在这里插入图片描述

    2.2 逻辑回归公式

    在这里插入图片描述
    输出:[0,1]区间的概率值,默认0.5作为阀值
    注:g(z)为sigmoid函数

    2.3 逻辑回归的损失函数、优化(了解)

    与线性回归原理相同,但由于是分类问题,损失函数不一样,只能通过梯度下降求解

    对数似然损失函数:
    在这里插入图片描述
    完整的损失函数:
    在这里插入图片描述
    cost损失的值越小,那么预测的类别准确度更高。
    当y=1时:
    在这里插入图片描述
    在这里插入图片描述

    2.4 二分类问题

    二分类问题是指预测的y值只有两个取值(0或1),二分类问题可以扩展到多分类问题。例如:我们要做一个垃圾邮件过滤系统,x是邮件的特征,预测的y值就是邮件的类别,是垃圾邮件还是正常邮件。对于类别我们通常称为正类(positive class)和负类(negative class),垃圾邮件的例子中,正类就是正常邮件,负类就是垃圾邮件。

    2.5 sklearn逻辑回归API

    sklearn.linear_model.LogisticRegression 可以用于概率预测、分类等。
    逻辑回归用于离散变量的分类,即它的输出y的取值范围是一个离散的集合,主要用于类的判别,而且其输出值y表示属于某一类的率。

    Logistic Regression 逻辑回归主要用于分类问题,常用来预测概率,如知道一个人的年龄、体重、身高、血压等信息,预测其患心脏病的概率是多少。经典的LR用于二分类问题(只有0,1两类)。

    class sklearn.linear_model.LogisticRegression(penalty=’l2’, dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None, random_state=None, solver=’liblinear’, max_iter=100, multi_class=’ovr’, verbose=0, warm_start=False, n_jobs=1)
    

    注意:
    (1)在多类别划分中,如果’multi_class’选项设置为’ovr’,训练算法将使用one-vs-rest(OvR)方案;如果’multi_class’选项设置为‘多项式’,则使用交叉熵损失。
    (2)这个类使用’liblinear’ 、‘library’、‘newton-cg’、‘sag’ 和 ‘lbfgs’ 求解器实现了规范化的logistic回归。它的输入矩阵可以是密集和稀疏的矩阵;使用C-ordered arrays or CSR matrices containing 64-bit floats可以获得最佳的性能。
    (3)‘newton-cg’、‘sag’、and 'lbfgs’求解器只支持原始公式下的L2正则化;liblinear求解器同时支持L1和L2的正则化,只对L2处罚采用对偶公式。

    参数说明:
    penalty :str,‘l1’ or ‘l2’,default : ‘l2’。用来指定惩罚的标准,‘newton-cg’、‘sag’ 和 ‘lbfg’ solvers仅支持l2 惩罚。

    1. 如果为’l2’,则优化目标函数为:在这里插入图片描述为极大似然函数。
    2. 如果为’l1’,则优化目标函数为:在这里插入图片描述为极大似然函数。
    3. ‘l1’ : 正则化的损失函数不是连续可导的,而’netton-cg’,‘sag’,'lbfgs’三种算法需要损失函数的一阶或二阶连续可导。
    4. 调参时如果主要是为了解过拟合,选择’l2’正则化就够了。若选择’l2’正则化还是过拟合,可考虑’l1’正则化。
    5. 若模型特征非常多,希望一些不重要的特征系数归零,从而让模型系数化的话,可使用’l1’正则化。

    dual :一个布尔值,默认是False。选择目标函数为原始形式还是对偶形式。如果为True,则求解对偶形式(只是在penalty=‘l2’ 且solver='liblinear’有对偶形式);如果为False,则求解原始形式。(bool, default: False。Dual or primal formulation.Dual formulation只适用于 l2 penalty with liblinear solver.Prefer dual=False when n_samples > n_features)
    注意: :将原始函数等价转化为一个新函数,该新函数称为对偶函数。对偶函数比原始函数更易于优化。

    tol : float, default: 1-4。Tolerance for stopping criteria。(指定判断迭代收敛与否的一个阈值)(优化算法停止的条件。当迭代前后的函数差值小于等于tol时就停止)
    C : 一个浮点数,默认:1.0,它指定了惩罚系数的倒数。如果它的值越小,则正则化越大。(逆正则化的强度,一定要是整数,就像支持向量机一样,较小的值有职责更好的正则化)
    fit_intercept : 一个布尔值,默认为True,指定是否存在截距,默认存在。如果为False,则不会计算b值(模型会假设你的数据已经中心化)。(选择逻辑回归模型中是否会有常数项)
    intercept_scaling : 一个浮点数,只有当solver=‘liblinear’才有意义。当采用fit_intercept时,相当于人造一个特征出来,该特征恒为1,其权重为b。在计算正则化项的时候,该人造特征也被考虑了。因此为了降低人造特征的影响,需要提供 intercept_scaling。
    class_weight : 一个字典或者字符串’balanced’。用于表示分类中各种类型的权重,可以不输入,即不考虑权重。如果输入的话可以调用balanced库计算权重,或者是手动输入各类的权重。比如对于0,1的二元模型,我们可以定义class_weight={0:0.9,1:0.1},这样类型0的权重为90%,而类型1的权重为10%。

    1. 如果为字典:则字典出了每个分类的权重,如{class_label:weight}
    2. 如果为字符串 ‘balanced’:则每个分类的权重与该分类在样品中出现的频率成反比。
    3. 如果未指定,则每个分类的权重都为1。

    max_iter : 一个整数,默认:100,指定最大迭代数。仅仅针对solvers为newton-cg,sag和lbfgs

    random_state : 一个整数或者一个RandomState实例,或者None。(随机数种子,默认为无,仅在正则化优化算法为sag,liblinear时有用)

    1. 如果为整数,则它指定了随机数生成器的种子。

    2. 如果为RandomState实例,则指定了随机数生成器。

    3. 如果为None,则使用默认的随机数生成器。
      solver : 一个字符串,指定了求解最优化问题的算法,可以为如下的值。

    4. ‘newton-cg’:使用牛顿法。

    5. ‘lbfgs’:使用L-BFGS拟牛顿法。(拟牛顿法的一种。利用损失函数二阶倒数矩阵即海森矩阵来迭代损失函数)

    6. ‘liblinear’ :使用 liblinear。(使用坐标轴下降法来迭代化损失函数)

    7. ‘sag’:使用 Stochastic Average Gradient descent 算法。(随机平均梯度下降。每次迭代仅仅用一部分的样本来计算梯度,适合于样本数据多的时候)

    8. ‘saga’
      注意:

    9. 对于规模小的数据集,'liblearner’比较适用;对于规模大的数据集,'sag’比较适用。

    10. 对于多级分类的问题,只有’newton-cg’,‘sag’,‘saga’和’lbfgs’,libniear只支持多元逻辑回归的OvR,不支持MvM,但MVM相对精确。(对于MvM,若模型有T类,每次在所有的T类样本里面选择两类样本出来,把所有输出为该两类的样本放在一起,进行二元回归,得到模型参数,一共需要T(T-1)/2次分类。)

    11. ‘newton-cg’、‘lbfgs’、‘sag’ 只处理penalty=‘12’的情况。相反的’liblinear’和’saga’处理L1惩罚。
      multi_class : 一个字符串,指定对于多分类问题的策略,可以为如下的值。

    12. ‘ovr’ :采用 one-vs-rest 策略。

    13. ‘multinomial’:直接采用多分类逻辑回归策略。
      verbose : 一个正数。用于开启/关闭迭代中间输出的日志。(日志冗长度int:冗长度;0:不输出训练过程;1:偶尔输出; >1:对每个子模型都输出)
      warm_start : 一个布尔值,默认False。是否热启动,如果为True,那么使用前一次训练结果继续训练,否则从头开始训练。
      n_jobs : 并行数,int : 个数。-1,跟CPU核数一致;1 : 默认值。

    返回值:
    coef_ : 权重向量。shape (1, n_features) or (n_classes, n_features)
    intercept : 截距。shape (1,) or (n_classes,)
    n_iter_ : 所有类的实际迭代次数。shape (n_classes,) or (1, )

    方法
    fix(X,y[,sample_weight]):根据给出的训练数据来训练模型。用来训练LR分类器,其中X是训练样本,y是对应的标记样本。
    predict(X):用模型进行预测,返回预测值。(用来预测测试样本的标记,也就是分类。预测x的标签)
    score(X,y[,sample_weight]):返回(X,y)上的预测准确率(accuracy)。
    predict_log_proba(X):返回一个数组,数组的元素依次是 X 预测为各个类别的概率的对数值。
    predict_proba(X):返回一个数组,数组元素依次是 X 预测为各个类别的概率的概率值。
    sparsify() : 将系数矩阵转换为稀疏格式。
    set_params(params) : 设置此估计器的参数。
    get_params([deep]) : Get parameters for this estimator;
    decision_function(X) : 预测样本的置信度分数。
    densify() : 将系数矩阵转换为密集阵列格式。

    sklearn.linear_model.LogisticRegressionCV
    相比于LogisticRegression,LogisticRegressionCV使用交叉验证来选择正则化系数C。

    2.6 LogisticRegression回归案例

    良/恶性乳腺癌肿瘤预测
    原始数据的下载地址:https://archive.ics.uci.edu/ml/machine-learning-databases/
    具体的是:https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data
    内容如下:
    在这里插入图片描述

    数据描述:
    (1)699条样本,共11列数据,第一列用语检索的id,后9列分别是与肿瘤相关的医学特征,最后一列表示肿瘤类型的数值。
    (2)包含16个缺失值,用”?”标出。

    2.6.1 良/恶性乳腺癌肿瘤分类流程

    1. 网上获取数据(工具pandas)
    2. 数据缺失值处理、标准化
    3. LogisticRegression估计器流程

    案例:

    # -*- coding: utf-8 -*-
    
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.linear_model import LogisticRegression
    from sklearn.metrics import classification_report
    import pandas as pd
    import numpy as np
    
    def logistic():
        """
        逻辑回归做二分类进行癌症预测(根据细胞的属性特征)
        :return:
        """
        # 构造列标签名字
        column = ['Sample code number','Clump Thickness', 'Uniformity of Cell Size','Uniformity of Cell Shape','Marginal Adhesion', 'Single Epithelial Cell Size','Bare Nuclei','Bland Chromatin','Normal Nucleoli','Mitoses','Class']
    
        # 读取数据
        data = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data", names=column)
        print(data)
    
        # 缺失值进行处理
        data = data.replace(to_replace='?', value=np.nan)
        data = data.dropna()
    
        # 进行数据的分割
        x_train, x_test, y_train, y_test = train_test_split(data[column[1:10]], data[column[10]], test_size=0.25)
    
        # 产品标准化处理
        std = StandardScaler()
    
        x_train = std.fit_transform(x_train)
        x_test = std.transform(x_test)
    
        # 逻辑回归预测
        lg = LogisticRegression(C=1.0)
        lg.fit(x_train,y_train)
        print(lg.coef_)
    
        y_predict = lg.predict(x_test)
    
        print("准确率:",lg.score(x_test,y_test))
    
        print("召回率:", classification_report(y_test, y_predict, labels=[2, 4], target_names=["良性", "恶性"]))
    
        return None
    
    if __name__ == "__main__":
        logistic()
    

    输出结果:

         Sample code number  Clump Thickness  ...  Mitoses  Class
    0               1000025                5  ...        1      2
    1               1002945                5  ...        1      2
    2               1015425                3  ...        1      2
    3               1016277                6  ...        1      2
    4               1017023                4  ...        1      2
    ..                  ...              ...  ...      ...    ...
    694              776715                3  ...        1      2
    695              841769                2  ...        1      2
    696              888820                5  ...        2      4
    697              897471                4  ...        1      4
    698              897471                4  ...        1      4
    [699 rows x 11 columns]
    D:\installed\Anaconda3\lib\site-packages\sklearn\linear_model\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.
      FutureWarning)
    [[ 1.48655604 -0.03632439  0.54633716  0.80247214  0.43417113  1.17620603
       1.37521541  0.79215824  0.86304763]]
    准确率: 0.9590643274853801
    召回率:               precision    recall  f1-score   support
              良性       0.97      0.97      0.97       117
              恶性       0.94      0.93      0.93        54
        accuracy                           0.96       171
       macro avg       0.95      0.95      0.95       171
    weighted avg       0.96      0.96      0.96       171
    

    2.7 逻辑回归的优缺点

    优点:
    1、实现简单,广泛的应用于工业问题上;
    2、分类时计算量非常小,速度很快,存储资源低;
    3、便利的观测样本概率分数;
    4、对逻辑回归而言,多重共线性并不是问题,它可以结合L2正则化来解决该问题;
    5、适合需要得到一个分类概率的场景

    缺点:
    1、当特征空间很大时,逻辑回归的性能不是很好(看硬件能力)
    2、容易欠拟合,一般准确度不太高。
    3、不能很好地处理大量多类特征或变量
    4、只能处理两分类问题(在此基础上衍生出来的softmax可以用于多分类),且必须线性可分;
    5、对于非线性特征,需要进行转换;

    2.8 逻辑回归 VS 线性回归

    线性回归和逻辑回归是2种经典的算法。经常被拿来做比较,下面整理了一些两者的区别:
    在这里插入图片描述
    1、线性回归只能用于回归问题,逻辑回归虽然名字叫回归,但是更多用于分类问题
    2、线性回归要求因变量是连续性数值变量,而逻辑回归要求因变量是离散的变量
    3、线性回归要求自变量和因变量呈线性关系,而逻辑回归不要求自变量和因变量呈线性关系。
    4、线性回归可以直观的表达自变量和因变量之间的关系,逻辑回归则无法表达变量之间的关系。

    注:
    自变量: 主动操作的变量,可以看做“因变量”的原因
    因变量: 因为“自变量”的变化而变化,可以看做“自变量”的结果。也是我们想要预测的结果。

    2.9 多分类问题

    逻辑回归解决办法:1V1,1Vall
    在这里插入图片描述

    softmax方法-逻辑回归在多分类问题上的推广

    打个赏呗,您的支持是我坚持写好博文的动力
    在这里插入图片描述

    展开全文
  • 多重共线性问题 -- 岭回归方法

    千次阅读 2020-02-28 00:18:10
    本篇博客分为三大部分,线性模型、多重共线性问题和岭回归。其中,线性模型中介绍了线性模型定义和普通最小二乘法对线性模型的拟合。第二部分,借由1987-2007年的人口、消费和科技对碳排放的影响的数据来说明多重...

    概述

    本篇博客分为两大部分,第一部分是最小二乘法作线性回归时会遭遇的问题:多重共线性问题。第二部分,使用岭回归解决第一部分中的多重共线性问题。

    第一部分:线性回归最小二乘法的困境

    第一部分借由1987-2007年的人口、消费和技术对碳排放的影响的数据来说明多重共线性问题(包括如何判断多重共线性问题)和多重共线性问题对普通最小二乘估计的影响。同时也给出线性模型定义和普通最小二乘法对线性模型的拟合的介绍

    1.1 1987-2007年的人口、消费和科技对碳排放的影响

    研究目的是量化分析人口、消费和技术因素对碳排放的影响,进而判断哪些因素是影响气候变化的主要因子。
    文献[1]提出一个关于人文因素 (人口、经济和技术)对环境影响的量化模型STIRPAT模型:
    I = α P b A c T d e (1) I = \alpha P^bA^cT^de \tag{1} I=αPbAcTde(1)
    其中, α \alpha α为模型系数,b、c、d为各自变量指数,e为误差。
    对两边取自然对数,得到方程:
    l n I = l n a + b ( l n P ) + c ( l n A ) + d ( l n T ) + l n e (2) lnI = lna + b(lnP) + c(lnA) + d(lnT)+lne\tag{2} lnI=lna+b(lnP)+c(lnA)+d(lnT)+lne(2)
    将人口城市化率引入模型,得到最终的扩展的STIRPAT模型:
    l n I = l n a + b s ( l n P s ) + b c ( l n P c ) + c ( l n A ) + d ( l n T ) + l n e (3) lnI = lna + b_s(lnP_s) + b_c(lnP_c)+ c(lnA) + d(lnT)+lne \tag{3} lnI=lna+bs(lnPs)+bc(lnPc)+c(lnA)+d(lnT)+lne(3)

    模型一般还会假设误差项 l n e lne lne满足正态分布、同方差,见附录1。
    数据可以从这里下载链接:https://pan.baidu.com/s/1wl_TtsXLLSdZoT48U_fznw
    提取码:2xeb
    数据来源于文献[1],如表1所示:
    原始数据
    按照公式(3),使用statsmodels库中的简单最小二乘法对公式(3)进行回归方程拟合。
    statsmodels起源于Jonathan Taylor用R语言实现的各类统计分析模型,由Skipper Seabold 和Josef Perktold于2010年开始开发,实现各种统计模型和假设检验。
    下面是数据读取和标准化代码:

    import numpy as np
    import pandas as pd
    # 载入数据
    file_path = "./PopulationConsumptionAndCarbonEmission1980_2007.csv"
    data_df = pd.read_csv(open(file_path, encoding='utf-8'))
    # 给列名重新命名,每一列就是一个自(因)变量的观测值
    data_df.columns = ['year','I', 'Ps', 'Pc', 'A', 'T']
    # 量纲恢复
    data_df['I'] = data_df['I']*1e4
    data_df['Ps'] = data_df['Ps']*1e4
    data_df['T'] = data_df['T']*1e4
    # 数据标准化
    def Normalize(data):
        """对因变量作标准化变换,标准化因子选择是标准差,这个和文献[1]不相同"""
        return (data - data.mean())/data.std()
    

    下面是statsmodels库中的简单最小二乘法拟合公式(3)的代码:

    import statsmodels.api as sm
    # 为了时间连续性,选取1990-2007年数据,下同。
    X = np.log(data_df.iloc[2:,2:])
    y = np.log(data_df.iloc[2:,1])
    X = sm.add_constant(X)
    ols_model = sm.OLS(y, X).fit()
    print(ols_model.summary())
    

    回归结果如下图所示:
    回归结果
    第二条警告说的是条件数太大,这可能表明存在强烈的多重共线性或其它数值问题。多重共线性指的是自变量之间存在线性相关关系,这个与线性回归的基本假设第一条“自变量之间互不影响”相违背(线性回归的基本假设见附录1),因此,此数据不满足线性回归的基本假设,自然不可以使用简单线性回归进行公式(3)的拟合。最终解决办法放在第二部分介绍,下面深入介绍自变量之间的多重共线性问题如何判断。

    1.2 数据多重共线性的判断

    本小节参考自文献[3],通过三种方法来判断:相关系数(粗略判断有无)、方差扩大因子法(variance inflation factor, VIF)和条件数法。

    下面的数据标准化操作是为了消除量纲不同和不同数量级的差异所带来的的影响,见文献[1]的P76。

    1.3.1 相关系数计算

    # 为了时间连续性,选取1990-2007年数据,下同。
    rxy = np.log(data_df.iloc[2:,1:]).corr(method='pearson')
    

    rxy的结果如下图所示:
    rxy结果
    可见,任意两个自变量之间的相关系数的绝对值都超过了0.5,说明两两自变量之间的线性关系很明显[3]。

    1.3.1 方差扩大因子法

    def VIF_value(normal_x):
        """计算方差扩大因子VIF
           输入:标准化的自变量观测值,normal_x
           返回:每个自变量的VIF值
        """
        # 计算自变量之间的两两相关系数
        rxx = normal_x.corr(method='pearson')
        # 计算相关系数矩阵的逆
        C = np.matrix(rxx).I 
        # 返回方差扩大因子,C对角线上元素,并保留两位小数
        return np.diag(C).round(2)
    # 计算1990-2007年数据中自变量的方差扩大因子
    X = np.log(data_df.iloc[2:,2:])
    y = np.log(data_df.iloc[2:,1])
    vif = VIF_value(Normalize(X))
    

    计算结果是:array([282.92, 29.2 , 221.86, 19.76])。当自变量 x i x_i xi方差因子大于10,说明自变量 x i x_i xi与其余自变量存在共线性。显然这里每一个自变量都与其余自变量存在线性关系[3]。

    1.3.1 条件数法

    def Condition_number(normal_x):
        """
        返回条件数、特征值和特征向量
        输入:标准化后的自变量观测值;
        返回:条件数、特征值和特征向量
        """
        x_array = np.array(normal_x)
        # 计算x_array的特征值和特征向量
        ev, evct = np.linalg.eig(np.dot(x_array.T,x_array))
        # 计算条件数
        k = ev.max()/ev.min()
        return k, ev, evct
    # 计算1990-2007年数据中自变量的条件数
    X = np.log(data_df.iloc[2:,2:])
    y = np.log(data_df.iloc[2:,1])
    k,_,_ = Condition_number(Normalize(X))
    

    条件数计算结果是k = 1912.8255998684424。
    条件数检验准则是[3]:

    • 100 ≤ k ≤ 1000 100\le k \le 1000 100k1000,则认为存在较强的多重共线性;
    • 1000 ≤ k 1000\leq k 1000k,则认为存在严重的多重共线性。
      由k= 1912.8可知,自变量之间存在严重的多重共线性。但是,这个地方我有个疑问,为什么这里计算的条件数和上面statsmodels中计算的不一样?虽然这个不影响对多重共线性问题结果的判断。

    第二部分 多重共线性的消除与岭回归

    现在开始解决第一部分中的自变量之间多重共线性问题,文献[1]并不想通过剔除共线性自变量来解决问题,因为文献[1]想要研究这四个自变量对因变量的影响显著程度。因此,岭回归便成了唯一的办法。

    岭回归的核心思想是:既然共线性会使得回归参数估值过大,那么就回归参数加入惩罚项,来控制回归参数的估计范围,从而弱化共线性对回归参数估计的影响。

    研究了好久 statsmodels的官网https://www.statsmodels.org/stable/index.html,而且这个网站响应太慢了,网页刷新一次要好久,也没有找到岭回归方法,也不知道是不是没有这个,希望有知道的小伙伴能在评论区交流交流。

    2.1 sklearn岭回归

    于是,我就使用了sklearn中的岭回归,解决这个多重共线性问题。代码如下:

    # 载入标准化后的数据
    X, y = Normalize(data_df.iloc[2:,2:]), Normalize(data_df.iloc[2:,1])
    # 指定alpha系数范围
    k = np.linspace(0.2,1,20)
    ridge_reg = linear_model.RidgeCV(alphas=k)
    # 用数据拟合模型
    ridge_reg.fit(X, y)
    print(ridge_reg.coef_,ridge_reg.alpha_,,ridge_reg.intercept_)
    

    最终结果,岭回归系数是 [0.62645745, 0.01831523, 1.0759906 , 0.89142276], α = 0.2 \alpha=0.2 α=0.2,常数项intercept_约等于0,sklearn中没有对回归系数进行显著性检验的工具(对于为什么是这样文献[3]给出了说明,整理在了本文附录2中),只有对回归方程显著性检验指标 R 2 R^2 R2决定系数,代码如下。

    ridge_reg.score(X,y)
    

    结果为0.9768888111923794。还算能够接受。于是,拟合得到如下标准化岭回归方程(即通过标准化自变量观测数据拟合的回归方程)。
    l n I ^ = 0.6265 ( l n P ^ s ) + 0.0183 ( l n P ^ c ) + 1.0760 ( l n A ^ ) + 0.8914 ( l n T ^ ) (4) ln\hat I = 0.6265(ln\hat P_s) +0.0183(ln\hat P_c)+ 1.0760(ln\hat A) + 0.8914(ln\hat T) \tag{4} lnI^=0.6265(lnP^s)+0.0183(lnP^c)+1.0760(lnA^)+0.8914(lnT^)(4)
    按照下面代码计算得到(非标准化的)岭回归方程:

    X = np.log(data_df.iloc[2:,2:])
    y = np.log(data_df.iloc[2:,1])
    # 计算非标准化的岭回归方程系数
    coef_ = ridge_reg.coef_*(y.std()/X.std())
    

    l n I = 3.9323 ( l n P s ) + 0.0284 ( l n P c ) + 0.8165 ( l n A ) + 0.9975 ( l n T ) (5) lnI =3.9323(lnP_s) +0.0284(lnP_c)+ 0.8165(lnA) + 0.9975(lnT) \tag{5} lnI=3.9323(lnPs)+0.0284(lnPc)+0.8165(lnA)+0.9975(lnT)(5)

    2.2 计算结果分析

    首先要说的是,本文结果 和原文文献[2]有较大出入,如有不合理之处,欢迎大家在评论区交流。

    按照公式 (4),我国1990-2007该阶段碳排放的解释因素按其影响比重大小,依次是:人均消费(1.0760)、碳排放强度(0.8914)、人口数量(0.6265)和城市化率(0.0183)。

    文献[2]中的次序是:人均消费(0.3454)、城市化率(0.3414)、人口数量(0.2970)、碳排放强度(0.0374)

    同样的就是文献[1]在人均消费这个因素上没有将物价通货膨胀的影响纳入考虑,如果考虑进去后,碳排放强度可能会抢占第一。人均消费第一 说明,该阶段财富增长刺激了人们消费的欲望,而消费增长将会对碳排放产生直接的促进作用。即居民消费水平的提高对碳排放产生了深刻的影响。

    碳排放强度指的是万元GDP碳排放的量。该阶段我国大力发展房地产经济和劳动密集型产业,房地产经济带动的水泥石化等碳排放很大的重工业 ,该阶段北京等地区春秋季多雾霾现象也从另一方面印证碳排放强度这个因素对该阶段碳排放的影响(雾霾成因多种多样,有自然客观因素,也有人类活动因素,其中人类活动主要表现在:汽车尾气、工业排放、建筑扬尘、垃圾焚烧等)。这个反映出我国在发展中的工业化进程对碳排放有着重大影响,也符合西方国家的工业化历史发展,所以说碳排放强度因素对该阶段碳排放影响占重要地位也符合工业化历史规律。

    值得注意的是,碳排放强度高于人口数量和城市化率,这说明我国进行节能减排和发展绿色经济对于减少碳排放将会有显著的成效。

    人口数量和碳排放强度差距并不是特别多,这也说明人口规模依然是我国资源和环境压力的主要因素之一。

    附录1:线性模型和普通最小二乘法

    线性模型是指预测值是特征(feature)的线性组合(liner combination),数学表达式如下:
    y i ^ = β 0 + β 1 x i 1 + . . . + β p x i p (4) \hat {y_i}= \beta_0 + \beta_1 x_{i1} + ... + \beta_p x_{ip} \tag{4} yi^=β0+β1xi1+...+βpxip(4)
    y i = y ^ i + ϵ i (5) y_i = \hat y_i + \epsilon_i \tag{5} yi=y^i+ϵi(5)
    i = 1 , 2 , . . . , n i=1,2,...,n i=1,2,...,n
    其中:
    y ^ \hat {y} y^是预测值(也叫因变量);
    y y y是真实值;
    β = ( β 1 , . . . , β p ) \beta = (\beta_1,..., \beta_p) β=(β1,...,βp)是系数coef_;
    β 0 \beta_0 β0是截距intercept_;
    x i 1 , . . . , x i p x_{i1},..., x_{ip} xi1,...,xip是第 i i i个样本点, 是 x x x的行向量;
    ϵ i \epsilon_i ϵi是第 i i i个样本点估计的误差项。

    普通最小二乘法拟合线性模型,本质上解决的是:
    min ⁡ β ∣ ∣ x β − y ∣ ∣ 2 2 \min_ {\beta} || x\beta-y || _2 ^ 2 βminxβy22
    其中:
    β = ( β 1 , . . . , β p ) \beta = (\beta_1,..., \beta_p) β=(β1,...,βp)是回归系数coef_;
    x = ( x 1 , . . . , x p ) x = (x_1,..., x_p) x=(x1,...,xp) x x x的列向量,也叫自变量;
    y = ( y 1 , y 2 , . . . , y p ) y = (y_1,y_2,...,y_p) y=(y1,y2,...,yp)是样本观测值(也叫自变量);

    线性回归模型基本假设

    • 自变量 x 1 , x 2 , . . , x p x_1,x_2,..,x_p x1,x2,..,xp是确定的观测值,且互不影响。
    • 因变量与自变量之间是近似线性的关系,即公式(4)所示;
    • 误差项 ϵ i \epsilon_i ϵi的均值为0,方差形同,且两两不相关。

    { E ( ϵ i ) = 0 v a r ( ϵ i ) = σ 2 c o v ( ϵ i , ϵ j ) = 0 \left\{ \begin{aligned} E(\epsilon_i) & = &0 \\ var(\epsilon_i) & = & \sigma^2 \\ cov(\epsilon_i, \epsilon_j)& = & 0 \end{aligned} \right. E(ϵi)var(ϵi)cov(ϵi,ϵj)===0σ20
    其中, i ≠ j , i = 1 , 2 , . . . , n ; j = 1 , 2 , . . . , n i\neq j,i=1,2,...,n;j=1,2,...,n i=j,i=1,2,...,n;j=1,2,...,n

    也就是说如果自变量 x i x_i xi x j x_j xj的相关时,最小二乘法的估计值会对自变量X中的随机误差极其敏感,会产生很大的方差。在没有实验设计就进行数据收集,很容易在自变量之间产生多重共线问题。

    附录 2:回归模型和其在经典统计学 、机器学习中应用

    F2.1 回归模型

    • 回归的意思是趋向平均
    • 回归的模型有线性模型和非线性(逻辑回归)之分

    F2.2 统计学中回归分析

    • 回归方程系数 β 0 , β 1 \beta_0,\beta_1 β0,β1等的估计方法;
    • 估计量 β ^ 0 , β ^ 1 \hat\beta_0,\hat\beta_1 β^0,β^1的统计性质:无偏性和有效性;
    • 统计性质检验:t检验、F检验
    • 模型假设诊断:误差项是否满足独立、同方差的假设等
    • 新样本点输出值的预测

    F2.3 机器学习中的回归分析

    • 以算法为中心进行处理数据
    • 假设数据背后的理论结构是复杂和未知的:因而不太关注模型的假设和统计检验
    • 致力于用算法模拟数据产生的过程,从而达到较好的预测效果
    • 缺陷是理论可解释性差

    F2.4 统计学视角和机器学习视角对比

    • 统计学视角是以数学模型为基础,基于人类既有的经验和理论推导,需要对问题场景和数据特征做出种种假设(例如误差项服从正态分布等)
    • 大数据时代,数据越来越复杂,无法满足统计视角下的种种假设,或者是已经超出了人类既有的经验和理论。机器学习提供了一个从数据本身的角度探寻的可能。
    • 适当的做法是结合统计学和机器学习,进行适当的综合(具体怎么做没想法,目前只有这个概念)

    参考文献

    [1]何晓群,刘文卿.应用回归分析(第三版)[M].中国人民大学出版社
    [2]朱勤, 彭希哲, 陆志明, et al. 人口与消费对碳排放影响的分析模型与实证[J]. 中国人口.资源与环境, 2010(02):102-106.
    [3]https://www.bilibili.com/video/av80412525?p=27
    [4]https://zhuanlan.zhihu.com/p/72722146

    展开全文
  • 回归算法线性回归线性回归的定义线性回归误差的度量线性回归减小误差的方法方法一:正规方程方法二:梯度下降正规方程和梯度下降的对比回归性能评估过拟合和欠拟合过拟合欠拟合解决方法岭回归岭回归的概念岭回归的...

    线性回归

    线性回归的定义

    线性回归通过一个或多个自变量与因变量之间的关系进行建模与回归分析,其特点为一个或多个回归系数的参数的线性组合。根据自变量的个数不同分为一元线性回归和多元线性回归。其具体表示公式如下:
    在这里插入图片描述

    线性回归误差的度量

    损失函数,又称最小二乘法,其具体表示公式如下:
    在这里插入图片描述

    线性回归减小误差的方法

    核心思想:找到最小损失对应的W值

    方法一:正规方程
    • 具体公式
      在这里插入图片描述
    • 注意点:需要进行标准化处理
    • 缺点:当特征过于复杂时,求解速度太慢。
    • 代码示例(预测波士顿房价)
    from sklearn.datasets import load_boston
    from sklearn.linear_model import LinearRegression
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.metrics import mean_squared_error
    
    def mylinear():
        """
        用LinearRegression方法预测波士顿房价
    
        :return: None
        """
    
        # 获取数据
        lb = load_boston()
    
        # 分割数据集
        x_train, x_test, y_train, y_test = train_test_split(lb.data,lb.target,test_size=0.25)
    
        # 标准化处理(注意特征值和目标值需要实例化两个API,因为维数不一样)
    
        std_x = StandardScaler()
        x_train = std_x.fit_transform(x_train)
        x_test = std_x.transform(x_test)
    
        std_y = StandardScaler()
        y_train = std_y.fit_transform(y_train.reshape(-1,1))
        y_test = std_y.transform(y_test.reshape(-1,1))
    
        # 用估计器预测房价结果
        lr = LinearRegression()
        lr.fit(x_train,y_train)
        print(lr.coef_)
    
        predict_std = lr.predict(x_test)
        y_predict = std_y.inverse_transform(predict_std.reshape(-1,1))
        print("线性回归方程预测房价结果:", y_predict)
        print("线性回归方程预测军方误差:", mean_squared_error(std_y.inverse_transform(y_test),y_predict))
    
    
        return None
    
    if __name__ == '__main__':
        mylinear()
    

    输出结果:

    [[-0.07189689  0.11056253  0.00852308  0.06510871 -0.17156743  0.3417623
      -0.0550457  -0.29720397  0.22697546 -0.21461555 -0.21549207  0.12524146
      -0.323476  ]]
    线性回归方程预测房价结果: [[16.67298491]
     [21.51430668]
     [15.63161012]
     [41.67971428]
     [22.12070811]
     [29.74143583]
     [45.16135176]
     [13.47566068]
     [18.94535531]
     [28.80047496]
     [21.2140528 ]
     [28.17246202]
     [26.24308882]
     [12.27271099]
     [26.33784283]
     [20.0184693 ]
     [15.56019304]
     [19.78458139]
     [ 8.44834886]
     [19.2649333 ]
     [32.51179258]
     [23.04744077]
     [12.19437145]
     [18.24760861]
     [18.15170883]
     [11.03283082]
     [25.74066679]
     [30.53326076]
     [28.75518113]
     [15.41794206]
     [31.71846201]
     [13.11025356]
     [ 9.39360885]
     [25.86065388]
     [14.83219011]
     [19.17522972]
     [24.72453426]
     [17.97900083]
     [24.60920764]
     [16.33075212]
     [32.92539655]
     [19.33175092]
     [22.56207634]
     [22.08126759]
     [26.8019178 ]
     [27.81518837]
     [ 6.13935003]
     [20.20341886]
     [15.83163726]
     [33.39822915]
     [21.91187973]
     [21.30148556]
     [29.69154311]
     [35.27221326]
     [25.36056497]
     [22.99531908]
     [24.23264307]
     [ 9.91553065]
     [26.88413251]
     [22.80506192]
     [22.10942353]
     [34.84690799]
     [17.0764197 ]
     [30.17811061]
     [30.3602628 ]
     [25.59228421]
     [19.61567103]
     [17.44520032]
     [32.08421329]
     [22.42346097]
     [35.13647673]
     [23.55930269]
     [27.7629917 ]
     [25.36087011]
     [22.98636269]
     [23.81183436]
     [43.91295741]
     [31.0158378 ]
     [23.90163612]
     [19.8617725 ]
     [ 0.40462815]
     [19.06456293]
     [21.00950922]
     [30.57172582]
     [21.54336377]
     [17.94269787]
     [22.56265107]
     [18.70495122]
     [28.99876226]
     [34.92273719]
     [23.07659802]
     [10.38802434]
     [21.50174461]
     [16.91550915]
     [28.36196581]
     [24.33000943]
     [25.9625918 ]
     [17.19987812]
     [36.29645747]
     [20.3181725 ]
     [ 6.31130636]
     [ 9.82912988]
     [ 5.71437948]
     [12.55375899]
     [11.8760076 ]
     [21.08312231]
     [16.16794352]
     [23.89854365]
     [19.00454068]
     [16.35134125]
     [25.74128361]
     [15.40079632]
     [36.4936849 ]
     [ 5.36164699]
     [24.70578649]
     [34.23378414]
     [28.17193439]
     [27.68687533]
     [17.6316129 ]
     [27.19337924]
     [19.31946272]
     [22.02621029]
     [27.28518294]
     [29.49658103]
     [39.68007288]
     [40.08295584]
     [26.26031041]]
    线性回归方程预测军方误差: 30.331638135174217
    
    方法二:梯度下降
    • 概念:沿着这个函数下降的方向找,最后就能找到山谷的最低点,然后更新W值,每次下降的幅度不同。
    • 算法公式:
      在这里插入图片描述
    • 示意图
      即从一开始随机生成的权重对应的cost函数值,沿着下降方向,以不同的学习速率下降,直到最终找到cost函数最小时对应的W值为止。
      在这里插入图片描述
    • 注意点:需要进行标准化处理
    • 适用场景:面对训练数据规模十分庞大的任务
    • 代码示例(预测波士顿房价)
    from sklearn.datasets import load_boston
    from sklearn.linear_model import SGDRegressor
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.metrics import mean_squared_error
    
    def mysgd():
        """
        用SGDRegression方法预测波士顿房价
    
        :return: None
        """
    
        # 获取数据
        lb = load_boston()
    
        # 分割数据集
        x_train, x_test, y_train, y_test = train_test_split(lb.data,lb.target,test_size=0.25)
    
        # 标准化处理(注意特征值和目标值需要实例化两个API,因为维数不一样)
    
        std_x = StandardScaler()
        x_train = std_x.fit_transform(x_train)
        x_test = std_x.transform(x_test)
    
        std_y = StandardScaler()
        y_train = std_y.fit_transform(y_train.reshape(-1,1))
        y_test = std_y.transform(y_test.reshape(-1,1))
    
        # 用估计器预测房价结果
        sgd = SGDRegressor()
        sgd.fit(x_train,y_train)
        print(sgd.coef_)
    
        predict_std = sgd.predict(x_test)
        y_predict = std_y.inverse_transform(predict_std.reshape(-1,1))
        print("梯度回归方程预测房价结果:", y_predict)
        print("梯度回归方程预测军方误差:", mean_squared_error(std_y.inverse_transform(y_test),y_predict))
    
    
        return None
    
    if __name__ == '__main__':
        mysgd()
    

    输出结果:

    [-0.09899378  0.05707105 -0.06552787  0.10473573 -0.10534929  0.36552032
     -0.02953529 -0.21774241  0.10686514 -0.05112742 -0.19883048  0.07593193
     -0.34252204]
    梯度回归方程预测房价结果: [[18.15533454]
     [34.11869678]
     [32.14174411]
     [21.34420274]
     [17.21388765]
     [16.35700059]
     [21.91035209]
     [25.74225411]
     [13.80938554]
     [37.0260741 ]
     [20.34283321]
     [22.60332358]
     [10.57004107]
     [20.23572153]
     [ 9.59137916]
     [28.41603421]
     [17.68100316]
     [21.23897539]
     [17.53442359]
     [13.19849714]
     [20.14575752]
     [33.52831795]
     [17.12473639]
     [21.36697523]
     [17.90262181]
     [ 4.09907073]
     [21.95366187]
     [33.80847587]
     [20.27105119]
     [17.53696132]
     [33.11813363]
     [28.80634195]
     [ 6.57209533]
     [25.48550927]
     [23.35904861]
     [35.9924995 ]
     [ 5.20083665]
     [20.03161132]
     [26.15215008]
     [36.99552849]
     [21.72707286]
     [36.55176266]
     [22.03371153]
     [23.26822998]
     [21.48258812]
     [19.91669232]
     [24.69897601]
     [41.31930121]
     [20.08257762]
     [13.07880876]
     [20.2117174 ]
     [23.51263223]
     [40.44256018]
     [33.56951898]
     [27.71772647]
     [24.50848523]
     [17.46991589]
     [21.44298149]
     [19.40351808]
     [-4.20320864]
     [24.41236848]
     [22.70770552]
     [18.32786776]
     [21.20199655]
     [29.35400254]
     [17.98159301]
     [23.30945554]
     [19.72799619]
     [17.12636849]
     [17.75898183]
     [23.46041889]
     [13.44739229]
     [22.7480483 ]
     [17.2265867 ]
     [26.99748033]
     [21.60716127]
     [14.71744082]
     [20.73697436]
     [32.00570023]
     [17.61311475]
     [20.89879453]
     [18.10165056]
     [24.57757874]
     [35.80571785]
     [23.92253462]
     [25.27805868]
     [40.2727596 ]
     [13.42459155]
     [19.19037907]
     [32.87888685]
     [ 6.42186031]
     [19.53277955]
     [ 8.98051468]
     [26.30031149]
     [20.90806747]
     [15.90596611]
     [16.28474562]
     [20.14033052]
     [30.55707971]
     [17.70373075]
     [15.45362061]
     [ 5.7067405 ]
     [21.30190112]
     [32.76682679]
     [38.25465606]
     [27.28654404]
     [15.74370192]
     [20.45658597]
     [28.26599518]
     [12.94885544]
     [35.28388653]
     [26.48460038]
     [21.49836632]
     [20.56639879]
     [28.386673  ]
     [32.78291138]
     [12.35907231]
     [ 9.89626638]
     [24.98827917]
     [29.76318234]
     [18.2809601 ]
     [21.24515354]
     [34.17683845]
     [29.44239205]
     [22.00955944]
     [22.65328658]
     [22.50688932]]
    梯度回归方程预测军方误差: 24.97920841695512
    

    正规方程和梯度下降的对比

    在这里插入图片描述
    注:正规方程适用于小规模场景,梯度方程适用于大规模场景

    • 不同算法使用场景截图(官网)
      在这里插入图片描述

    回归性能评估

    • 评估函数
      (均方误差(Mean Squared Error)MSE) 评价机制,具体公式如下:
      在这里插入图片描述
    • 评估代码实现
    1. API:sklearn.metrics.mean_squared_error
    2. 函数:mean_squared_error(y_true, y_pred)
      均方误差回归损失
      y_true:真实值
      y_pred:预测值
      return:浮点数结果
    3. 注意点:真实值,预测值为标准化之前的值

    过拟合和欠拟合

    过拟合和欠拟合所处区间示意图
    在这里插入图片描述

    过拟合

    一个假设在训练数据上能够获得比其他假设更好的拟合, 但是在训练数据外的数据集上却不能很好地拟合数据,此时认为这个假设出现了过拟合的现象。(模型过于复杂)

    欠拟合

    一个假设在训练数据上不能获得更好的拟合, 但是在训练数据外的数据集上也不能很好地拟合数据,此时认为这个假设出现了欠拟合的现象。(模型过于简单)

    解决方法
    • 欠拟合:
    1. 欠拟合形成原因:学习到数据的特征过少
    2. 欠拟合解决方法:增加数据的特征数量
    • 过拟合
    1. 过拟合形成原因:原始特征过多,存在一些嘈杂特征, 模型过于复杂是因为模型尝试去兼顾各个测试数据点
    2. 1) 进行特征选择,消除关联性大的特征(很难做);2)交叉验证,只能帮助判断是过拟合还是欠拟合,但不能从根本上解决这一问题(让所有数据都有过训练);3)正则化(了解)

    岭回归

    岭回归的概念

    针对线性回归中的过拟合问题,以正则化为解决方法,产生了“岭回归”这种回归算法。
    目的:尽量减小高次项特征的影响
    作用:可以使得W的每个元素都很小,都接近于0
    优点:回归得到的回归系数更符合实际,更可靠。另外,能让
    估计参数的波动范围变小,变的更稳定。在存在病态数据偏多的研究中有较大的实用价值。

    岭回归的代码实现

    1. API:sklearn.linear_model.Ridge
    2. 函数:klearn.linear_model.Ridge(alpha=1.0)
      具有l2正则化的线性最小二乘法
      alpha:正则化力度
      coef_:回归系数
    3. 正则化程度的变化对结果的影响在这里插入图片描述
    4. 代码示例(预测波士顿房价)1
    from sklearn.datasets import load_boston
    from sklearn.linear_model import Ridge
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.metrics import mean_squared_error
    
    def mysgd():
        """
        用SGDRegression方法预测波士顿房价
    
        :return: None
        """
    
        # 获取数据
        lb = load_boston()
    
        # 分割数据集
        x_train, x_test, y_train, y_test = train_test_split(lb.data,lb.target,test_size=0.25)
    
        # 标准化处理(注意特征值和目标值需要实例化两个API,因为维数不一样)
    
        std_x = StandardScaler()
        x_train = std_x.fit_transform(x_train)
        x_test = std_x.transform(x_test)
    
        std_y = StandardScaler()
        y_train = std_y.fit_transform(y_train.reshape(-1,1))
        y_test = std_y.transform(y_test.reshape(-1,1))
    
        # 用估计器预测房价结果
        rd = Ridge()
        rd.fit(x_train,y_train)
        print(rd.coef_)
    
        predict_std = rd.predict(x_test)
        y_predict = std_y.inverse_transform(predict_std.reshape(-1,1))
        print("岭回归方程预测房价结果:", y_predict)
        print("岭回归方程预测军方误差:", mean_squared_error(std_y.inverse_transform(y_test),y_predict))
    
    
        return None
    
    if __name__ == '__main__':
        mysgd()
    

    输出结果:

    [[-0.09712775  0.10193582  0.04583568  0.09351994 -0.18624549  0.31246168
      -0.00936299 -0.30612679  0.31170519 -0.28632496 -0.18517174  0.13279692
      -0.40581663]]
    岭回归方程预测房价结果: [[37.00176928]
     [13.26132682]
     [23.54672912]
     [22.71654214]
     [25.67990408]
     [19.54523528]
     [20.67861965]
     [32.5417979 ]
     [22.99726104]
     [28.36399662]
     [40.68055885]
     [21.15905508]
     [16.67517075]
     [14.19302252]
     [17.38041852]
     [31.24705479]
     [13.50863022]
     [27.34963008]
     [41.25713632]
     [20.70165982]
     [23.24533533]
     [39.85987694]
     [32.83040663]
     [13.04899638]
     [14.0838789 ]
     [18.06380925]
     [19.6426615 ]
     [27.21555235]
     [17.67976907]
     [34.45092919]
     [26.22531561]
     [-0.33650528]
     [23.34381681]
     [33.72670693]
     [15.28809868]
     [23.24733193]
     [24.30973196]
     [18.18241414]
     [15.5708979 ]
     [16.64774211]
     [23.98182194]
     [40.942158  ]
     [26.93749796]
     [29.60798076]
     [22.77235029]
     [20.29534231]
     [28.39466337]
     [19.64746016]
     [ 2.4324661 ]
     [26.53607902]
     [21.28318569]
     [16.89454292]
     [13.02035884]
     [27.05552907]
     [18.76256831]
     [25.48453803]
     [22.98359125]
     [34.12163382]
     [-0.07566267]
     [27.22672687]
     [24.57249196]
     [31.35506797]
     [21.51520609]
     [18.1874919 ]
     [ 5.91854968]
     [28.8187358 ]
     [20.02153002]
     [22.97045159]
     [20.51448762]
     [23.01560955]
     [36.30354424]
     [26.7269793 ]
     [19.40240129]
     [25.22398079]
     [25.89558279]
     [25.43732688]
     [28.03109779]
     [19.60742959]
     [23.1766216 ]
     [33.27108218]
     [22.40006098]
     [23.6421197 ]
     [17.17184732]
     [10.82001448]
     [25.60073618]
     [16.22722067]
     [19.81550019]
     [11.61445192]
     [35.65601271]
     [15.29808558]
     [24.62870842]
     [24.89710764]
     [17.93088168]
     [23.31675652]
     [35.35558844]
     [13.24745034]
     [22.10891563]
     [22.51795098]
     [22.32261331]
     [30.19595212]
     [33.13758238]
     [39.13321668]
     [24.43840237]
     [22.96093311]
     [21.18458161]
     [30.30673668]
     [33.30111801]
     [19.22585514]
     [18.14130464]
     [14.90996596]
     [ 9.36230842]
     [15.03863595]
     [13.26064651]
     [23.26088159]
     [21.56648367]
     [22.11404782]
     [29.44668622]
     [25.73617186]
     [19.26855022]
     [17.1962654 ]
     [22.0283875 ]
     [36.84887348]
     [11.14088656]
     [26.13613835]
     [24.94894001]
     [23.38184477]
     [16.32009033]]
    岭回归方程预测军方误差: 27.751727283864966
    

    1. 比较不同回归算法的效果时,需要将训练集和测试集固定,本文中三种算法的训练集和测试集未固定,均为随机生成。 ↩︎

    展开全文
  • 岭回归线性回归的正则化版本,即在原来的线性回归的cost function中添加正则项: 以达到在拟合数据的同时,使模型权重尽可能小的目的,岭回归代价函数: a=0:岭回归退化为线性回归 2.L...
  • 在网上经常看到有人问关于使用SPSS岭回归方法处理多重共线性的问题,以前不断地有人问,我想将来肯定还会有人问这方面的问题。 主要原因:1、SPSS没有提供岭回归的菜单命令,而是需要语法命令来完成,这增加了操作的...
  • Lasso: lasso的解为何比较稀疏? 假设ridge和lasso都有解,即wridge 和 wlasso 都存在。在wridge 中,(XT X+αI)-1 不为0,若某个wi为0,只能寄希望于XTy;而在wlasso 中,(XT X)-1 不为0,可以调整α使(XTy-αI...
  • 文章目录线性回归、岭回归和LASSO回归模型1 线性回归模型1.1 一元线性回归模型1.1.1 模型介绍1.1.2 参数求解1.1.3 python实现1.2 多元线性回归模型1.2.1 模型介绍1.2.2 模型参数求解1.3 回归模型的假设检验1.3.1 ...
  • 岭回归最早是用来处理多于样本的情况,现在也用于在估计中加入偏差,从而得到最好的估计。同样也可以解决多重共线性问题。岭回归是一种有偏估计。 岭回归的代价函数: 线性回归标准方程法: 岭回归的求...
  • 这里记录一下关于回归方面的知识包括(线性回归、局部加权回归、岭回归、逐步线性回归)等基础思想和代码实现。以及sklearn的实现方法。(数据来自机器学习实战第八章) 回归:  分类的目标变量是标称型数据,而...
  • 线性回归,岭回归

    2020-04-22 00:38:10
    性能评测案例欠拟合与过拟合解决过拟合的方法回归算法之岭回归sklearn.linear_model.Ridge方法属性案例分析 线性回归 回归算法 回归是统计学中最有力的工具之一。机器学习监督学习算法分为分类算法和回归算法两种,...
  • 上一节我们讲了线性回归的...详细对比了前两个的关系,然后我们又引出了正则化回归,其实就是岭回归,原因也简单的提了一下,本节将详细的对此进行分析,吃透原理,在遇到问题时才知道如何处理它,废话不多说,下面...
  • 线性回归、lasso回归、岭回归以及弹性网络的系统解释声明背景介绍概述线性回归模型函数及损失函数线性回归算法多项式回归(线性回归的推广)广义线性回归(线性回归的推广)岭回归(Ridge回归)lasso回归为什么lasso...
  • 岭回归 & 分箱处理线性问题 点击标题即可获取文章源代码和笔记 1. 导入需要的模块和库 from sklearn.linear_model import LinearRegression as LR from sklearn.model_selection import train_test_split ...
  • 上篇文章,我们介绍了几种处理共线性的方法。比如逐步回归法、手动剔除变量法是最常使用的方法,但是往往使用这类方法会剔除掉我们想要研究的自变量,导致自己希望研究的变量无法得到研究。因而,此时就需要使用更为...
  • 线性回归之岭回归

    2019-02-28 21:31:40
    class sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True, normalize=False, copy_X=True, max_iter=None, tol=0.001, solver=’auto’, random_state=None) 岭回归是一种正则化方法,通过在损...
  • 岭回归 原理 缩减系数来“理解”数据 优点 总结 小结 应用场景 代码实现 导包 样本小于特征,无数个解 打乱索引 矩阵乘法 比较三种算法 计算斜率 岭回归alpha最优化 导包 设X矩阵 设y 岭回归拟合 ...
  • 2.1 岭回归解决多重共线性问题 2.2 linear_model.Ridge 在sklearn中,岭回归线性模型库中的Ridge类来调用: class sklearn . linear_model . Ridge ( alpha = 1.0 , #正则化系数 ...
  • 以概率的方式解释了线性回归为什么采用平方损失,然后介绍了线性回归中常用的两种范数来解决过拟合和矩阵不可逆的情况,分别对应岭回归和Lasso回归,最后考虑到线性回归的局限性,介绍了一种局部加权线性回归,增加...
  • 这一篇文章,我们将首次介绍回归算法即对连续性的数据做出预测。回归一词的来历由来已久。“回归”是由英国著名生物学家兼统计学家高尔顿(Francis Galton,1822~1911.生物学家达尔文的表弟)在研究人类遗传问题时提...
  • 岭回归是一种用于共线性数据分析的有偏估计回归方法,是一种改良的最小二乘估计法,通过放弃最小二乘法的无偏性,以损失部分信息、降低精度为代价从而获得更符合实际、更可靠的回归系数,对病态数据(这样的数据中...
  • scikit-learn机器学习笔记——线性回归,岭回归线性回归损失函数最小二乘法直接求解最小二乘法梯度下降sklearn线性回归方程求解、梯度下降API回归性能评估:sklearn回归评估API线性回归实例过拟合与欠拟合降低过拟合...
  • 1.最小二乘法求解多元线性回归 多元线性回归表达式: 可以写成: 我们的目标就是求解w,如何求解w,就要用到损失函数,线性回归的损失函数为: 即预测值和真实值之间的差异,我们希望越小越好。 我们往往称上述...
  • 线性回归与逻辑回归LR线性回归应用场合求解最小二乘法梯度下降法加入正则化岭回归Ridge regressionlasso回归lasso regression逻辑回归LR交叉熵损失(极大似然损失)梯度下降法优缺点区别与联系以及其他常见问题 线性...
  • 1、线性回归,岭回归,Lasso回归,局部加权线性回归 2、logistic回归,softmax回归,最大熵模型 3、广义线性模型 4、Fisher线性判别和线性感知机 5、三层神经网络 6、支持向量机...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,138
精华内容 2,455
关键字:

岭回归的共线性的处理