精华内容
下载资源
问答
  • 线性回归,前面用Python从底层一步一个脚印用两种方法实现了回归拟合。在这个高级语言层出不穷的年代,这样做显然不明智,所以我考虑用优秀的数据分析工具——R语言(不敢说最...
        

    640?wx_fmt=png

    线性回归,前面用Python从底层一步一个脚印用两种方法实现了回归拟合。在这个高级语言层出不穷的年代,这样做显然不明智,所以我考虑用优秀的数据分析工具——R语言(不敢说最优秀,虽然心里是这么想的,我怕有人要骂我!)做回归分析。包括简单多变量回归、逐步回归、逻辑回归!

    对了,上次,用Python写的两篇回归拟合分别是:

    多元回归分析,生活中用的很多,因为一个因素可能与很多其它因素有关!言归正传,这里考虑用R语言里面的相关函数做回归分析。

    需要的用到的知识储备:

    • 线性代数

    • 概率论与数理统计

    • 高等数学

    • R语言基础

    下面分别从普通多元线性回归、逐步回归、逻辑回归进行介绍。前面用Python实现的只是一元回归,由于R语言实现线性回归很方便,所以我会着重介绍原理。

    多元线性回归

    不论是单变量还是多元线性回归分析,他们都是直接或间接(有时候需要通过变量代换)程线性的关系。我们需要找到一个通用的线性模型来描述这种关系,在我们可以接受的误差范围内对数据进行预测或者发现规律。

    多元线性回归理论基础

    对于一组变量数据,如果我们不管是通过画散点图还是其它方法,知道了一个变量与其它变量程很强线性关系。我们就需要知道,到底是什么样的关系,关系系数是多少。通常是用经典的最小二乘法,因为这样算出的确实是最优的系数,可以保证残差平方和最小的优化目标。

    对于一个因变量y,有一组自变量X = (x1,x2,...,xk),x1,x2,...,xk,eps是列向量,考虑它们之间有如下线性关系:

    640?wx_fmt=png

    当然了,这里X = (x1,x2,...,xk),y都是给的一组数据,就像这样

    640?wx_fmt=png

    那么,对每一组(比如第一行)数据,就有如下关系:

    640?wx_fmt=png

    目标函数为残差平方和的关于系数beta0,beta1,...,betak的多元二次函数,我们希望找到一组系数使得目标函数值最小,即误差最小。目标函数如下:

    640?wx_fmt=png

    学过数学分析或者高等数学的人都知道,这只要关于beta0,beta1,...,betak分别求偏导数,得到k+1方程,再求出零点即可。

    我们用矩阵表示各个变量如下:

    640?wx_fmt=png

    那么,学过高等代数(数学专业)或者线性代数(工科)都知道,因变量与自变量关系可以表示为:

    640?wx_fmt=png

    中间推导过程这里不在赘述了,最终系数向量表达式为:

    640?wx_fmt=png

    关于多元线性回归的理论就到这里,有兴趣可以参考:线性回归导论(机械工业出版社 王辰勇 译)

    多元线性回归的R语言实现

    这里用R语言里面的常用数据集iris来说明,这个数据集包含五个指标,我们这里先只用前面四个:花萼长度、花萼宽度、花瓣长度、花瓣宽度,进行多元线性回归分析。

    数据预处理

    大家都知道,为了消除不同变量量纲或者数量级不一致,做数据标准化的数据预处理是有必要的。用到的R语言函数是scale(),这个函数的机理具体公式如下:

    640?wx_fmt=png

    R语言实现如下:

    640?wx_fmt=png

    标准化后数据选择前六行我们看一下:

    > head(sl.sc)

         Sepal.Length

    [1,]   -0.8976739

    [2,]   -1.1392005

    [3,]   -1.3807271

    [4,]   -1.5014904

    [5,]   -1.0184372

    [6,]   -0.5353840

    下面构建多元线性回归

    我们用花萼标准化后的数据sl.sc与其它三个变量做线性回归,先做有常数项的多元回归。

    lm.sc <- lm(sl.sc~sw.sc+pl.sc+pw.sc)

    summary(lm.sc)

    640?wx_fmt=png

    summary(lm.sc)给出了线性回归的相关信息,各个系数Residuals给出了残差的5分位数,Estimate、Std. Error、t value、Pr(>|t|)分别给出了自变量系数、标准误、t值和p值,Multiple R-squared:  0.8586, Adjusted R-squared:  0.8557分别给出了R方与修正的R方,这里 R-squared:  0.8557表示这个线性回归模型可以解释85.57的原数据,还是不错的,后面就不再解释这几个指标的意思了。可以看出无论是每个系数还是总体的p-value都远远小于0.05,给出了三颗星***的等级,但是如图蓝色方框是常数项的值是-1.176e-16,太小了,p值是1,告诉我们常数项可以不用,这些数据是过原点的线性关系。

    去掉常数项的多元回归,不同的是,减一表示不要常数项

    lm.sc <- lm(sl.sc~sw.sc+pl.sc+pw.sc-1)

    summary(lm.sc)

    模型详细情况:

    640?wx_fmt=png

    显然,去掉后R方,F值没有明显变换,系数等级都是三颗星,表明去掉常数项确实在不影响模型情况下简化了模型。

    我们来看一下残差图与QQ图:

    plot(lm.sc,1,col = 'orange',main = '残差图')

    plot(lm.sc,2,col = 'orange',main = 'QQ图')

    640?wx_fmt=png

    640?wx_fmt=png

    通过残差图与QQ图也可以明显看出这个不带常数项的线性回归模型是不错的。

    逐步回归

    逐步回归的基本思想是将变量逐个引入模型,每引入一个解释变量后都要进行F检验,并对已经选入的解释变量逐个进行t检验,当原来引入的解释变量由于后面解释变量的引入变得不再显著时,则将其删除。以确保每次引入新的变量之前回归方程中只包含显著性变量。这是一个反复的过程,直到既没有显著的解释变量选入回归方程,也没有不显著的解释变量从回归方程中剔除为止。以保证最后所得到的解释变量集是最优、最简单的。

    逐步回归最常用的挑选准则有修正复相关系数、预测平方和、Cp和AIC等,这里用AIC准则,对于含有P个自变量的回归方程,n为观测值(样本)个数,AIC越小越好,具体计算公式为:

    640?wx_fmt=png

    使用R语言构建逐步回归模型

    知道原理后,我们试图从三个自变量中筛选出两个,首先看一下上述模型的AIC

    step(lm.sc)

    640?wx_fmt=png

    显然,三个变量时AIC是最小的,这里为了说明问题,实在要剔除一个变量的话,当然要剔除第一个。因为我们发现剔除pw.sc时AIC为-272.06,如果剔除pl.scAIC就为-181.26,而AIC越小越好,所以就剔除变量pw.sc吧。

    lm.new <- lm(sl.sc~sw.sc+pl.sc-1)

    summary(lm.new)

    640?wx_fmt=png

    R方稍微减小了一点,因为三个变量AIC最小(即模型最优),提出后肯定会减小的。这里为了说明问题才强行提出一个。

    逻辑回归

    在介绍逻辑回归前我们先介绍什么是哑变量,其实,R语言用的多的人都知道iris这个数据集有5列,第五列是花的分类:setosa、versicolor、 virginica。那么花萼长度是否与花的分类有关呢?一般是有的。增加三列,我们考虑引入0~1变量那么对于属于setosa的,记为1,versicolor、 virginica位置记为0,同理就多了3列,这里的0,1就是哑变量。还是为了减少变量,简化模型,我们只增加2列versicolor和 virginica,这样versicolor、 virginica位置都为0时,就属于setosa这个分类,versicolor位置为1时就为versicolor这个分类。0,1是逻辑变量,线性回归引入了逻辑变量,故称为逻辑回归。

    下面就进行R语言实现,要不看一下iris数据集长什么样:

    640?wx_fmt=png

    第五列变量就有三个水平,都是50条,正好。

    640?wx_fmt=png

    两个for()语句就是构造逻辑变量的,还是很好理解的,这样就有五个变量了。构造的应该像这样:

    640?wx_fmt=png

    这里省略了前面的,只为说明构造的逻辑变量(实际应该是s1里面51~100为1,s2里面101~150为1,其它为0)。看一下结果:

    640?wx_fmt=png

    所有变量系数p-value都小于0.05,R-squared:  0.8627,比没有增加逻辑变量的R-squared:  0.8557好一些,可见花的分类确实对花萼长度sl.sc有关系。最终表达式为:

    640?wx_fmt=png

    猜你可能喜欢

    640?wx_fmt=jpeg

    展开全文
  • 线性回归和逻辑回归的梯度介绍(Introduction) One of the most powerful ways of training models is to train multiple models and aggregate their predictions. This is the main concept of Ensemble Learning. ...

    线性回归和逻辑回归的梯度

    介绍(Introduction)

    One of the most powerful ways of training models is to train multiple models and aggregate their predictions. This is the main concept of Ensemble Learning. While many flavours of Ensemble Learning exist, some of the most powerful algorithms and Boosting Algorithms. In my previous article, I broke down one of the most popular Boosting Algorithms; Adaptive Boosting. Today, I want to talk about its equally powerful twin; Gradient Boosting.

    训练模型最强大的方法之一是训练多个模型并汇总其预测。 这是集成学习的主要概念 尽管存在多种合奏学习风格,但一些最强大的算法和Boosting算法。 在上一篇文章中,我分解了一种最受欢迎​​的Boosting算法。 自适应提升。 今天,我想谈谈它同样强大的孪生兄弟。 渐变增强。

    增强与自适应增强与梯度增强 (Boosting & Adaptive Boosting vs Gradient Boosting)

    Image for post

    Boosting refers to any Ensemble Method that can combine several weak learners(a predictor with poor accuracy) to make a strong learner(a predictor with high accuracy). The idea behind boosting is to train models sequentially, each trying to correct its predecessor.

    Boosting是指可以将多个弱学习者(准确性低的预测变量)组合成强大学习者(高精度的预测变量)的任何集成方法。 增强背后的想法是顺序地训练模型,每个模型都试图纠正其前身。

    自适应提升概述 (An Overview Of Adaptive Boosting)

    In Adaptive Boosting, the main idea occurs with the model assigning a certain weight to each instance, and training a weak learner. Based on the predictor’s performance, it gets assigned its own separate weight based on a weighted error rate. The higher the accuracy of the predictor, the higher its weight, and the more “say” it will have on the final prediction.

    自适应提升中,主要思想是模型为每个实例分配一定的权重,并训练一个弱学习者。 根据预测器的性能,将基于加权错误率为其分配单独的权重。 预测变量的准确性越高,其权重就越高,并且对最终预测变量的“判断”就越多。

    Once the predictor has made predictions, AdaBoost looks at the misclassified instances, and boosts their instance weights. After normalising the instance weights so that they all equate to 1, a new predictor is trained and the process is repeated until a desirable output is reached, or a threshold is reached.

    一旦预测器做出预测,AdaBoost就会查看错误分类的实例,并提高其实例权重。 在对实例权重进行标准化以使它们全部等于1之后,将训练新的预测变量,并重复该过程,直到达到所需的输出或达到阈值为止。

    The final classification is done by taking a weighted vote. In other words, if we were predicting heart disease on a patient, and 60 stumps predicted 1 and 40 predicted 0, but the predictors in the 0 class had a higher cumulative weight(i.e the predictors had more “say”), then the final prediction would be 0.

    最终分类通过加权投票完成。 换句话说,如果我们正在预测患者的心脏病,60个残端预测1,40个预测0,但是0类的预测因子具有更高的累积权重(即预测因子具有更多的“说”),则最终预测将为0。

    梯度提升 (Gradient Boosting)

    In contrast to Adaptive Boosting, instead of sequentially boosting misclassified instance weights, Gradient Boosting actually make predictions on the predecessors residuals. Woah, hold it. What?

    与“自适应增强”相比,“梯度增强”实际上不是对顺序错误的实例权重进行增强,而是对先前的残差进行预测 哇,等一下什么?

    Image for post

    Ok, so let’s break down the model’s steps:

    好的,让我们分解模型的步骤:

    1. The first thing Gradient Boosting does is that is starts of with a Dummy Estimator. Basically, it calculates the mean value of the target values and makes initial predictions. Using the predictions, it calculates the difference between the predicted value and the actual value. This is called the residuals.

      Gradient Boosting要做的第一件事是从虚拟估计器开始。 基本上,它计算目标值的平均值并进行初始预测。 使用这些预测,可以计算出预测值和实际值之间的差异。 这称为残差。

    2. Next, instead of training a new estimator on the data to predict the target, it trains an estimator to predict the residuals of the first predictor. This predictor is usually a Decision Tree with certain limits, such as the maximum amount of leaf nodes allowed. If multiple instances’ residuals are in the same leaf node, it takes their average and uses that as the leaf node’s value.

      接下来,与其在数据上训练新的估计器以预测目标,不如在训练估计器以预测第一个预测器残差。 该预测变量通常是具有某些限制的决策树,例如允许的最大叶节点数量。 如果多个实例的残差在同一个叶节点中,它将取其平均值并将其用作叶节点的值。

    3. Next, to make predictions, for each instance, it adds the base estimator’s value onto the Decision Tree’s predicted residual value of the instance to make a new prediction. It then calculates the residuals again between the predicted and actual value.

      接下来,要进行预测,对于每个实例,它将基本估计量的值添加到实例的决策树的预测残差值上,以进行新的预测。 然后,它再次计算预测值和实际值之间的残差。
    4. This process is repeated until a certain threshold is reached or the residual difference is very small.

      重复此过程,直到达到某个阈值或残差很小。
    5. To make a prediction for an unseen instance, it gives the instance to each and very decision tree made, sums their predictions and adds the base estimator’s value.

      为了对看不见的实例进行预测,它将实例提供给每个决策树,对它们的预测求和,并添加基本估算器的值。

    学习率 (Learning Rate)

    An important hyperparameter to take note of here is the learning rate. This actually scales the contribution of each tree, so essentially increasing bias in exchange for a lower variance. So at step 3 and 4, the predicted value is actually multiplied by a learning rate to achieve better generalisation on unseen data.

    这里要注意的一个重要的超参数是学习率。 这实际上缩放了每棵树的贡献,因此实质上增加了偏差以换取较低的方差。 因此,在第3步和第4步,将预测值实际乘以学习率,以更好地概括未见数据。

    使用Python和Scikit-Learn进行梯度提升回归的动手示例 (A hands-on example of Gradient Boosting Regression with Python & Scikit-Learn)

    Image for post

    Some of the concepts might still be unfamiliar in your mind, so, in order to learn, one must apply! Let’s build a Gradient Boosting Regressor to predict house prices using the infamous Boston Housing Dataset. Without further ado, let’s get started!

    您可能对某些概念不熟悉,因此,为了学习,必须先应用一个概念! 让我们构建一个梯度提升回归器,以使用臭名昭著的波士顿住房数据集来预测房价。 事不宜迟,让我们开始吧!

    import pandas as pd
    import numpy as npfrom sklearn.metrics import mean_squared_error
    from sklearn.model_selection import KFold
    from sklearn.datasets import load_bostonfrom sklearn.tree import DecisionTreeRegressor
    from sklearn.ensemble import GradientBoostingRegressor

    Ok, so we do some basic imports, along with our dataset, which is conveniently builtin to scikit-learn, and Kfold cross validation, for splitting our data into a train set and validation set. We also import the DecisionTreeRegressor as well as the GradientBoostingRegressor

    好的,所以我们进行了一些基本的导入以及数据集(方便地内置到scikit-learn和Kfold交叉验证中),以便将数据分为训练集和验证集。 我们还导入了DecisionTreeRegressor以及GradientBoostingRegressor

    df = pd.DataFrame(load_boston()['data'],columns=load_boston()['feature_names'])
    df['y'] = load_boston()['target']
    df.head(5)

    Here, we just convert our data into a DataFrame for convenience

    在这里,为了方便起见,我们只是将数据转换为DataFrame

    X,y = df.drop('y',axis=1),df['y']kf = KFold(n_splits=5,random_state=42,shuffle=True)for train_index,val_index in kf.split(X):
    X_train,X_val = X.iloc[train_index],X.iloc[val_index],
    y_train,y_val = y.iloc[train_index],y.iloc[val_index]

    Here, we initialise our features and our target, and use 5 Fold cross validation to split our dataset into a training set and a validation set.

    在这里,我们初始化功能和目标,并使用5折交叉验证将我们的数据集分为训练集和验证集。

    Before I go ahead and implement scikit-learn’s GradientBoostingRegressor, I would like to make a custom one of my own, just to help illustrate the concepts I wrote about earlier.

    在继续实施scikit-learn的GradientBoostingRegressor之前,我想做一个自己的自定义,只是为了帮助说明我之前写的概念。

    First, we create our initial predictions to be just the average of the training label values and assign our learning rate to be 0.1:

    首先,我们将初始预测创建为训练标签值的平均值,并将学习率分配为0.1:

    base = [y_train.mean()] * len(y_train)
    learning_rate = 0.1

    Then, we calculate the residuals and get the MSE:

    然后,我们计算残差并获得MSE:

    residuals_1 = base - y_train
    mean_squared_error(y_val, base[len(y_val)])OUT:
    71.92521322606885

    Well, not so bad, considering we just predicted the mean value the whole time!

    好吧,考虑到我们一直在预测平均值,还算不错!

    After that, we create our first tree and train it on the residuals. Again we will get the MSE of our predictions on the validation set:

    之后,我们创建我们的第一棵树并在残差上对其进行训练。 同样,我们将在验证集上获得预测的MSE:

    predictions_dtree_1 = base + learning_rate * dtree_1.predict(X_train)
    mean_squared_error(y_train,predictions_dtree_1)OUT:
    70.90445609876541

    Ok, so a slight improvement, already showing the power of Gradient Boosting! Again, we get the residuals:

    好的,这是一个很小的改进,已经显示了Gradient Boosting的强大功能! 同样,我们得到残差:

    residuals_2 = y_train - predictions_dtree_1
    dtree_2 = DecisionTreeRegressor(random_state=42)
    dtree_2.fit(X_train,residuals_2)

    And we get the MSE by making predictions, but note how we combined the predicted value of the first predictor with the new predictor’s values:

    我们通过做出预测来获得MSE,但请注意我们如何结合 第一个预测变量的预测值与新预测变量的值:

    predictions_dtree_2 = ((dtree_2.predict(X_train) * learning_rate)) + predictions_dtree_1
    mean_squared_error(y_train,predictions_dtree_2)OUT:
    57.43260944000001

    Wow, that was a big leap indeed! Now, let’s keep training a few more predictors to see what we can achieve:

    哇,那确实是一个巨大的飞跃! 现在,让我们继续训练更多的预测变量,以了解我们可以实现的目标:

    residuals_3 = y_train - predictions_dtree_2
    dtree_3 = DecisionTreeRegressor(random_state=42)
    dtree_3.fit(X_train,residuals_3)predictions_dtree_3 = (dtree_3.predict(X_train) * learning_rate) + predictions_dtree_2residuals_4 = y_train - predictions_dtree_3
    dtree_4 = DecisionTreeRegressor(random_state=42)
    dtree_4.fit(X_train,residuals_4)predictions_dtree_4 = (dtree_4.predict(X_train) * learning_rate) + predictions_dtree_3
    mean_squared_error(y_train,predictions_dtree_4)OUT:43.90388561846081

    So we definitely improved our score, but now it’s time for the ultimate test: the validation set!

    因此,我们确实提高了分数,但是现在该进行终极测试了:验证集!

    To make a final prediction, we do the following:

    为了做出最终预测,我们执行以下操作:

    initial prediction(the mean of the target values) * learning rate +

    初始预测(目标值的平均值)*学习率+

    • predicted reisudal values from tree 1

      树1的预计重新估值
    • predicted reisudal values from tree 2

      树2的预测的重新设计值
    • predicted reisudal values from tree 3

      树3的预计重新估值
    • predicted reisudal values from tree 4

      树4的预测的重新设计值

    In code:

    在代码中:

    y_pred = base[:101] + learning_rate * 
    (dtree_1.predict(X_val)) +
    (dtree_2.predict(X_val) * learning_rate) +
    (dtree_3.predict(X_val) * learning_rate) +
    (dtree_4.predict(X_val) * learning_rate)

    And the result (Drumroll please…):

    结果(请打鼓……):

    mean_squared_error(y_train, y_pred)OUT:
    42.32013345535233

    Fantastic! Not only did it fit the training set well, it also generalised smoothly on the test set! Why? Because we used a learning rate to control each trees contribution size, making sure that the ensemble did not overfit the data.

    太棒了! 它不仅非常适合训练集,而且还可以在测试集上顺利推广! 为什么? 因为我们使用学习率来控制每棵树的贡献大小,所以请确保该集合不会过度拟合数据。

    使用Scikit-Learn的GradientBoostingRegressor进行梯度增强 (Gradient Boosting with Scikit-Learn’s GradientBoostingRegressor)

    Image for post

    We have now manually made a basic gradient boosting algorithm, but now let us code out a Gradient Boosting Regressor using scikit-learn!

    现在,我们已经手动制作了基本的梯度增强算法,但是现在让我们使用scikit-learn编写出梯度增强回归器!

    Using the same data as above:

    使用与上述相同的数据:

    gradient_booster = GradientBoostingRegressor(loss='ls',learning_rate=0.1)
    gradient_booster.get_params()OUT:
    {'alpha': 0.9,
    'ccp_alpha': 0.0,
    'criterion': 'friedman_mse',
    'init': None,
    'learning_rate': 0.1,
    'loss': 'ls',
    'max_depth': 3,
    'max_features': None,
    'max_leaf_nodes': None,
    'min_impurity_decrease': 0.0,
    'min_impurity_split': None,
    'min_samples_leaf': 1,
    'min_samples_split': 2,
    'min_weight_fraction_leaf': 0.0,
    'n_estimators': 100,
    'n_iter_no_change': None,
    'presort': 'deprecated',
    'random_state': None,
    'subsample': 1.0,
    'tol': 0.0001,
    'validation_fraction': 0.1,
    'verbose': 0,
    'warm_start': False}

    Now, this model has a lot of parameters, so it is worth mentioning the most important ones:

    现在,该模型具有很多参数,因此值得一提的是最重要的参数:

    learning_rate: exactly the same parameter as we have discussed about above; it scales the contribution of each tree

    learning_rate :与我们上面讨论的参数完全相同; 它缩放了每棵树的贡献

    init: the initial estimator, which equates to the DummyEstimator by default(aka predicts the mean for everything)

    init:初始估计量,默认情况下等于DummyEstimator(aka预测所有均值)

    max_depth: the maximum depth you want your trees to grow

    max_depth:您希望树木生长的最大深度

    n_estimators: the amount of trees you want to create

    n_estimators:您要创建的树的数量

    criterion: what loss function you would like to minimise for the decision trees to use when it is searching for the best feature and threshold that splits the data.

    准则:当搜索拆分数据的最佳特征和阈值时,您希望对决策树使用的损失函数最小化。

    loss: the loss to use for calculating residuals(the default is “ls”, or least squares)

    loss :用于计算残差的损失(默认为“ ls”或最小二乘)

    max_leaf_nodes: the maximum number of leaf nodes you want to have for each tree. If this number is smaller then the number of training instances, and if two or more instances are in the same leaf, then the leaf’s value will be the average of all the training instance values in that leaf.

    max_leaf_nodes:每棵树要拥有的最大叶节点数。 如果此数目较小,则为训练实例的数目,并且如果同一叶中有两个或更多实例,则该叶子的值将为该叶中所有训练实例值的平均值。

    Let’s fit our model to the dataset and get its R2 score:

    让我们将模型拟合到数据集并获得其R2分数:

    gradient_booster.fit(X_train,y_train)gradient_booster.score(X_train,y_train)OUT:
    0.9791009142174039

    And let’s get its R2 Score on the validation set:

    让我们在验证集上获得其R2分数:

    gradient_booster.score(X_val,y_val)OUT:
    0.8847454683496595

    Ok , so our algorithm is slightly overfitting. Let’s adjust the learning_rate parameter to see if we can get better results:

    好的,所以我们的算法有点过拟合。 让我们调整learning_rate参数以查看是否可以获得更好的结果:

    gradient_booster = GradientBoostingRegressor(loss='ls',learning_rate=0.25)gradient_booster.fit(X_train,y_train)gradient_booster.score(X_train,y_train)OUT:
    0.994857818295815gradient_booster.score(X_val,y_val)OUT:
    0.9082261292781879

    This is a much better result, where we sacrificed some bias for a better variance. Finally, let’s get the ensemble’s MSE on the validation set:

    这是一个更好的结果,我们为了更好的变化而牺牲了一些偏见。 最后,让我们获取验证集中的集合的MSE:

    predictions = gradient_booster.predict(X_val)
    mean_squared_error(y_val,predictions)OUT:
    6.599129139886324

    Ok, so that wraps up this one, folks! I hope you enjoyed it, but my Gradient Boosting days are not over yet! I will be back, and in the next articles I will be talking about Gradient Boosting for Classification, and more importantly; the big boy: XTREME GRADIENT BOOSTING! But, for now:

    好的,伙计们,这个总结一下! 希望您喜欢它,但是我的Gradient Boosting天还没有结束! 我会回来的,在接下来的文章中,我将讨论分类的梯度提升,更重要的是, 大男孩:XTREME GRADIENT BOOSTING! 但现在:

    Image for post

    翻译自: https://medium.com/@vagifaliyev/a-hands-on-explanation-of-gradient-boosting-regression-4cfe7cfdf9e

    线性回归和逻辑回归的梯度

    展开全文
  • python 逐步逻辑回归源码

    千次阅读 2019-01-18 17:40:03
    import os import pandas as pd import statsmodels.api as sm from sklearn.metrics import auc,roc_curve import matplotlib.pyplot as plt   def stepwise_selection(X, y,  initial_lis...

    import os
    import pandas as pd
    import statsmodels.api as sm
    from sklearn.metrics import auc,roc_curve
    import matplotlib.pyplot as plt

     

    def stepwise_selection(X, y,
                           initial_list=[],
                           threshold_in=0.01,
                           threshold_out = 0.05,
                           verbose = True):
        """ Perform a forward-backward feature selection
        based on p-value from statsmodels.api.OLS
        Arguments:
            X - pandas.DataFrame with candidate features
            y - list-like with the target
            initial_list - list of features to start with (column names of X)
            threshold_in - include a feature if its p-value < threshold_in
            threshold_out - exclude a feature if its p-value > threshold_out
            verbose - whether to print the sequence of inclusions and exclusions
        Returns: list of selected features
        Always set threshold_in < threshold_out to avoid infinite looping.
        See https://en.wikipedia.org/wiki/Stepwise_regression for the details
        """
        included = list(initial_list)
     
        while True:
            changed=False
            # forward step
            excluded = list(set(X.columns)-set(included))
            new_pval = pd.Series(index=excluded)
            for new_column in excluded:
                model = sm.Logit(y, sm.add_constant(pd.DataFrame(X[included+[new_column]]))).fit()
                new_pval[new_column] = model.pvalues[new_column]
            best_pval = new_pval.min()
            if best_pval < threshold_in:
                best_feature = new_pval.argmin()
                included.append(best_feature)
                changed=True
                if verbose:
                    print('Add  {:30} with p-value {:.6}'.format(best_feature, best_pval))
     
            # backward step
            model = sm.Logit(y, sm.add_constant(pd.DataFrame(X[included]))).fit()
            # use all coefs except intercept
            pvalues = model.pvalues.iloc[1:]
            worst_pval = pvalues.max() # null if pvalues is empty
            if worst_pval > threshold_out:
                changed=True
                worst_feature = pvalues.argmax()
                included.remove(worst_feature)
                if verbose:
                    print('Drop {:30} with p-value {:.6}'.format(worst_feature, worst_pval))
            if not changed:
                break
        return included
     
    result = stepwise_selection(exog, endog)
     
    print('resulting features:')
    print(result)

    lr = sm.Logit(endog,sm.add_constant(exog[result]))
    rst = lr.fit()
    print(rst.summary2())

    y_predicted = rst.predict(sm.add_constant(exog[result]))

    fpr, tpr, thresholds = roc_curve(endog,y_predicted, pos_label=1)
    auc_score = auc(fpr,tpr)
    w = tpr - fpr
    ks_score = w.max()
    ks_x = fpr[w.argmax()]
    ks_y = tpr[w.argmax()]
    fig,ax = plt.subplots()
    ax.plot(fpr,tpr,label='AUC=%.5f'%auc_score)
    ax.set_title('Receiver Operating Characteristic')
    ax.plot([0, 1], [0, 1], '--', color=(0.6, 0.6, 0.6))
    ax.plot([ks_x,ks_x], [ks_x,ks_y], '--', color='red')
    ax.text(ks_x,(ks_x+ks_y)/2,'  KS=%.5f'%ks_score)
    ax.legend()
    fig.show()  

    展开全文
  • R语言多元Logistic逻辑回归 应用案例

    万次阅读 2019-06-14 15:00:55
    可以使用阶梯函数通过逐步过程确定多重逻辑回归。此函数选择模型以最小化AIC,而不是像手册中的SAS示例那样根据p值。另请注意,在此示例中,步骤函数找到了与“ 手册”中的过程不同的模型。 通常建议不要盲目地遵循...

    原文链接http://tecdat.cn/?p=2640  

    原文出处:拓端数据部落公众号

     

    可以使用逐步回归过程确定多元逻辑回归。此函数选择模型以最小化AIC。

    如何进行多元逻辑回归

    可以使用step函数通过逐步回归过程确定多元逻辑回归。此函数选择模型以最小化AIC。

    通常建议不要盲目地遵循逐步回归程序,而是要使用拟合统计(AIC,AICc,BIC)比较模型,或者根据生物学或科学上合理的可用变量建立模型。

    多元相关是研究潜在自变量之间关系的一种工具。例如,如果两个独立变量彼此相关,可能在最终模型中都不需要这两个变量,但可能有理由选择一个变量而不是另一个变量。

    多元相关

    创建数值变量的数据框

    
    
    Data.num $ Status = as.numeric(Data.num $ Status)
    
    Data.num $ Length = as.numeric(Data.num $ Length)
    
    Data.num $ Migr = as.numeric(Data.num $ Migr)
    
    Data.num $ Insect = as.numeric(Data.num $ Insect)
    
    Data.num $ Diet = as.numeric(Data.num $ Diet)
    
    Data.num $ Broods = as.numeric(Data.num $ Broods)
    
    Data。 num $ Wood = as.numeric(Data.num $ Wood)
    
    Data.num $ Upland = as.numeric(Data.num $ Upland)
    
    Data.num $ Water = as.numeric(Data.num $ Water)
    
    Data.num $ Release = as.numeric(Data.num $ Release)
    
    Data.num $ Indiv = as.numeric(Data.num $ Indiv)
    
    ###检查新数据框
    
    headtail(Data.num)
    
    1 1 1520 9600.0 1.21 1 12 2 6.0 1 0 0 1 6 29
    
    2 1 1250 5000.0 0.56 1 0 1 6.0 1 0 0 1 10 85
    
    3 1 870 3360.0 0.07 1 0 1 4.0 1 0 0 1 3 8
    
    77 0 170 31.0 0.55 3 12 2 4.0 NA 1 0 0 1 2
    
    78 0 210 36.9 2.00 2 8 2 3.7 1 0 0 1 1 2
    
    79 0 225 106.5 1.20 2 12 2 4.8 2 0 0 0 1 2
    
    ###检查变量之间的相关性
    
    ###这里使用了Spearman相关性
     

    多元逻辑回归的例子

    在此示例中,数据包含缺失值。在R中缺失值用NA表示。SAS通常会无缝地处理缺失值。虽然这使用户更容易,但可能无法确保用户了解这些缺失值的作用。在某些情况下,R要求用户明确如何处理缺失值。处理多元回归中的缺失值的一种方法是从数据集中删除具有任何缺失值的所有观察值。这是我们在逐步回归过程之前要做的事情,创建一个名为Data.omit的数据框。但是,当我们创建最终模型时,我们只想排除那些在最终模型中实际包含的变量中具有缺失值的观察样本。为了测试最终模型的整体p值,绘制最终模型,或使用glm.compare函数,我们将创建一个名为Data.final的数据框,只排除那些观察结果。

    尽管二项式和poission分布中的模型应该没问题,但是对于使用某些glm拟合的步骤过程存在一些注意事项。

    用逐步回归确定模型

    最终模型

    summary(model.final)
    
    
    Coefficients:
    
                  Estimate Std. Error z value Pr(>|z|)   
    
    (Intercept) -3.5496482  2.0827400  -1.704 0.088322 . 
    
    Upland      -4.5484289  2.0712502  -2.196 0.028093 * 
    
    Migr        -1.8184049  0.8325702  -2.184 0.028956 * 
    
    Mass         0.0019029  0.0007048   2.700 0.006940 **
    
    Indiv        0.0137061  0.0038703   3.541 0.000398 ***
    
    Insect       0.2394720  0.1373456   1.744 0.081234 . 
    
    Wood         1.8134445  1.3105911   1.384 0.166455   

     

    伪R方

    $Pseudo.R.squared.for.model.vs.null
    
                                 Pseudo.R.squared
    
    McFadden                             0.700475
    
    Cox and Snell (ML)                   0.637732
    
    Nagelkerke (Cragg and Uhler)         0.833284

     

    模型总体p值

    在最终模型中创建包含变量的数据框,并省略NA。

    偏差表分析

     

    Analysis of Deviance Table
    
     
    
    Model 1: Status ~ Upland + Migr + Mass + Indiv + Insect + Wood
    
    Model 2: Status ~ 1
    
      Resid. Df Resid. Dev Df Deviance  Pr(>Chi)   
    
    1        63     30.392                         
    
    2        69     93.351 -6  -62.959 1.125e-11 ***

    似然比检验

     

    Likelihood ratio test
    
     
    
      #Df  LogLik Df  Chisq Pr(>Chisq)   
    
    1   7 -15.196                        
    
    2   1 -46.675 -6 62.959  1.125e-11 ***

     

    标准化残差图

    简单的预测值图

    在最终模型中创建包含变量的数据框,并在NA中省略

    过度离散检验

    过度离散是glm的deviance残差相对于自由度较大的情况。这些值显示在模型的摘要中。一个指导原则是,如果deviance残差与剩余自由度的比率超过1.5,则模型过度离散。过度离散表明模型不能很好地拟合数据:解释变量可能无法很好地描述因变量,或者可能无法为这些数据正确指定模型。如果存在过度离散,一种可能的解决方案是 在glm中使用quasibinomial family选项。

     

    Null deviance: 93.351  on 69  degrees of freedom
    
    Residual deviance: 30.392  on 63  degrees of freedom
    
    deviance /   df.residual
    
     
    
    [1] 0.482417

     

    评估模型的替代方法

    使用逐步回归程序的替代或补充是将模型与拟合统计进行比较。我的compare.glm 函数将为glm模型显示AIC,AICc,BIC和伪R平方。使用的模型应该都拟合相同的数据。也就是说,如果数据集中的不同变量包含缺失值,则应该谨慎使用。如果您对使用哪种拟合统计数据没有任何偏好,您希望在最终模型中使用较少的项,我可能会推荐AICc或BIC。

    一系列模型可以与标准的anova 进行比较。模型应嵌套在先前模型中或anova函数列表中的下一个模型中; 和模型应该拟合相同的数据。在比较多个回归模型时,通常放宽p值为0.10或0.15。

    在以下示例中,使用通过逐步回归过程选择的模型。请注意,虽然模型9最小化了AIC和AICc,但模型8最小化了BIC。anova结果表明模型8不是对模型7的显着改进。这些结果支持选择模型7,8或9中的任何一个。  

     

    compareGLM(model.1, model.2, model.3, model.4, model.5, model.6,
               model.7, model.8, model.9)
    
     
    
    $Models
    
      Formula                                                  
    
    1 "Status ~ 1"                                             
    
    2 "Status ~ Release"                                       
    
    3 "Status ~ Release + Upland"                               
    
    4 "Status ~ Release + Upland + Migr"                       
    
    5 "Status ~ Release + Upland + Migr + Mass"                
    
    6 "Status ~ Release + Upland + Migr + Mass + Indiv"        
    
    7 "Status ~ Release + Upland + Migr + Mass + Indiv + Insect"
    
    8 "Status ~ Upland + Migr + Mass + Indiv + Insect"         
    
    9 "Status ~ Upland + Migr + Mass + Indiv + Insect + Wood"  
    
     
    
    $Fit.criteria
    
      Rank Df.res   AIC  AICc   BIC McFadden Cox.and.Snell Nagelkerke   p.value
    
    1    1     66 94.34 94.53 98.75   0.0000        0.0000     0.0000       Inf
    
    2    2     65 62.13 62.51 68.74   0.3787        0.3999     0.5401 2.538e-09
    
    3    3     64 56.02 56.67 64.84   0.4684        0.4683     0.6325 3.232e-10
    
    4    4     63 51.63 52.61 62.65   0.5392        0.5167     0.6979 7.363e-11
    
    5    5     62 50.64 52.04 63.87   0.5723        0.5377     0.7263 7.672e-11
    
    6    6     61 49.07 50.97 64.50   0.6118        0.5618     0.7588 5.434e-11
    
    7    7     60 46.42 48.90 64.05   0.6633        0.5912     0.7985 2.177e-11
    
    8    6     61 44.71 46.61 60.14   0.6601        0.5894     0.7961 6.885e-12
    
    9    7     60 44.03 46.51 61.67   0.6897        0.6055     0.8178 7.148e-12
    
    
    Analysis of Deviance Table
    
     
    
    Model 1: Status ~ 1
    
    Model 2: Status ~ Release
    
    Model 3: Status ~ Release + Upland
    
    Model 4: Status ~ Release + Upland + Migr
    
    Model 5: Status ~ Release + Upland + Migr + Mass
    
    Model 6: Status ~ Release + Upland + Migr + Mass + Indiv
    
    Model 7: Status ~ Release + Upland + Migr + Mass + Indiv + Insect
    
    Model 8: Status ~ Upland + Migr + Mass + Indiv + Insect
    
    Model 9: Status ~ Upland + Migr + Mass + Indiv + Insect + Wood
    
     
    
      Resid. Df Resid. Dev Df Deviance Pr(>Chi)   
    
    1        66     90.343                        
    
    2        65     56.130  1   34.213 4.94e-09 ***
    
    3        64     48.024  1    8.106 0.004412 **
    
    4        63     41.631  1    6.393 0.011458 * 
    
    5        62     38.643  1    2.988 0.083872 . 
    
    6        61     35.070  1    3.573 0.058721 . 
    
    7        60     30.415  1    4.655 0.030970 * 
    
    8        61     30.710 -1   -0.295 0.587066   
    
    9        60     28.031  1    2.679 0.101686

     

     


    最受欢迎的见解

    1.matlab中的偏最小二乘回归(PLSR)和主成分回归(PCR)

    2.R语言多元Logistic逻辑回归 应用案例

    3.R语言面板平滑转移回归(PSTR)分析案例实现

    4.R语言回归中的Hosmer-Lemeshow拟合优度检验

    5.R语言泊松Poisson回归模型分析案例

    6.r语言中对LASSO回归,Ridge岭回归和Elastic Net模型实现

    7.R语言如何在生存分析与Cox回归中计算IDI,NRI指标

    8.在R语言中实现Logistic逻辑回归

    9.R语言实现向量自回归VAR模型

     

    展开全文
  • 本文主要介绍了逻辑回归的评价指标和逻辑回归中常用的三种变量筛选方法,并介绍了三种变量筛选方法的原理及运行效率问题,在文章最后给出了一种基于AIC评价指标的逐步回归的Python实现。
  • 我们之前说到了逻辑回归的分类,主要是二值分类的情况,通过训练权值来获得两个类别的分界线。而线性回归模型用于拟合现有的数据用来进行预测,回归的目的是预测数值型的目标值。这里我们为了拟合现有的数据训练出的...
  • logistic回归分析matlab代码逻辑回归-机器学习 ...在其中一个实验室中,我们在Octave中实现了逻辑回归,因此以该示例为例,对算法进行了逐步分析,并在python中实现。 用于统计分析和绘图- 用于开发算法的软件工具用
  • 1、逻辑回归定义事件发生的概率为 其中: 因此对于输入x分类结果为类别1和类别0的概率分别为: (1)式综合起来可以写成: 取似然函数为: 对数似然函数为: 实际求解中通常取 -2...
  • EDA和胫骨数据的逻辑回归 在“ titanic”数据集上逐步进行探索性数据分析,Logistic回归模型构建和模型评估。
  • 回归算法有很多,比如:线性回归、Logistic回归、多项式回归、逐步回归、令回归、Lasso回归等。我们常用Logistic回归模型做预测。通常,Logistic回归用于二分类问题,例如预测明天是否会下雨。当然它也可以用于多...
  • 目前,回归诊断不仅用于一般线性模型的诊断,还被逐步推广...如何处理从逻辑回归中得到的残差图? 为了更好地理解,让我们考虑以下数据集 glm(Y~X1+X2,family=binomial) 如果我们使用R的诊断图,第一个是残差..
  • 梯度下降法,就是利用负梯度方向来决定每次迭代的新的搜索方向,使得每次迭代能使待优化的目标函数逐步减小。 梯度下降法是2范数下的最速下降法。 最速下降法的一种简单形式是:x(k+1)=x(k)-a*g(k),其中a称为学习...
  •   分类问题:逻辑回归 第 3 周任务   分类问题:支持向量机 第 4 周任务   分类问题:AdaBoost 第 5 周任务   回归问题:线性回归、岭回归、套索方法、逐步回归等   回归问题:树回归 第 6 周任务   ...
  • 逐步回归[根据Pearson的相关关系最好地执行]->使用了12个非侵入性变量的子集,其对数值取代了白蛋白,胆红素和protime 线性回归 套索 随机森林 为了预测患者的生存状态,我们使用以下模型: 逻辑回归 随机森林[根据...
  • 逐步回归法3.随机森林法(RF)4.挑选变量总结三、带权重的逻辑回归模型四、代码实现 引言    一、逻辑回归概述   从概率的角度来看:“逾期”是一个随机事件,可以用伯努利分布来刻画它的随机性。伯努利分布是一...
  • 逻辑回归模型的一般步骤 一.数据的整理 1.根据业务对字段进行删除、清洗等预处理 2.构建数据集:Y的属性—>【违约,不违约,不清楚】 用于建模的数据集:违约和不违约【70%为训练集】 用于测试的数据集:违约和不...
  • 本篇内容是建立一个逻辑回归分类器来识别猫,逐步了解神经网络,并进一步的认识深度学习。 需要使用到的包(Packages) NumPy:Python 的科学计算包 H5py:与 H5 文件进行交互的软件包 Matplotlib:Python 中著名的...
  • 使用R语言对"教师经济信息"进行逻辑回归分析  (1)按3:1的比例采用简单随机抽样方法,创建训练集和测试集  (2)用训练集创建逻辑回归模型  (3)用测试集预测贷款结果,并用table统计分类的最终结果  ...
  • 回归算法

    2019-04-10 10:13:19
    5.逻辑回归逻辑回归并不是回归算法,而是分类算法) 6.多项式回归 7.逐步回归 8.岭回归 9.Lasso回归 10.ElasticNet回归 什么是回归分析? 回归分析是研究自变量和因变量之间关系的一种预测模型技术。...
  • 回归分析

    2021-05-01 08:59:31
    回归分析 回归分析是一种预测性的建模技术,它研究的是因变量(目标)和自变量(预测器)之间的...Logistic Regression逻辑回归 Polynomial Regression多项式回归 Stepwise Regression逐步回归 Ridge Regression岭回归
  • 美赛快速复习之回归

    2021-01-26 21:20:06
    逐步回归、一元线性回归、多元线性回归、非线性回归、高斯回归分析、自回归、岭回归、lasso回归、逻辑回归、生存回归、弹性回归 线性回归(Linear Regression) 逻辑回归(Logistic Regression) 多项式回归...
  • 七种回归

    2017-09-12 21:45:04
    内容什么是回归分析我们为什么要用回归分析回归有哪些类型线性回归逻辑回归多项式回归逐步回归岭回归LASSO回归ElasticNet回归如何去选择回归模型参考介绍  根据受欢迎程度,线性回归和逻辑回归经常是我们做预测模型...
  • 七种回归技术

    2018-03-17 20:13:34
    摘要:本文解释了回归分析及其优势,重点总结了应该掌握的线性回归、逻辑回归、多项式回归、逐步回归、岭回归、套索回归、ElasticNet回归等七种最常用的回归技术及其关键要素,最后介绍了选择正确的回归模型的关键...
  • MATLAB脚本,逐步引导您完成逻辑回归 ex2 reg.m-Octave / MATLAB脚本,可逐步引导您进行正则化Logistic回归 ex2data1.txt-Logistic回归的训练集 ex2data2.txt-正则逻辑回归的训练集 mapFeature.m-生成多项式特征的...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 193
精华内容 77
关键字:

逐步回归逻辑回归