精华内容
下载资源
问答
  • 点上方蓝字人工智能算法与Python大数据获取更多干货在右上方···设为星标★,第一时间获取资源仅做学术分享,如有侵权,联系删除转载于 :作者:Sunil Ray 出处:csdn 译...

    点上方蓝字人工智能算法与Python大数据获取更多干货

    在右上方 ··· 设为星标 ★,第一时间获取资源

    仅做学术分享,如有侵权,联系删除

    转载于 :作者:Sunil Ray 出处:csdn 译者/刘帝伟 审校/刘翔宇、朱正贵 责编/周建丁

    什么是回归分析?

    回归分析是一种预测性的建模技术,它研究的是因变量(目标)和自变量(预测器)之间的关系。这种技术通常用于预测分析,时间序列模型以及发现变量之间的因果关系。例如,司机的鲁莽驾驶与道路交通事故数量之间的关系,最好的研究方法就是回归。

    回归分析是建模和分析数据的重要工具。在这里,我们使用曲线/线来拟合这些数据点,在这种方式下,从曲线或线到数据点的距离差异最小。我会在接下来的部分详细解释这一点。

    我们为什么使用回归分析?

    如上所述,回归分析估计了两个或多个变量之间的关系。下面,让我们举一个简单的例子来理解它:

    比如说,在当前的经济条件下,你要估计一家公司的销售额增长情况。现在,你有公司最新的数据,这些数据显示出销售额增长大约是经济增长的2.5倍。那么使用回归分析,我们就可以根据当前和过去的信息来预测未来公司的销售情况。

    使用回归分析的好处良多。具体如下:

    1. 它表明自变量和因变量之间的显著关系;

    2. 它表明多个自变量对一个因变量的影响强度。

    回归分析也允许我们去比较那些衡量不同尺度的变量之间的相互影响,如价格变动与促销活动数量之间联系。这些有利于帮助市场研究人员,数据分析人员以及数据科学家排除并估计出一组最佳的变量,用来构建预测模型。

    我们有多少种回归技术?

    有各种各样的回归技术用于预测。这些技术主要有三个度量(自变量的个数,因变量的类型以及回归线的形状)。我们将在下面的部分详细讨论它们。

    对于那些有创意的人,如果你觉得有必要使用上面这些参数的一个组合,你甚至可以创造出一个没有被使用过的回归模型。但在你开始之前,先了解如下最常用的回归方法:

    1.Linear Regression线性回归

    它是最为人熟知的建模技术之一。线性回归通常是人们在学习预测模型时首选的技术之一。在这种技术中,因变量是连续的,自变量可以是连续的也可以是离散的,回归线的性质是线性的。

    线性回归使用最佳的拟合直线(也就是回归线)在因变量(Y)和一个或多个自变量(X)之间建立一种关系。

    用一个方程式来表示它,即Y=a+b*X+e,其中a表示截距,b表示直线的斜率,e是误差项。这个方程可以根据给定的预测变量(s)来预测目标变量的值。

    一元线性回归和多元线性回归的区别在于,多元线性回归有(>1)个自变量,而一元线性回归通常只有1个自变量。现在的问题是“我们如何得到一个最佳的拟合线呢?”。

    如何获得最佳拟合线(a和b的值)?

    这个问题可以使用最小二乘法轻松地完成。最小二乘法也是用于拟合回归线最常用的方法。对于观测数据,它通过最小化每个数据点到线的垂直偏差平方和来计算最佳拟合线。因为在相加时,偏差先平方,所以正值和负值没有抵消。

    我们可以使用R-square指标来评估模型性能。想了解这些指标的详细信息,可以阅读:模型性能指标Part 1,Part 2.

    要点:

    1.自变量与因变量之间必须有线性关系

    2.多元回归存在多重共线性,自相关性和异方差性。

    3.线性回归对异常值非常敏感。它会严重影响回归线,最终影响预测值。

    4.多重共线性会增加系数估计值的方差,使得在模型轻微变化下,估计非常敏感。结果就是系数估计值不稳定

    5.在多个自变量的情况下,我们可以使用向前选择法,向后剔除法和逐步筛选法来选择最重要的自变量。

    2.Logistic Regression逻辑回归

    逻辑回归是用来计算“事件=Success”和“事件=Failure”的概率。当因变量的类型属于二元(1 / 0,真/假,是/否)变量时,我们就应该使用逻辑回归。这里,Y的值从0到1,它可以用下方程表示。

    odds= p/ (1-p) = probability of event occurrence / probability of not event occurrenceln(odds) = ln(p/(1-p))logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk

    上述式子中,p表述具有某个特征的概率。你应该会问这样一个问题:“我们为什么要在公式中使用对数log呢?”。

    因为在这里我们使用的是的二项分布(因变量),我们需要选择一个对于这个分布最佳的连结函数。它就是Logit函数。在上述方程中,通过观测样本的极大似然估计值来选择参数,而不是最小化平方和误差(如在普通回归使用的)。

    要点:

    1.它广泛的用于分类问题。

    2.逻辑回归不要求自变量和因变量是线性关系。它可以处理各种类型的关系,因为它对预测的相对风险指数OR使用了一个非线性的log转换。

    3.为了避免过拟合和欠拟合,我们应该包括所有重要的变量。有一个很好的方法来确保这种情况,就是使用逐步筛选方法来估计逻辑回归。

    4.它需要大的样本量,因为在样本数量较少的情况下,极大似然估计的效果比普通的最小二乘法差。

    5.自变量不应该相互关联的,即不具有多重共线性。然而,在分析和建模中,我们可以选择包含分类变量相互作用的影响。

    6.如果因变量的值是定序变量,则称它为序逻辑回归。

    7.如果因变量是多类的话,则称它为多元逻辑回归。

    3.Polynomial Regression多项式回归

    对于一个回归方程,如果自变量的指数大于1,那么它就是多项式回归方程。如下方程所示:y=a+b*x^2

    在这种回归技术中,最佳拟合线不是直线。而是一个用于拟合数据点的曲线。

    重点:

    虽然会有一个诱导可以拟合一个高次多项式并得到较低的错误,但这可能会导致过拟合。你需要经常画出关系图来查看拟合情况,并且专注于保证拟合合理,既没有过拟合又没有欠拟合。

    下面是一个图例,可以帮助理解:

    明显地向两端寻找曲线点,看看这些形状和趋势是否有意义。更高次的多项式最后可能产生怪异的推断结果。

    4.Stepwise Regression逐步回归

    在处理多个自变量时,我们可以使用这种形式的回归。在这种技术中,自变量的选择是在一个自动的过程中完成的,其中包括非人为操作。

    这一壮举是通过观察统计的值,如R-square,t-stats和AIC指标,来识别重要的变量。逐步回归通过同时添加/删除基于指定标准的协变量来拟合模型。

    下面列出了一些最常用的逐步回归方法:

    • 标准逐步回归法做两件事情。即增加和删除每个步骤所需的预测。

    • 向前选择法从模型中最显著的预测开始,然后为每一步添加变量。

    • 向后剔除法与模型的所有预测同时开始,然后在每一步消除最小显着性的变量。

    这种建模技术的目的是使用最少的预测变量数来最大化预测能力。这也是处理高维数据集的方法之一。

    5.Ridge Regression岭回归

    岭回归分析是一种用于存在多重共线性(自变量高度相关)数据的技术。在多重共线性情况下,尽管最小二乘法(OLS)对每个变量很公平,但它们的差异很大,使得观测值偏移并远离真实值。岭回归通过给回归估计上增加一个偏差度,来降低标准误差。

    上面,我们看到了线性回归方程。还记得吗?它可以表示为:

    y=a+b*x这个方程也有一个误差项。完整的方程是:

    y=a+b*x+e (error term),  [error term is the value needed to correct for a prediction error between the observed and predicted value]

    => y=a+y= a+ b1x1+ b2x2+....+e, for multiple independent variables.

    在一个线性方程中,预测误差可以分解为2个子分量。一个是偏差,一个是方差。预测错误可能会由这两个分量或者这两个中的任何一个造成。在这里,我们将讨论由方差所造成的有关误差。

    岭回归通过收缩参数λ(lambda)解决多重共线性问题。看下面的公式

    在这个公式中,有两个组成部分。第一个是最小二乘项,另一个是β2(β-平方)的λ倍,其中β是相关系数。为了收缩参数把它添加到最小二乘项中以得到一个非常低的方差。

    要点:

    1.除常数项以外,这种回归的假设与最小二乘回归类似;

    2.它收缩了相关系数的值,但没有达到零,这表明它没有特征选择功能

    3.这是一个正则化方法,并且使用的是L2正则化。

    6.Lasso Regression套索回归

    它类似于岭回归,Lasso (Least Absolute Shrinkage and Selection Operator)也会惩罚回归系数的绝对值大小。此外,它能够减少变化程度并提高线性回归模型的精度。看看下面的公式:

    Lasso 回归与Ridge回归有一点不同,它使用的惩罚函数是绝对值,而不是平方。这导致惩罚(或等于约束估计的绝对值之和)值使一些参数估计结果等于零。使用惩罚值越大,进一步估计会使得缩小值趋近于零。这将导致我们要从给定的n个变量中选择变量。

    要点:

    1.除常数项以外,这种回归的假设与最小二乘回归类似;

    2.它收缩系数接近零(等于零),这确实有助于特征选择;

    3.这是一个正则化方法,使用的是L1正则化;

    如果预测的一组变量是高度相关的,Lasso 会选出其中一个变量并且将其它的收缩为零。

    7.ElasticNet回归

    ElasticNet是Lasso和Ridge回归技术的混合体。它使用L1来训练并且L2优先作为正则化矩阵。当有多个相关的特征时,ElasticNet是很有用的。Lasso 会随机挑选他们其中的一个,而ElasticNet则会选择两个。

    Lasso和Ridge之间的实际的优点是,它允许ElasticNet继承循环状态下Ridge的一些稳定性。

    要点:

    1.在高度相关变量的情况下,它会产生群体效应;

    2.选择变量的数目没有限制;

    3.它可以承受双重收缩。

    除了这7个最常用的回归技术,你也可以看看其他模型,如Bayesian、Ecological和Robust回归。

    如何正确选择回归模型?

    当你只知道一个或两个技术时,生活往往很简单。我知道的一个培训机构告诉他们的学生,如果结果是连续的,就使用线性回归。如果是二元的,就使用逻辑回归!然而,在我们的处理中,可选择的越多,选择正确的一个就越难。类似的情况下也发生在回归模型中。

    在多类回归模型中,基于自变量和因变量的类型,数据的维数以及数据的其它基本特征的情况下,选择最合适的技术非常重要。以下是你要选择正确的回归模型的关键因素:

    1.数据探索是构建预测模型的必然组成部分。在选择合适的模型时,比如识别变量的关系和影响时,它应该首选的一步。

    2. 比较适合于不同模型的优点,我们可以分析不同的指标参数,如统计意义的参数,R-square,Adjusted R-square,AIC,BIC以及误差项,另一个是Mallows’ Cp准则。这个主要是通过将模型与所有可能的子模型进行对比(或谨慎选择他们),检查在你的模型中可能出现的偏差。

    3.交叉验证是评估预测模型最好额方法。在这里,将你的数据集分成两份(一份做训练和一份做验证)。使用观测值和预测值之间的一个简单均方差来衡量你的预测精度。

    4.如果你的数据集是多个混合变量,那么你就不应该选择自动模型选择方法,因为你应该不想在同一时间把所有变量放在同一个模型中。

    5.它也将取决于你的目的。可能会出现这样的情况,一个不太强大的模型与具有高度统计学意义的模型相比,更易于实现。

    6.回归正则化方法(Lasso,Ridge和ElasticNet)在高维和数据集变量之间多重共线性情况下运行良好。

    ---------♥---------

    声明:本内容来源网络,版权属于原作者

    图片来源网络,不代表本公众号立场。如有侵权,联系删除

    AI博士私人微信,还有少量空位

    如何画出漂亮的深度学习模型图?

    如何画出漂亮的神经网络图?

    一文读懂深度学习中的各种卷积

    点个在看支持一下吧

    展开全文
  • 【李宏毅深度学习CP3-4】(task2)回归

    千次阅读 2021-08-18 17:59:16
    结果就是系数估计值不稳定 在多个自变量的情况下,我们可以使用向前选择法,向后剔除法和逐步筛选法来选择最重要的自变量。 2.Logistic Regression逻辑回归 逻辑回归是用来计算“事件=Success”和“事件=Failure”的...

    目录

    回归分析的定义

    回归应用举例

    七种常见的回归

    三种常用的损失函数

    python中的sklearn. metrics 

    在python上实现交叉验证

    梯度下降法筛选最优模型


    回归分析的定义

    回归分析是一种预测性的建模技术,它研究的是因变量(目标)和自变量(预测器)之间的关系。这种技术通常用于预测分析,时间序列模型以及发现变量之间的因果关系。例如,司机的鲁莽驾驶与道路交通 事 故数量之间的关系,最好的研究方法就是回归。

    回归分析是建模和分析数据的重要工具。在这里,我们使用曲线/线来拟合这些数据点,在这种方式下,从曲线或线到数据点的距离差异最小。我会在接下来的部分详细解释这一点。

    简单来说,Regression 就是找到一个函数 functionfunction ,通过输入特征 xx,输出一个数值 ScalarScalar。

    回归应用举例

    • 股市预测(Stock market forecast)
      • 输入:过去10年股票的变动、新闻咨询、公司并购咨询等
      • 输出:预测股市明天的平均值
    • 自动驾驶(Self-driving Car)
      • 输入:无人车上的各个sensor的数据,例如路况、测出的车距等
      • 输出:方向盘的角度
    • 商品推荐(Recommendation)
      • 输入:商品A的特性,商品B的特性
      • 输出:购买商品B的可能性
    • Pokemon精灵攻击力预测(Combat Power of a pokemon):
      • 输入:进化前的CP值、物种(Bulbasaur)、血量(HP)、重量(Weight)、高度(Height)
      • 输出:进化后的CP值

    七种常见的回归

    1. Linear Regression线性回归

    它是最为人熟知的建模技术之一。线性回归通常是人们在学习预测模型时首选的技术之一。在这种技术中,因变量是连续的,自变量可以是连续的也可以是离散的,回归线的性质是线性的。

    线性回归使用最佳的拟合直线(也就是回归线)在因变量(Y)和一个或多个自变量(X)之间建立一种关系。

    用一个方程式来表示它,即Y=a+b*X + e,其中a表示截距,b表示直线的斜率,e是误差项。这个方程可以根据给定的预测变量(s)来预测目标变量的值。

    一元线性回归和多元线性回归的区别在于,多元线性回归有(>1)个自变量,而一元线性回归通常只有1个自变量。现在的问题是“我们如何得到一个最佳的拟合线呢?”。

    如何获得最佳拟合线(a和b的值)?

    这个问题可以使用最小二乘法轻松地完成。最小二乘法也是用于拟合回归线最常用的方法。对于观测数据,它通过最小化每个数据点到线的垂直偏差平方和来计算最佳拟合线。因为在相加时,偏差先平方,所以正值和负值没有抵消。

    我们可以使用R-square指标来评估模型性能。想了解这些指标的详细信息,可以阅读:模型性能指标Part 1,Part 2 .

    要点:

    • 自变量与因变量之间必须有线性关系

    • 多元回归存在多重共线性,自相关性和异方差性。

    • 线性回归对异常值非常敏感。它会严重影响回归线,最终影响预测值。

    • 多重共线性会增加系数估计值的方差,使得在模型轻微变化下,估计非常敏感。结果就是系数估计值不稳定

    • 在多个自变量的情况下,我们可以使用向前选择法,向后剔除法和逐步筛选法来选择最重要的自变量。

     

    2.Logistic Regression逻辑回归

    逻辑回归是用来计算“事件=Success”和“事件=Failure”的概率。当因变量的类型属于二元(1 / 0,真/假,是/否)变量时,我们就应该使用逻辑回归。这里,Y的值从0到1,它可以用下方程表示。

    Java

    1

    2

    3

    odds= p/ (1-p) = probability of event occurrence / probability of not event occurrence

    ln(odds) = ln(p/(1-p))

    logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk

    上述式子中,p表述具有某个特征的概率。你应该会问这样一个问题:“我们为什么要在公式中使用对数log呢?”。

    因为在这里我们使用的是的二项分布(因变量),我们需要选择一个对于这个分布最佳的连结函数。它就是Logit函数。在上述方程中,通过观测样本的极大似然估计值来选择参数,而不是最小化平方和误差(如在普通回归使用的)。

    要点:

    • 它广泛的用于分类问题。

    • 逻辑回归不要求自变量和因变量是线性关系。它可以处理各种类型的关系,因为它对预测的相对风险指数OR使用了一个非线性的log转换。

    • 为了避免过拟合和欠拟合,我们应该包括所有重要的变量。有一个很好的方法来确保这种情况,就是使用逐步筛选方法来估计逻辑回归。

    • 它需要大的样本量,因为在样本数量较少的情况下,极大似然估计的效果比普通的最小二乘法差。

    • 自变量不应该相互关联的,即不具有多重共线性。然而,在分析和建模中,我们可以选择包含分类变量相互作用的影响。

    • 如果因变量的值是定序变量,则称它为序逻辑回归。

    • 如果因变量是多类的话,则称它为多元逻辑回归。

    3. Polynomial Regression多项式回归

    对于一个回归方程,如果自变量的指数大于1,那么它就是多项式回归方程。如下方程所示:

    y = a + b*x^{\2}

    在这种回归技术中,最佳拟合线不是直线。而是一个用于拟合数据点的曲线。

    重点:

    虽然会有一个诱导可以拟合一个高次多项式并得到较低的错误,但这可能会导致过拟合。你需要经常画出关系图来查看拟合情况,并且专注于保证拟合合理,既没有过拟合又没有欠拟合。下面是一个图例,可以帮助理解:

    明显地向两端寻找曲线点,看看这些形状和趋势是否有意义。更高次的多项式最后可能产生怪异的推断结果。

     

    4. Stepwise Regression逐步回归

    在处理多个自变量时,我们可以使用这种形式的回归。在这种技术中,自变量的选择是在一个自动的过程中完成的,其中包括非人为操作。

    这一壮举是通过观察统计的值,如R-square,t-stats和AIC指标,来识别重要的变量。逐步回归通过同时添加/删除基于指定标准的协变量来拟合模型。下面列出了一些最常用的逐步回归方法:

    • 标准逐步回归法做两件事情。即增加和删除每个步骤所需的预测。

    • 向前选择法从模型中最显著的预测开始,然后为每一步添加变量。

    • 向后剔除法与模型的所有预测同时开始,然后在每一步消除最小显着性的变量。

    这种建模技术的目的是使用最少的预测变量数来最大化预测能力。这也是处理高维数据集的方法之一。

    5. Ridge Regression岭回归

    岭回归分析是一种用于存在多重共线性(自变量高度相关)数据的技术。在多重共线性情况下,尽管最小二乘法(OLS)对每个变量很公平,但它们的差异很大,使得观测值偏移并远离真实值。岭回归通过给回归估计上增加一个偏差度,来降低标准误差。

    上面,我们看到了线性回归方程。还记得吗?它可以表示为:

    y = a + b*x

    这个方程也有一个误差项。完整的方程是:

    Java

    1

    y=a+b*x+e (error term), [error term is the value needed to correct for a prediction error between the observed and predicted value]

    Java

    1

    => y=a+y= a+ b1x1+ b2x2+....+e, for multiple independent variables.

    在一个线性方程中,预测误差可以分解为2个子分量。一个是偏差,一个是方差。预测错误可能会由这两个分量或者这两个中的任何一个造成。在这里,我们将讨论由方差所造成的有关误差。

    岭回归通过收缩参数λ(lambda)解决多重共线性问题。看下面的公式

    在这个公式中,有两个组成部分。第一个是最小二乘项,另一个是β2(β-平方)的λ倍,其中β是相关系数。为了收缩参数把它添加到最小二乘项中以得到一个非常低的方差。

    要点:

    • 除常数项以外,这种回归的假设与最小二乘回归类似;

    • 它收缩了相关系数的值,但没有达到零,这表明它没有特征选择功能

    • 这是一个正则化方法,并且使用的是L2正则化。

     

    6. Lasso Regression套索回归

    它类似于岭回归,Lasso (Least Absolute Shrinkage and Selection Operator)也会惩罚回归系数的绝对值大小。此外,它能够减少变化程度并提高线性回归模型的精度。看看下面的公式:

    Lasso 回归与Ridge回归有一点不同,它使用的惩罚函数是绝对值,而不是平方。这导致惩罚(或等于约束估计的绝对值之和)值使一些参数估计结果等于零。使用惩罚值越大,进一步估计会使得缩小值趋近于零。这将导致我们要从给定的n个变量中选择变量。

    要点:

    • 除常数项以外,这种回归的假设与最小二乘回归类似;

    • 它收缩系数接近零(等于零),这确实有助于特征选择;

    • 这是一个正则化方法,使用的是L1正则化;

    如果预测的一组变量是高度相关的,Lasso 会选出其中一个变量并且将其它的收缩为零。

    7.ElasticNet回归

    ElasticNet是Lasso和Ridge回归技术的混合体。它使用L1来训练并且L2优先作为正则化矩阵。当有多个相关的特征时,ElasticNet是很有用的。Lasso 会随机挑选他们其中的一个,而ElasticNet则会选择两个。

    Lasso和Ridge之间的实际的优点是,它允许ElasticNet继承循环状态下Ridge的一些稳定性。

    要点:

    • 在高度相关变量的情况下,它会产生群体效应;

    • 选择变量的数目没有限制;

    • 它可以承受双重收缩。

    除了这7个最常用的回归技术,你也可以看看其他模型,如Bayesian、Ecological和Robust回归。

    三种常用的损失函数

    1、SSE(误差平方和) The sum of squares due to error
    计算公式如下:

         

    同样的数据集的情况下,SSE越小,误差越小,模型效果越好
    缺点:
    SSE数值大小本身没有意义,随着样本增加,SSE必然增加,也就是说,不同的数据集的情况下,SSE比较没有意义

    2、R-square(决定系数) Coefficient of determination

    数学理解: 分母理解为原始数据的离散程度,分子为预测数据和原始数据的误差,二者相除可以消除原始数据离散程度的影响
    其实“决定系数”是通过数据的变化来表征一个拟合的好坏。
    理论上取值范围(-∞,1], 正常取值范围为[0 1] ------实际操作中通常会选择拟合较好的曲线计算R²,因此很少出现-∞
    一个常数模型总是预测 y 的期望值,它忽略输入的特征,因此输出的R^2会为0
    越接近1,表明方程的变量对y的解释能力越强,这个模型对数据拟合的也较好

    越接近0,表明模型拟合的越差

    经验值:>0.4, 拟合效果好

    缺点:
    数据集的样本越大,R²越大,因此,不同数据集的模型结果比较会有一定的误差

    3、Adjusted R-Square (校正决定系数)Degree-of-freedom adjusted coefficient of determination

       

    n为样本数量,p为特征数量

    消除了样本数量和特征数量的影响


    python中的sklearn. metrics 

    python的sklearn.metrics中包含一些损失函数,评分指标来评估回归模型的效果。主要包含以下几个指标:n_squared_error, mean_absolute_error, explained_variance_score and r2_score.。

    (1) explained_variance_score(解释方差分)
       y_hat :预测值, y :真实值, var :方差

    explained_variance_score:解释方差分,这个指标用来衡量我们模型对数据集波动的解释程度,如果取值为1时,模型就完美,越小效果就越差。下面是python的使用情况:

    # 解释方差分数
    >>> from sklearn.metrics import explained_variance_score
    >>> y_true = [3, -0.5, 2, 7]
    >>> y_pred = [2.5, 0.0, 2, 8]
    >>> explained_variance_score(y_true, y_pred)  
    0.957...
    >>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
    >>> y_pred = [[0, 2], [-1, 2], [8, -5]]
    >>> explained_variance_score(y_true, y_pred, multioutput='raw_values')
    ... 
    array([ 0.967...,  1.        ])
    >>> explained_variance_score(y_true, y_pred, multioutput=[0.3, 0.7])
    ... 
    0.990...


    (2) Mean absolute error(平均绝对误差)
       y_hat :预测值, y :真实值

    给定数据点的平均绝对误差,一般来说取值越小,模型的拟合效果就越好。下面是在python上的实现:

    >>> from sklearn.metrics import mean_absolute_error
    >>> y_true = [3, -0.5, 2, 7]
    >>> y_pred = [2.5, 0.0, 2, 8]
    >>> mean_absolute_error(y_true, y_pred)
    0.5
    >>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
    >>> y_pred = [[0, 2], [-1, 2], [8, -5]]
    >>> mean_absolute_error(y_true, y_pred)
    0.75
    >>> mean_absolute_error(y_true, y_pred, multioutput='raw_values')
    array([ 0.5,  1. ])
    >>> mean_absolute_error(y_true, y_pred, multioutput=[0.3, 0.7])
    ... 
    0.849...


    (3)Mean squared error(均方误差)
       y_hat :预测值, y :真实值

    这是人们常用的指标之一。

    >>> from sklearn.metrics import mean_squared_error
    >>> y_true = [3, -0.5, 2, 7]
    >>> y_pred = [2.5, 0.0, 2, 8]
    >>> mean_squared_error(y_true, y_pred)
    0.375
    >>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
    >>> y_pred = [[0, 2], [-1, 2], [8, -5]]
    >>> mean_squared_error(y_true, y_pred)  
    0.7083...


    (4) Mean squared logarithmic error
       y_hat :预测值, y :真实值

         当目标实现指数增长时,例如人口数量、一种商品在几年时间内的平均销量等,这个指标最适合使用。请注意,这个指标惩罚的是一个被低估的估计大于被高估的估计。

    >>> from sklearn.metrics import mean_squared_log_error
    >>> y_true = [3, 5, 2.5, 7]
    >>> y_pred = [2.5, 5, 4, 8]
    >>> mean_squared_log_error(y_true, y_pred)  
    0.039...
    >>> y_true = [[0.5, 1], [1, 2], [7, 6]]
    >>> y_pred = [[0.5, 2], [1, 2.5], [8, 8]]
    >>> mean_squared_log_error(y_true, y_pred)  
    0.044...


    (5)Median absolute error(中位数绝对误差)
    y_hat :预测值, y :真实值

    中位数绝对误差适用于包含异常值的数据的衡量

    >>> from sklearn.metrics import median_absolute_error
    >>> y_true = [3, -0.5, 2, 7]
    >>> y_pred = [2.5, 0.0, 2, 8]
    >>> median_absolute_error(y_true, y_pred)
    0.5


    (6) R² score(决定系数、R方)


    R方可以理解为因变量y中的变异性能能够被估计的多元回归方程解释的比例,它衡量各个自变量对因变量变动的解释程度,其取值在0与1之间,其值越接近1,则变量的解释程度就越高,其值越接近0,其解释程度就越弱。

    一般来说,增加自变量的个数,回归平方和会增加,残差平方和会减少,所以R方会增大;反之,减少自变量的个数,回归平方和减少,残差平方和增加。

    为了消除自变量的数目的影响,引入了调整的R方

     

    >>> from sklearn.metrics import r2_score
    >>> y_true = [3, -0.5, 2, 7]
    >>> y_pred = [2.5, 0.0, 2, 8]
    >>> r2_score(y_true, y_pred)  
    0.948...
    >>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
    >>> y_pred = [[0, 2], [-1, 2], [8, -5]]
    >>> r2_score(y_true, y_pred, multioutput='variance_weighted')
    ... 
    0.938...
    >>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
    >>> y_pred = [[0, 2], [-1, 2], [8, -5]]
    >>> r2_score(y_true, y_pred, multioutput='uniform_average')
    ... 
    0.936...
    >>> r2_score(y_true, y_pred, multioutput='raw_values')
    ... 
    array([ 0.965...,  0.908...])
    >>> r2_score(y_true, y_pred, multioutput=[0.3, 0.7])
    ... 
    0.925...

    在python上实现交叉验证

    ############################交叉验证,评价模型的效果############################
    from sklearn import datasets, linear_model
    from sklearn.model_selection import cross_val_score
    diabetes = datasets.load_diabetes()
    X = diabetes.data[:150]
    y = diabetes.target[:150]
    lasso = linear_model.Lasso()
    print(cross_val_score(lasso, X, y, cv=5))  # 默认是3-fold cross validation
    ############################交叉验证,评价模型的效果############################
    from sklearn import datasets, linear_model
    from sklearn.model_selection import cross_val_score
    diabetes = datasets.load_diabetes()
    X = diabetes.data[:150]
    y = diabetes.target[:150]
    lasso = linear_model.Lasso()
    print(cross_val_score(lasso, X, y, cv=5))  # 默认是3-fold cross validation
    ################定义一个返回cross-validation rmse error函数来评估模型以便可以选择正确的参数########
    from sklearn.linear_model import Ridge, RidgeCV, ElasticNet, LassoCV, LassoLarsCV
    from sklearn.model_selection import cross_val_score
     
    def rmse_cv(model):
        ##使用K折交叉验证模块,将5次的预测准确率打印出
        rmse= np.sqrt(-cross_val_score(model, X_train, y_train, scoring="neg_mean_squared_error", cv = 5))  #输入训练集的数据和目标值
        return(rmse)
        
    model_ridge = Ridge()
     
    alphas = [0.05, 0.1, 0.3, 1, 3, 5, 10, 15, 30, 50, 75]
    cv_ridge = [rmse_cv(Ridge(alpha = alpha)).mean()    #对不同的参数alpha,使用岭回归来计算其准确率
                for alpha in alphas]
     
    cv_ridge
     
    #绘制岭回归的准确率和参数alpha的变化图
    cv_ridge = pd.Series(cv_ridge, index = alphas)
    cv_ridge.plot(title = "Validation - Just Do It")
    plt.xlabel("alpha")
    plt.ylabel("rmse")

    梯度下降法筛选最优模型

    【单个特征】: x_{cp}xcp​

    如何筛选最优的模型(参数w,b)

    已知损失函数是 L(w,b)= \sum_{n=1}^{10}\left ( \hat{y}^n - (b + w·x_{cp}) \right )^2L(w,b)=∑n=110​(y^​n−(b+w⋅xcp​))2 ,需要找到一个令结果最小的 f^*f∗,在实际的场景中,我们遇到的参数肯定不止 ww, bb。

    先从最简单的只有一个参数ww入手,定义w^* = arg\ \underset{x}{\operatorname{\min}} L(w)w∗=arg xmin​L(w)

    首先在这里引入一个概念 学习率 :移动的步长,如图7中 \etaη

    • 步骤1:随机选取一个 w^0w0
    • 步骤2:计算微分,也就是当前的斜率,根据斜率来判定移动的方向
      • 大于0向右移动(增加ww)
      • 小于0向左移动(减少ww)
    • 步骤3:根据学习率移动
    • 重复步骤2和步骤3,直到找到最低点

    步骤1中,我们随机选取一个 w^0w0,如图8所示,我们有可能会找到当前的最小值,并不是全局的最小值,这里我们保留这个疑问,后面解决。

    解释完单个模型参数ww,引入2个模型参数 ww 和 bb , 其实过程是类似的,需要做的是偏微分,过程如图9所示,偏微分的求解结果文章后面会有解释,详细的求解过程自行Google。

    整理成一个更简洁的公式:

    梯度下降推演最优模型的过程

    如果把 ww 和 bb 在图形中展示:

    • 每一条线围成的圈就是等高线,代表损失函数的值,颜色约深的区域代表的损失函数越小
    • 红色的箭头代表等高线的法线方向

    梯度下降算法在现实世界中面临的挑战

    我们通过梯度下降gradient descent不断更新损失函数的结果,这个结果会越来越小,那这种方法找到的结果是否都是正确的呢?前面提到的当前最优问题外,还有没有其他存在的问题呢?

    其实还会有其他的问题:

    • 问题1:当前最优(Stuck at local minima)
    • 问题2:等于0(Stuck at saddle point)
    • 问题3:趋近于0(Very slow at the plateau)

    注意:其实在线性模型里面都是一个碗的形状(山谷形状),梯度下降基本上都能找到最优点,但是再其他更复杂的模型里面,就会遇到 问题2 和 问题3 了

    w和b偏微分的计算方法

     ####(注:对b求偏导最后少了一个-1,特此更正)

    未完待续,先交作业

    Reference

    李宏毅b站地址

    李宏毅官网TASK

    datawhale李宏毅机器学习论坛

    李宏毅机器学习笔记(LeeML-Notes)

    https://blog.csdn.net/weixin_39541558/article/details/80705006

    https://www.cnblogs.com/sumuncle/p/5647722.html

    展开全文
  • 逐步选择法(Stepwise Selection) 2.1 向前逐步选择(Forward Stepwise Selection) 2.2 向后逐步选择(Backward Stepwise Selection) 一、 前言 模型选择方法有三种,分别是:子集选择法(subset selection), ...

    一、 前言

    模型选择方法有三种,分别是:子集选择法(subset selection), 收缩法(Shrinkage)和降维法(Dimension Reduction)。

    这篇文章主要介绍模型选择的子集选择法。​​​​​​​
      \  

    二、为什么要进行模型选择?

    对于线性模型:
    Y = β 0 + β 1 X 1 + . . . + β p X p + ϵ Y = \beta_{0} + \beta_{1}X_{1}+...+ \beta_{p}X_{p} +\epsilon Y=β0+β1X1+...+βpXp+ϵ
    模型选择就是要:决定P的大小;确定哪些特征是重要的。

    而进行模型选择,主要出于预测准确性(Prediction Accuracy)和模型解释度(Model Interpretability)两方面考虑。

    1. 模型准确性:当p > n时,最小二乘法失效,此时需要模型选择来控制方差,使模型成功拟合。
    2. 模型解释性:因为多元回归模型中的一些自变量可能与因变量无关,但最小二乘法得到的无关变量的系数可能不为0,此时需要通过模型选择移除某些无关特征。

      \  

    三、模型选择标准

    对于训练集来说,包含了所有变量的模型总是有着最小的RSS和最大的 R 2 R^2 R2,所以RSS和 R 2 R^2 R2不适合用来作为模型选择的标准。

    通常情况下,我们希望选择拥有最小测试误差(Test error)的模型。那么我们该如何知道测试误差呢?

    1. 通过训练误差调整得到测试误差: Adjusted R 2 R^2 R2, Mallow’s Cp, AIC, BIC
    2. 直接预测测试误差: 校验集方法(Validation Set Approach), 交叉验证(Cross-validation)

    1. 调整得到Test error

    1.1 调整后的 R 2 R^2 R2 (Adjusted R 2 R^2 R2)

    A d j u s t e d   R 2 = 1 − R S S / ( n − p − 1 ) T S S / ( n − 1 ) Adjusted \ R^{2} = 1 - \frac{RSS/(n - p -1)}{TSS/(n -1)} Adjusted R2=1TSS/(n1)RSS/(np1)
    调整后的 R 2 R^2 R2越大,意味着模型的测试误差越小。

    1.2 Mallow’s C p C_p Cp

    C p = 1 n ( R S S + 2 p σ ^ 2 ) C_{p}=\frac{1}{n}(RSS+2p\widehat{\sigma}^{2}) Cp=n1(RSS+2pσ 2)
    其中, σ ^ \widehat\sigma σ 是对误差项 ϵ \epsilon ϵ 方差的估计, p 为自变量数量。

    C p C_p Cp越小,模型越优。

    1.3 Akaike Information Criterion (AIC)

    A I C = − 2 l o g L + 2 p AIC=-2logL+2p AIC=2logL+2p
    其中,L为似然函数。

    AIC越小,模型越优。

    1.4 Bayesian information Criterion (BIC)

    B I C = 1 n ( R S S + l o g ( n ) p σ ^ 2 ) BIC=\frac{1}{n}(RSS+log(n)p\widehat{\sigma}^{2}) BIC=n1(RSS+log(n)pσ 2)
    其中,n为样本数量。

    对比Mallow’s Cp 和 BIC, 可以发现BIC将Cp公式中的 2 p σ ^ 2p\widehat\sigma 2pσ 替换为 l o g ( n ) p σ ^ log(n)p\widehat\sigma log(n)pσ
    对于任意n>7, 均有log(n) > 2,所以BIC对于更多变量的惩罚更重。因此,相比于Cp,BIC倾向选择变量数更小的模型。

    2. 直接预测Test error

    优点:

    • 直接预测Test error
    • 不需要对误差项 ϵ \epsilon ϵ 方差 σ 2 \sigma^2 σ2 进行估计
    • 可用于无法精确知道模型自由度的情况

    2.1 校验集方法(Validation Set Approach)

    1. 将可用样本集随机分为两部分:训练集 (training set) 和验证或保持集(validation set or hold-out set);
    2. 用训练集拟合模型,将拟合的模型用于预测验证集;
    3. 将验证集的MSE用作 Test error 的估计。

    缺点:

    • 只有一部分观测值用于拟合模型。
    • 根据原始数据的分割情况,Test error的估计值可能变化很大。
    • 验证集的Test error可能会高估整个数据集模型拟合的Test error。

    2.2 交叉验证(Cross-validation CV)

    K折交叉验证(K-fold Cross Validation)
    1. 将所有数据集分成k份;
    2. 不重复地每次取其中一份做测试集,用其他 k-1 份做训练集训练模型,之后计算该模型在测试集上的MSEi
    3. 将k次的 MSEi 取平均得到最后的 MSE
    LOOCV(Leave-one-out cross-validation)
    1. 将所有数据集分成n份;
    2. 不重复地每次取其中一份做测试集,用其他 n-1 份做训练集训练模型,之后计算该模型在测试集上的MSEi
    3. 将n次的 MSEi 取平均得到最后的 MSE

    比起test set approach,LOOCV有很多优点。首先它不受测试集合训练集划分方法的影响,因为每一个数据都单独的做过测试集。同时,其用了n-1个数据训练模型,也几乎用到了所有的数据,保证了模型的bias更小。
    不过LOOCV的缺点也很明显,那就是计算量过于大,是test set approach耗时的n-1倍

    为了解决计算成本太大的弊端,又有人提供了下面的式子,使得LOOCV计算成本和只训练一个模型一样快。
    C V ( n ) = 1 n ∑ i = 1 n ( y i − y i ^ 1 − h i ) 2 CV_{(n)}=\frac{1}{n}\sum^{n}_{i=1}(\frac{y_{i}-\widehat{y_{i}}}{1-h_i})^{2} CV(n)=n1i=1n(1hiyiyi )2
    其中 y i ^ \widehat{y_{i}} yi 表示第i个拟合值,而 h i h_i hi 则表示leverage。
      \  

    四、子集选择方法

    1. 最优子集法(Best Subset Selection)

    1. 记 M0 为空模型(null model),此模型只存在截距项。
    2. 对于k = 1,2,3,…,p:
      选取所有 C p k C^k_p Cpk 个包含k个自变量的模型进行拟合;
      C p k C^k_p Cpk 个模型中选择最优模型,记为Mk。(因为这 C p k C^k_p Cpk 个模型的自变量数量均为k,所以此处最优模型可以通过最小的RSS或者最大的R2选取)
    3. 从 M0, M1, … , Mp中,选取一个最优模型。选取标准包括:交叉验证的预测误差, Cp, AIC, BIC, Adjusted R2

    缺点: p较大时运算量太大;巨大的探索空间可能导致过拟合。

    2.逐步选择法(Stepwise Selection)

    优点:运算量较小
    缺点:选择的模型可能不是最优模型

    2.1 向前逐步选择(Forward Stepwise Selection)

    1. 记 M0 为空模型(null model),此模型只存在截距项。
    2. 对于k = 0,1,2,…,p-1:
      拟合所有在 Mk 模型基础上加入1个自变量的模型(共有p-k个模型);
      保留RSS最小或R2最大的那个特征,此时这个模型记为Mk+1
    3. 从 M0, M1, … , Mp中,选取一个最优模型。选取标准包括:交叉验证的预测误差, Cp, AIC, BIC, Adjusted R2

    2.2 向后逐步选择(Backward Stepwise Selection)

    适用范围:样本数 n > 自变量数 p
    (所以当p非常大时,向前逐步选择是唯一可用的子集选择法)

    1. 记 Mp 为包含所有自变量的模型(full model)。
    2. 对于k = p, p-1, … ,1:
      拟合所有拟合所有在 Mk 基础上只减少一个自变量的模型(共有k个模型);
      保留RSS最小或R2最大的那个特征,此时这个模型记为Mk-1
    3. 从 M0, M1, … , Mp中,选取一个最优模型。选取标准包括:交叉验证的预测误差, Cp, AIC, BIC, Adjusted R2
    展开全文
  • 向前逐步选择3.向后逐步选择4.双向挑选 引言   逐步挑选是基于最优子集上的改进。逐步挑选分为向前挑选、向后挑选、双向挑选。其中最常用的是双向挑选,能够兼顾模型复杂度与模型精度的要求。逐步回归计算...

    引言

      逐步挑选法是基于最优子集法上的改进。逐步挑选法分为向前挑选、向后挑选、双向挑选。其中最常用的是双向挑选,能够兼顾模型复杂度与模型精度的要求。逐步回归法计算量大,python中也没有现成的包调用,使用的不多。常用到的指标有AIC,BIC, R 2 R^2 R2,在python中没有找到直接计算AIC,BIC的包,自定义也很复杂,这里使用 R 2 R^2 R2

    1.最优子集法

    (i) 记不含任何特征的模型为 𝑀0 ,计算这个 𝑀0 的测试误差。
    (ii) 在 𝑀0 基础上增加一个变量,计算p个模型的RSS,选择RSS最小的模型记作 𝑀1 ,并计算该模型 𝑀1 的测试误差。
    (iii) 再增加变量,计算p-1个模型的RSS,并选择RSS最小的模型记作 𝑀2 ,并计算该模型 𝑀2 的测试误差。
    (iv) 重复以上过程知道拟合的模型有p个特征为止,并选择p+1个模型 {𝑀0,𝑀1,…,𝑀𝑝} 中测试误差最小的模型作为最优模型。
      最优子集选择虽然在原理上很直观,但是随着数据特征维度p的增加,子集的数量为 2 p 2^p 2p (概率论里的知识),计算效率非常低下且需要的计算内存也很高,在大数据的背景下显然不适用。因此,我们需要把最优子集选择的运算效率提高。

    2.向前逐步选择

      相当于在最优子集法的基础上,每增加一个变量考虑了局部最优。
    (i) 记不含任何特征的模型为 M 0 M_0 M0,计算这个 M 0 M_0 M0的测试误差。
    (ii) 在 M 0 M_0 M0基础上增加一个变量,计算p个模型的RSS,选择RSS最小的模型记作 M 1 M_1 M1,并计算该模型 M 1 M_1 M1的测试误差。
    (iii) 在最小的RSS模型下继续增加一个变量,选择RSS最小的模型记作 M 2 M_2 M2,并计算该模型 M 2 M_2 M2的测试误差。
    (iv) 以此类推,重复以上过程知道拟合的模型有p个特征为止,并选择p+1个模型 { M 0 , M 1 , . . . , M p } \{M_0,M_1,...,M_p \} {M0,M1,...,Mp}中测试误差最小的模型作为最优模型。

    #!usr/bin/env python
    # -*- coding:utf-8 -*-
    """
    @author: admin
    @file: 向前逐步选择.py
    @time: 2021/03/15
    @desc:
    """
    import numpy as np
    import pandas as pd
    import statsmodels.api as sm
    from sklearn.linear_model import Lasso
    from sklearn.datasets import load_boston
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import r2_score
    
    
    def froward_select(train_data, test_data, target):
        """
        向前逐步回归
        :param data: 数据
        :param target:目标值
        :return:
        """
        variate = set(train_data.columns)
        variate.remove(target)
        # 参数
        selected = []  # 储存挑选的变量
        # 初始化
        # 初始化决定系数R^2,越近于1越好
        cur_score, best_score = 0.0, 0.0
        # 循环删选变量,直至对所有变量进行了选择
        while variate:
            variate_r2 = []
            # 找到局部最优
            for var in variate:
                selected.append(var)
                if len(selected) == 1:
                    model = Lasso().fit(train_data[selected[0]].values.reshape(-1, 1), train_data[target])
                    y_pred = model.predict(test_data[selected[0]].values.reshape(-1, 1))
                    # R2 = r2(test_data[target], y_pred)
                    R2 = r2_score(test_data[target], y_pred)
                    variate_r2.append((R2, var))
                    selected.remove(var)
                else:
                    model = Lasso().fit(train_data[selected], train_data[target])
                    y_pred = model.predict(test_data[selected])
                    # R2 = r2(test_data[target], y_pred)
                    R2 = r2_score(test_data[target], y_pred)
                    variate_r2.append((R2, var))
                    selected.remove(var)
            variate_r2.sort(reverse=False)  # 默认升序
            best_score, best_var = variate_r2.pop()  # pop用于移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
            if cur_score < best_score:  # 说明了加了该变量更好了
                variate.remove(best_var)  # 判断过了,不管是好是坏,就删了
                selected.append(best_var)
                cur_score = best_score
                print("R2={},continue!".format(cur_score))
            else:
                print('for selection over!')
                break
        selected_features = '+'.join([str(i) for i in selected])
        print(selected_features)
    
    
    def main():
        boston = load_boston()
        X = boston.data
        y = boston.target
        features = boston.feature_names
        x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.4)
        boston_train_data = pd.DataFrame(x_train, columns=features)
        boston_train_data["Price"] = y_train
        boston_test_data = pd.DataFrame(x_test, columns=features)
        boston_test_data["Price"] = y_test
        froward_select(boston_train_data, boston_test_data, 'Price')
    
    
    if __name__ == '__main__':
        main()
    
    R2=0.61744910032392,continue!
    R2=0.6908671406351847,continue!
    R2=0.7317782212152852,continue!
    R2=0.7395157511526225,continue!
    R2=0.7433588119420051,continue!
    R2=0.7454229322919887,continue!
    R2=0.7462568212024802,continue!
    R2=0.7462857832907019,continue!
    for selection over!
    LSTAT+PTRATIO+RM+DIS+B+CRIM+INDUS+TAX
    

    3.向后逐步选择

    向后逐步选择简述如下:

    1. 初始化时将所有特征放入模型中
    2. 每次剔除最差变量,该变量的剔除使得模型效果不明显,评估模型性能的改善
    3. 重复直到没有变量可剔除后
    #!usr/bin/env python
    # -*- coding:utf-8 -*-
    """
    @author: admin
    @file: 向后逐步挑选.py
    @time: 2021/03/16
    @desc:
    """
    import numpy as np
    import pandas as pd
    import statsmodels.api as sm
    from sklearn.linear_model import Lasso
    from sklearn.datasets import load_boston
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import r2_score
    
    
    def froward_select(train_data, test_data, target):
        """
        向前逐步回归
        :param data: 数据
        :param target:目标值
        :return:
        """
        variate = list(set(train_data.columns))
        variate.remove(target)
        # 参数
        selected = []  # 储存挑选的变量
        # 初始化
        # 初始化决定系数R^2,越近于1越好
        cur_score, best_score = 0.0, 0.0
        # 循环删选变量,直至对所有变量进行了选择
        while variate:
            variate_r2 = []
            # 找到局部最优
            for var in variate:
                variate.remove(var)
                if len(variate) == 1:
                    model = Lasso().fit(train_data[variate[0]].values.reshape(-1, 1), train_data[target])
                    y_pred = model.predict(test_data[variate[0]].values.reshape(-1, 1))
                    R2 = r2_score(test_data[target], y_pred)
                    variate_r2.append((R2, var))
                    variate.append(var)
                else:
                    model = Lasso().fit(train_data[variate], train_data[target])
                    y_pred = model.predict(test_data[variate])
                    R2 = r2_score(test_data[target], y_pred)
                    variate_r2.append((R2, var))
                    variate.append(var)
            variate_r2.sort(reverse=False)  # 升序排序r2,默认升序
            best_score, best_var = variate_r2.pop()  # pop用于移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
            if cur_score < best_score:  # 说明了移除了该变量更好了
                variate.remove(best_var)  # 判断过了,不管是好是坏,就删了
                selected.append(best_var)
                cur_score = best_score
                print("R2={},continue!".format(cur_score))
            else:
                print('for selection over!')
                break
        print(selected)
        selected = [var for var in set(train_data.columns) if var not in selected]
        selected_features = '+'.join([str(i) for i in selected])
    
        print(selected_features)
    
    
    def main():
        boston = load_boston()
        X = boston.data
        y = boston.target
        features = boston.feature_names
        x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.4)
        boston_train_data = pd.DataFrame(x_train, columns=features)
        boston_train_data["Price"] = y_train
        boston_test_data = pd.DataFrame(x_test, columns=features)
        boston_test_data["Price"] = y_test
        froward_select(boston_train_data, boston_test_data, 'Price')
    
    
    if __name__ == '__main__':
        main()
    
    R2=0.6130365918500247,continue!
    R2=0.6206140392385366,continue!
    R2=0.6206319773780711,continue!
    R2=0.6216812478858313,continue!
    R2=0.6217076288117218,continue!
    for selection over!
    ['CHAS', 'AGE', 'INDUS', 'ZN', 'NOX']
    TAX+Price+RAD+DIS+PTRATIO+RM+LSTAT+CRIM+B
    

    4.双向挑选

    双向挑选简述如下:
    向前向后挑选的结合
    双向挑选用的较多,能够兼顾模型复杂度与模型精度的要求。
    描述为:先两步向前挑选,再向后挑选,再反复向前向后

    #!usr/bin/env python
    # -*- coding:utf-8 -*-
    """
    @author: admin
    @file: 双向挑选.py
    @time: 2021/03/16
    @desc:
    """
    import numpy as np
    import pandas as pd
    import statsmodels.api as sm
    from sklearn.linear_model import Lasso
    from sklearn.datasets import load_boston
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import r2_score
    
    def froward_select(train_data, test_data, target):
        """
        向前逐步回归
        :param data: 数据
        :param target:目标值
        :return:
        """
        variate = list(set(train_data.columns))
        variate.remove(target)
        selected = []  # 储存挑选的变量
        selected_h = []  # 存储删除的变量
        # 初始化
        # 初始化决定系数R^2,越近于1越好
        cur_score_f, best_score_f = 0.0, 0.0
        cur_score_h, best_score_h = 0.0, 0.0
        # 循环删选变量,直至对所有变量进行了选择
        # 双向挑选—先两步前向再一步后向
        while variate:
            variate_r2_f = []
            variate_r2_h = []
            # 找到局部最优
            # 先两步前向
            for i in range(2):
                for var in variate:
                    selected.append(var)
                    if len(selected) == 1:
                        model = Lasso().fit(train_data[selected[0]].values.reshape(-1, 1), train_data[target])
                        y_pred = model.predict(test_data[selected[0]].values.reshape(-1, 1))
                        R2 = r2_score(test_data[target], y_pred)
                        variate_r2_f.append((R2, var))
                        selected.remove(var)
                    else:
                        model = Lasso().fit(train_data[selected], train_data[target])
                        y_pred = model.predict(test_data[selected])
                        R2 = r2_score(test_data[target], y_pred)
                        variate_r2_f.append((R2, var))
                        selected.remove(var)
                variate_r2_f.sort(reverse=False)  # 降序排序r2,默认升序
                best_score_f, best_var_f = variate_r2_f.pop()  # pop用于移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
                if cur_score_f < best_score_f:  # 说明了加了该变量更好了就不移除了,否则就移除
                    selected.append(best_var_f)
                    cur_score_f = best_score_f
                    print("R2_f={},continue!".format(cur_score_f))
                else:
                    variate.remove(best_var_f)
                    break
            # 再一步后向
            for var in variate:
                variate.remove(var)
                if len(variate) == 1:
                    model = Lasso().fit(train_data[variate[0]].values.reshape(-1, 1), train_data[target])
                    y_pred = model.predict(test_data[variate[0]].values.reshape(-1, 1))
                    R2 = r2_score(test_data[target], y_pred)
                    variate_r2_h.append((R2, var))
                    variate.append(var)
                else:
                    model = Lasso().fit(train_data[variate], train_data[target])
                    y_pred = model.predict(test_data[variate])
                    R2 = r2_score(test_data[target], y_pred)
                    variate_r2_h.append((R2, var))
                    variate.append(var)
            variate_r2_h.sort(reverse=False)  # 升序排序r2,默认升序
            best_score_h, best_var_h = variate_r2_h.pop()  # pop用于移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
            if cur_score_h < best_score_h:  # 说明了移除了该变量更好了
                variate.remove(best_var_h)
                selected_h.append(best_var_h)
                cur_score_h = best_score_h
                print("R2_h={},continue!".format(cur_score_h))
            else:
                print('for selection over!')
                selected = [var for var in set(train_data.columns) if var not in selected_h]
                selected_features = '+'.join([str(i) for i in selected])
                print(selected_features)
                break
    
    
    
    def main():
        boston = load_boston()
        X = boston.data
        y = boston.target
        features = boston.feature_names
        x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.4)
        boston_train_data = pd.DataFrame(x_train, columns=features)
        boston_train_data["Price"] = y_train
        boston_test_data = pd.DataFrame(x_test, columns=features)
        boston_test_data["Price"] = y_test
        froward_select(boston_train_data, boston_test_data, 'Price')
    
    
    if __name__ == '__main__':
        main()
    
    R2_f=0.5290772958895777,continue!
    R2_f=0.5992603091580796,continue!
    R2_h=0.6392096900660633,continue!
    R2_f=0.6328497309792275,continue!
    R2_f=0.6424099014083555,continue!
    R2_h=0.6446960403771425,continue!
    R2_f=0.6529845736263218,continue!
    R2_f=0.6555371387702666,continue!
    R2_h=0.6524813775669193,continue!
    R2_f=0.6577033230821112,continue!
    R2_f=0.6577063213485781,continue!
    R2_h=0.6525859983540159,continue!
    R2_f=0.6577196381996436,continue!
    for selection over!
    Price+RM+CHAS+AGE+PTRATIO+TAX+NOX+CRIM+B+DIS
    

    参考:
    根据AIC准则定义向前逐步回归进行变量筛选


    如果对您有帮助,麻烦点赞关注,这真的对我很重要!!!如果需要互关,请评论留言!
    在这里插入图片描述


    展开全文
  • 特征选择,SFS(顺序向前)与SBS(顺序向后)matlab源码&解析 这边文章将会讲解最基础的SFS algorithm & SBS algorithm. SFS-matlab %% SFS function [X,MaxF] = SFS(gN) MaxTimes = 4800; times = 0;%迭代...
  • 特征选择方法最全总结!

    千次阅读 2021-10-02 00:23:01
    上个月扫读完《阿里云天池大赛赛题解析》[1]后,看到书中对特征选择的讲述,于是便打算借此机会,系统梳理下各种特征选择方法。如有不足,还望指正。一、背景介绍在处理结构型数据时,特征工程中的特...
  • 时间序列分析预测:指数平滑

    千次阅读 2021-04-21 08:39:40
    时间序列分析预测:指数平滑 指数平滑是在移动平均基础上发展起来的一种时间序列分析预测,它是通过计算指数平滑值,配合一定的时间序列预测模型对现象的未来进行预测。其原理是任一期的指数平滑值都是本期...
  • 逆向归纳

    2021-04-21 05:55:21
    逆向归纳(backward induction)是求解动态博弈均衡的方法[编辑]什么是逆向归纳逆向归纳(backward induction)是求解动态博弈均衡的方法。所谓动态博弈是指博弈参与人的行动存在着先后次序,并且后行动的参与人...
  • 天大matlab大作业逐步回归分析方法.doc 逐步回归分析方法在实际中,影响Y的因素很多,...选择“最优”的回归方程有以下几种方法:(1)从所有可能的因子(变量)组合的回归方程中选择最优者;(2)从包含全部变量的回归方...
  • 遵循过滤方法的相同目标,但使用机器学习模型作为其评估标准(例如,向前/向后/双向/递归特征消除)。我们将一些特征输入机器学习模型,评估它们的性能,然后决定是否添加或删除特征以提高精度。因此,这种方法可以...
  • 在学习图的存储的时候,我们通常会有邻接矩阵和邻接表两种选择,邻接矩阵好写但效率低,邻接表不好写写但效率高,这里有一种优秀的数据结构,那便是用静态链表头插实现的链式向前星。 先给出一下邻接矩阵 可以...
  • 简单选择排序:(选出最小值,放在第一位,然后第一位向后推移,如此循环)第一位与后面每一个逐个比较,每次都使最小的置顶,第一位向后推进(即刚选定的第一位是最小值,不再参与比较,比较次数减1)复杂度: 所需进行...
  • 有限差分以Taylor级数展开等方法,把控制方程中的导数用网格节点上的函数值的差商代替进行离散,从而建立以网格节点上的值为未知数的代数。该方法是一种直接将问题变为代数问题的近似数值解法,数学概念直观,表达...
  • 牛顿logistic回归

    2021-10-17 21:28:14
    牛顿求解Logistic Regression 1、Logistic回归模型、牛顿推导公式 Logistic模型为(xi\mathbf{x_i}xi​是第iii个样本,为行向量,w\mathbf{w}w是特征向量,为一个列向量) KaTeX parse error: Unknown column ...
  • 回溯求解TSP问题回溯求解TSP问题人工智能实验报告实验名称:TSP问题姓名:xxx学号:xxxxx大学计算机学院2014年1月14日实验目的掌握递归回溯的思想,能够求解TSP问题,增强自己的编程能力.实验内容下图是5个...
  • 由于和零阶保持器z变换类似的原因计算机控制系统 2008年4月 计算机控制系统的经典设计方法 连续域-离散化设计 在连续域设计控制律D(s),将D(s)离散化 飞行控制律的数字化设计 离散域设计 将被控对象离散化,直接在...
  • 算法——回溯

    2021-11-17 12:34:26
    回溯(backtracking)是一种选优搜索,按选优条件向前搜索,以达到目标。但当探索到某一步时,发现原先选择并不优或达不到目标,就退回一步重新选择,这种走不通就退回再走的技术为回溯,而满足回溯条件的某个...
  • 结果就是系数估计值不稳定,在多个自变量的情况下,我们可以使用向前选择法,向后剔除法和逐步筛选法来选择最重要的自变量。 2. 逻辑回归(Logistic Regression) 逻辑回归是用来计算“事件=Success”和“事件=...
  • 倾向得分匹配 PSM

    千次阅读 2020-12-30 23:27:24
    以倾向得分为依据,在控制组样本中向前或向后寻找最接近干预组样本得分的对象,并形成配对。 (2)半径匹配(Radiusmatching)。设定一个常数r(可理解为区间或范围,一般设定为小于倾向得分标准差的四分之一),将...
  • 汤圆向前冲红包版

    2021-06-06 04:29:54
    汤圆向前冲红包版是由百度推出...汤圆向前冲红包版游戏玩简介:1、是一款可以帮助玩家一边玩游戏,一边还能赢得红包奖励的休闲手游。2、在游戏中你可以通过闯关的方式来进行积分的累计,积分换取大红包。3、你需要...
  • 向前选择法从模型中最显著的预测开始,然后为每一步添加变量。 05 Ridge Regression岭回归 岭回归分析是一种用于存在多重共线性(自变量高度相关)数据的技术。在多重共线性情况下,尽管最小二乘法(OLS)对每个...
  • 五大常用算法之四:回溯

    千次阅读 2020-12-20 03:34:13
    回溯是一种选优搜索,按选优条件向前搜索,以达到目标。但当探索到某一步时,发现原先选择并不优或达不到目标,就退回一步重新选择,这种走不通就退回再走的技术为回溯,而满足回溯条件的某个状态的点称为...
  • 《算法分析设计回溯求解装载问题实验报告》由会员分享,可在线阅读,更多相关《算法分析设计回溯求解装载问题实验报告...当发现当前候选解不可能是解时,就选择下一个候选解;倘 若当前候选解除了还不满足问题规...
  • 回溯是一种选优搜索,按选优条件向前搜索,以达到目标。但当探索到某一步时,发现原先选择并不优或达不到目标,就退回一步重新选择,这种走不通就退回再走的技术为回溯,而满足回溯条件的某个状态的点称为...
  • 什么是特征选择对一个学习任务来说,给定属性集,有些属性很有用,另一些则可能没什么用。这里的属性即称为“特征”(feature)。对当前学习任务有用的属性称为“相关特征”(relevant feature)、没什么用的属性称为...
  • 分治分治是一种很重要的算法,也就是“分而治之”的意思,就是把一个复杂的问题分解成两个或者多个相似的子问题,直到最后子问题可以简单的直接求解,原问题的解即子问题的解的合并。比如二分搜索算法,排序算法...
  • 如何评价长洱的《天才基本》?

    千次阅读 2020-12-24 12:06:00
    读完《天才基本》后的感受很复杂,从小说里领悟到的许许多多,最终都只归结于一个词——震撼。林朝夕。原来的世界里,本该走上平淡的人生。幸而,上天给了她一个机会。三段往返,她不留遗憾,成为了自己想成为的人...
  • 原标题:JS 中国象棋(1):校验棋子走(点击上方公众号,可快速关注)作者:伯乐在线专栏作者 - 未济如需转载,发送「转载」二字查看说明“Java中国象棋程序” 这一系列教程将带你从头使用Java编写一个中国象棋程序。...
  • 人工神经网络评价

    2021-02-05 04:20:46
    第五章第一节 思想和原理第二节 模型和步骤第三节 应用和案例第一节 思想和原理在当今社会,面临许许多多的选择或决策问题。人们通过分析各种影响因素,建立相应的数学模型,通过求解最优解来得到最佳方案。由于数学...
  • LassoCV, ElasticNetfrom sklearn.pipeline import Pipelinefrom sklearn.preprocessing import StandardScalerfrom statsmodels.formula import api as smfimport sysimport os‘‘‘多元线性回归特征选择类‘‘...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,972
精华内容 19,988
关键字:

向前选择法