精华内容
下载资源
问答
  • 弹性网回归分类
    千次阅读 多人点赞
    2020-10-24 09:53:48

    在线性大型数据集包含的变量数量大于样本数量的情况下,标准线性模型(或普通的最小二乘法)的效果较差。

    更好的替代方法是``惩罚回归'',可以通过在方程中添加约束来创建线性惩罚模型,该模型因变量过多而受到惩罚(James et al. 2014,P. Bruce and Bruce (2017)) 。这也称为收缩或调整方法。

    施加此惩罚的结果是将系数值减小(即缩小)为零。这允许贡献较小的变量具有接近零或等于零的系数。

    注意,收缩要求选择确定收缩量的调整参数(λ)。

    在本章中,我们将介绍最常用的惩罚回归方法,包括岭回归,套索回归和弹性净回归。我们还将在R中提供实用示例。

    Table of Contents

    收缩方法

    岭回归

    Lasso回归

    弹性网络回归

    加载R包

    准备数据

    计算惩戒线性回归

    准备数据

    R函数

    计算岭回归

    计算lasso回归

    计算弹性网络回归

    模型比较


    收缩方法

    岭回归

    岭回归缩小了回归系数,因此对结果影响较小的变量的系数接近零。系数的缩小是通过使用称为L2-正则化的惩罚项对回归模型进行惩罚来实现的,该惩罚项是系数平方的总和。

    可以使用称为lambda(λ)的常量微调惩罚量。为λ选择一个合适的值至关重要。当λ=0时,惩罚项无效,岭回归将产生经典的最小二乘系数。但是,随着λ增大到无穷大,收缩罚分的影响增大,并且岭回归系数将接近于零。

    请注意,与普通的最小二乘回归相比,岭回归受预测变量的规模影响很大。因此,最好在应用岭回归之前对预测变量进行标准化(即缩放)(James et al.2014),以使所有预测变量处于相同规模。

    可以使用公式x'= x / sd(x)来实现预测变量x的标准化,其中sd(x)是x的标准偏差。这样的结果是,所有标准化预测变量的标准偏差都将为一,从而使最终拟合不依赖于预测变量的度量范围。

    与普通的最小二乘方法(第@ref(linear-regression)章)相比,脊回归的一个重要优点是在具有大量预测变量(p )大于观察次数(n)。

    岭回归的一个缺点是它将包含最终模型中的所有预测变量,这与逐步回归方法(第@ref(stepwise-regression))不同,后者通常会选择涉及变量减少的模型。

    岭回归将系数缩小为零,但不会将其中的任何一个都精确设置为零。套索回归是克服此缺点的替代方法。

    Lasso回归

    LASSO代表最小绝对收缩和选择算符。它通过使用称为L1-正则化的惩罚项惩罚回归模型来将回归系数缩小为零,这是绝对系数的总和。在套索回归的情况下,惩罚具有迫使一些系数估计(对于模型的贡献很小)正好等于零的效果。这意味着,套索还可被视为执行变量选择以降低模型复杂性的子集选择方法的替代方法。

    就像在岭回归中一样,为套索选择一个好的λ值至关重要。

    套索回归相对于岭回归的一个明显优势是,它可以生成更简单,更易解释的模型,其中仅包含一组减少的预测变量。但是,无论是岭回归还是套索都不会普遍主导对方。

    通常,套索在某些预测变量系数较大而其余预测变量系数很小的情况下可能会表现更好。当结果是许多预测变量的函数时,岭回归将表现更好,所有预测变量的系数都大致相等(James et al.2014)。

    交叉验证方法可用于识别这两种技术中的哪一种在特定数据集上更好。

    弹性网络回归

    Elastic Net生成了一个回归模型,该模型同时受L1范数和L2范数的影响。 这样的结果是有效地缩小系数(如在岭回归中)并将某些系数设置为零(如在LASSO中)。

    加载R包

    • tidyverse -数据集操作及可视化
    • caret -机器学习流程
    • glmnet-建立惩罚方程
    library(tidyverse)
    library(caret)
    library(glmnet)

    准备数据

    # Load the data
    data("Boston", package = "MASS")
    # Split the data into training and test set
    set.seed(123)
    training.samples <- Boston$medv %>%
      createDataPartition(p = 0.8, list = FALSE)
    train.data  <- Boston[training.samples, ]
    test.data <- Boston[-training.samples, ]

    计算惩戒线性回归

    准备数据

    • y 结局变量
    • x 预测变量。这应该使用model.matrix()函数创建,该函数可以将任何分类变量自动转换为虚拟变量,这很重要,因为glmnet()仅可以 接受数字,定量输入。 创建模型矩阵后,我们删除索引= 1处的截距分量。
    # Predictor variables
    x <- model.matrix(medv~., train.data)[,-1]
    # Outcome variable
    y <- train.data$medv

    R函数

    使用 glmnet()函数构建惩戒方程 [glmnet包]

    glmnet(x, y, alpha = 1, lambda = NULL)
    • x: 预测变量矩阵
    • y: 二分类结局变量
    • alpha: 弹性网络混合系数. 
      • 1: Lasso回归
      • 0: 岭回归 
      • 0 ~ 1 :弹性网络回归
    • lamba: 收缩系数,需自定

    在惩罚回归中,您需要指定一个常数λ来调整系数收缩量。 可以将最适合您数据的lambda定义为使交叉验证预测错误率最小化的lambda。 这可以使用cv.glmnet()函数自动确定。

    在以下各节中,我们首先计算岭,套索和弹性网回归模型。 接下来,我们将比较不同的模型,以便为我们的数据选择最佳模型。

    最好的模型定义为预测误差最低的模型RMSE。

    计算岭回归

    # Find the best lambda using cross-validation
    set.seed(123) 
    cv <- cv.glmnet(x, y, alpha = 0)
    # Display the best lambda value
    cv$lambda.min
    ## [1] 0.758
    # Fit the final model on the training data
    model <- glmnet(x, y, alpha = 0, lambda = cv$lambda.min)
    # Display regression coefficients
    coef(model)
    ## 14 x 1 sparse Matrix of class "dgCMatrix"
    ##                    s0
    ## (Intercept)  28.69633
    ## crim         -0.07285
    ## zn            0.03417
    ## indus        -0.05745
    ## chas          2.49123
    ## nox         -11.09232
    ## rm            3.98132
    ## age          -0.00314
    ## dis          -1.19296
    ## rad           0.14068
    ## tax          -0.00610
    ## ptratio      -0.86400
    ## black         0.00937
    ## lstat        -0.47914
    # Make predictions on the test data
    x.test <- model.matrix(medv ~., test.data)[,-1]
    predictions <- model %>% predict(x.test) %>% as.vector()
    # Model performance metrics
    data.frame(
      RMSE = RMSE(predictions, test.data$medv),
      Rsquare = R2(predictions, test.data$medv)
    )
    ##   RMSE Rsquare
    ## 1 4.98   0.671

    请注意,默认情况下,函数glmnet()标准化变量,以便它们的大小可比。 但是,系数始终以原始比例返回。

    计算lasso回归

    用于岭回归的R代码之间的唯一区别是,对于套索回归,需要指定参数alpha = 1而不是alpha = 0(对于岭回归)。

    # Find the best lambda using cross-validation
    set.seed(123) 
    cv <- cv.glmnet(x, y, alpha = 1)
    # Display the best lambda value
    cv$lambda.min
    ## [1] 0.00852
    # Fit the final model on the training data
    model <- glmnet(x, y, alpha = 1, lambda = cv$lambda.min)
    # Dsiplay regression coefficients
    coef(model)
    ## 14 x 1 sparse Matrix of class "dgCMatrix"
    ##                    s0
    ## (Intercept)  36.90539
    ## crim         -0.09222
    ## zn            0.04842
    ## indus        -0.00841
    ## chas          2.28624
    ## nox         -16.79651
    ## rm            3.81186
    ## age           .      
    ## dis          -1.59603
    ## rad           0.28546
    ## tax          -0.01240
    ## ptratio      -0.95041
    ## black         0.00965
    ## lstat        -0.52880
    # Make predictions on the test data
    x.test <- model.matrix(medv ~., test.data)[,-1]
    predictions <- model %>% predict(x.test) %>% as.vector()
    # Model performance metrics
    data.frame(
      RMSE = RMSE(predictions, test.data$medv),
      Rsquare = R2(predictions, test.data$medv)
    )
    ##   RMSE Rsquare
    ## 1 4.99   0.671

    计算弹性网络回归

    我们使用caret包自动选择最佳的调整参数alpha和lambda。 caret程序包测试了一系列可能的alpha和lambda值,然后选择了lambda和alpha的最佳值,从而生成了最终模型,即弹性网模型。

    在这里,我们将测试10个不同的alpha和lambda值的组合。 使用选项tuneLength指定,最佳的alpha和lambda值是那些使交叉验证误差最小的值。

    # Build the model using the training set
    set.seed(123)
    model <- train(
      medv ~., data = train.data, method = "glmnet",
      trControl = trainControl("cv", number = 10),
      tuneLength = 10
    )
    # Best tuning parameter
    model$bestTune
    ##   alpha lambda
    ## 6   0.1   0.21
    # Coefficient of the final model. You need
    # to specify the best lambda
    coef(model$finalModel, model$bestTune$lambda)
    ## 14 x 1 sparse Matrix of class "dgCMatrix"
    ##                     1
    ## (Intercept)  33.04083
    ## crim         -0.07898
    ## zn            0.04136
    ## indus        -0.03093
    ## chas          2.34443
    ## nox         -14.30442
    ## rm            3.90863
    ## age           .      
    ## dis          -1.41783
    ## rad           0.20564
    ## tax          -0.00879
    ## ptratio      -0.91214
    ## black         0.00946
    ## lstat        -0.51770
    # Make predictions on the test data
    x.test <- model.matrix(medv ~., test.data)[,-1]
    predictions <- model %>% predict(x.test)
    # Model performance metrics
    data.frame(
      RMSE = RMSE(predictions, test.data$medv),
      Rsquare = R2(predictions, test.data$medv)
    )
    ##   RMSE Rsquare
    ## 1 4.98   0.672

    模型比较

    不同模型的性能指标具有可比性。 使用LASSO或弹性网络回归将预测变量年龄的系数设置为零,从而导致与包含所有预测变量的岭回归相比更简单的模型。在我们的示例中,我们可以选择套索或弹性净回归模型。

    请注意,我们可以使用caret操作流程轻松计算和比较岭,套索和弹性净回归。caret函数将自动选择最佳调整参数值,计算最终模型并使用交叉验证技术评估模型性能。

    使用 caret 包

    1. 设置Lambda值的范围:
    lambda <- 10^seq(-3, 3, length = 100)
    1. 计算岭回归
    # Build the model
    set.seed(123)
    ridge <- train(
      medv ~., data = train.data, method = "glmnet",
      trControl = trainControl("cv", number = 10),
      tuneGrid = expand.grid(alpha = 0, lambda = lambda)
      )
    # Model coefficients
    coef(ridge$finalModel, ridge$bestTune$lambda)
    # Make predictions
    predictions <- ridge %>% predict(test.data)
    # Model prediction performance
    data.frame(
      RMSE = RMSE(predictions, test.data$medv),
      Rsquare = R2(predictions, test.data$medv)
    )
    1. 计算LASSO回归
    # Build the model
    set.seed(123)
    lasso <- train(
      medv ~., data = train.data, method = "glmnet",
      trControl = trainControl("cv", number = 10),
      tuneGrid = expand.grid(alpha = 1, lambda = lambda)
      )
    # Model coefficients
    coef(lasso$finalModel, lasso$bestTune$lambda)
    # Make predictions
    predictions <- lasso %>% predict(test.data)
    # Model prediction performance
    data.frame(
      RMSE = RMSE(predictions, test.data$medv),
      Rsquare = R2(predictions, test.data$medv)
    )
    1. 弹性网络回归
    # Build the model
    set.seed(123)
    elastic <- train(
      medv ~., data = train.data, method = "glmnet",
      trControl = trainControl("cv", number = 10),
      tuneLength = 10
      )
    # Model coefficients
    coef(elastic$finalModel, elastic$bestTune$lambda)
    # Make predictions
    predictions <- elastic %>% predict(test.data)
    # Model prediction performance
    data.frame(
      RMSE = RMSE(predictions, test.data$medv),
      Rsquare = R2(predictions, test.data$medv)
    )
    1. 比较模型性能

    使用caret包比较不同模型性能,最佳模型定义为最小化预测误差的模型。

    models <- list(ridge = ridge, lasso = lasso, elastic = elastic)
    resamples(models) %>% summary( metric = "RMSE")
    ## 
    ## Call:
    ## summary.resamples(object = ., metric = "RMSE")
    ## 
    ## Models: ridge, lasso, elastic 
    ## Number of resamples: 10 
    ## 
    ## RMSE 
    ##         Min. 1st Qu. Median Mean 3rd Qu. Max. NA's
    ## ridge   3.10    3.96   4.38 4.73    5.52 7.43    0
    ## lasso   3.16    4.03   4.39 4.73    5.51 7.27    0
    ## elastic 3.13    4.00   4.37 4.72    5.52 7.32    0
    更多相关内容
  • 线性回归、lasso回归、岭回归以及弹性网络的系统解释声明背景介绍概述线性回归模型函数及损失函数线性回归算法多项式回归(线性回归的推广)广义线性回归(线性回归的推广)岭回归(Ridge回归)lasso回归为什么lasso...

    声明

    本博客集合了网上众多大牛的博客和观点,后面将对主要的引用源进行列举。在此对各位博主大牛表示感谢,若有侵权,请联系我。

    第一次写博客,任何意见,请不吝赐教!

    背景介绍

    线性回归模型的偏回归系数的表达式: θ = ( X ⊺ X ) − 1 X ⊺ Y \theta =(X^\intercal X)^{−1}X^\intercal Y θ=(XX)1XY要能保证该回归系数有解,必须确保XTX矩阵是满秩的,即XTX可逆,但在实际的数据当中,自变量之间可能存在高度自相关性,就会导致偏回归系数无解或结果无效。为了能够克服这个问题,可以根据业务知识,将那些高自相关的变量进行删除;或者选用岭回归也能够避免XTX的不可逆。
    (岭回归的必要性还有为了防止过拟合)

    岭回归一般可以用来解决线性回归模型系数无解的两种情况,一方面是自变量间存在高度多重共线性,另一方面则是自变量个数大于等于观测个数。针对这两种情况,我们不妨设计两个矩阵,来计算一下XTX的行列式。
    比如:第一种矩阵:第一列和第三列存在两倍关系(即多重共线性);第二种矩阵:列数比行数多(非满秩)

    所以,不管是高度多重共线性的矩阵还是列数多于观测数的矩阵,最终算出来的行列式都等于0或者是近似为0,类似于这样的矩阵,都会导致线性回归模型的偏回归系数无解或解无意义(因为矩阵行列式近似为0时,其逆将偏于无穷大,导致回归系数也被放大)。那如何来解决这个问题呢?1970年Heer提出了岭回归方法,非常巧妙的化解了这个死胡同,即在 X ⊺ X X^\intercal X XX的基础上加上一个较小的 α \alpha α扰动 (具体做法是在损失函数中加入了线性回归系数的L2正则项),从而使得行列式不再为0。LASSO回归与岭回归非常类似,不同的是在损失函数中加入了线性回归系数的L1正则项。

    概述

    线性回归问题算是机器学习中最基本的问题了,它主要包含线性回归算法、多项式回归算法(线性回归算法的推广)和广义线性回归(线性回归算法的推广)。
    以线性回归为基础,可以衍生出lasso回归、岭回归和弹性回归。线性回归采用误差平方和来作为损失函数,虽然这种算法简单,但是也会出现过拟合的现象,在线性回归损失函数中加入正则项可以有效地解决过拟合问题;线性回归的损失函数中加入自变量系数向量的L1范数后,线性回归变为lasso回归;线性回归的损失函数中加入自变量系数向量的L2范数后,线性回归变为岭回归(Ridge回归);线性回归的损失函数中加入自变量系数的L1范数和L2范数的结合后,线性回归变为弹性网络(Elastic Net)
    线性回归衍生出的三种回归方法各有优缺点,其详细内容后面会一一介绍。

    线性回归模型函数及损失函数

    线性回归遇到的问题可以做这样的描述,假设我们有m个样本,每个样本 i i i 包含 n n n个特征 x i 1 , x i 2 , . . . , x i n x_{i1},x_{i2},...,x_{in} xi1,xi2,...,xin和一个输出 y i y_i yi,如下: ( x 1 ( 1 ) , x 2 ( 1 ) , . . . , x n ( 1 ) , y 1 ) , ( x 1 ( 2 ) , x 2 ( 2 ) , . . . , x n ( 2 ) , y 2 ) , . . . . . . ( x 1 ( m ) , x 2 ( m ) , . . . , x n ( m ) , y m ) , (x_1^{(1)}, x_2^{(1)}, ...,x_n^{(1)}, y_1),\\(x_1^{(2)}, x_2^{(2)}, ...,x_n^{(2)}, y_2), \\......\\(x_1^{(m)}, x_2^{(m)},...,x_n^{(m)},y_m), (x1(1),x2(1),...,xn(1),y1),(x1(2),x2(2),...,xn(2),y2),......(x1(m),x2(m),...,xn(m),ym),
    我们的问题是,当给定一个新的 ( x 1 ( m + 1 ) , x 2 ( m + 1 ) , . . . , x n ( m + 1 ) (x_1^{(m+1)}, x_2^{(m+1)}, ...,x_n^{(m+1)} (x1(m+1),x2(m+1),...,xn(m+1)时,如何确定其对应的输出 y m + 1 y_{m+1} ym+1呢?如果这个问题中的 y y y 是连续的,那么这是一个回归问题,如果 y y y 是离散的,那么这是一个分类问题。
    对于 n n n维特征的样本数据,如果我们决定使用线性回归,那么对应的模型是这样的:
    h θ ( x 1 , x 2 , . . . , x n ) = θ 0 + θ 1 x 1 + . . . + θ n x n , h_\theta(x_1,x_2,...,x_n)=\theta_0+\theta_1x_1+...+\theta_nx_n, hθ(x1,x2,...,xn)=θ0+θ1x1+...+θnxn,其中 θ i ( i = 0 , 1 , 2... n ) \theta_i (i = 0,1,2... n) θi(i=0,1,2...n)为模型参数, x i ( i = 0 , 1 , 2... n ) x_i (i = 0,1,2... n) xi(i=0,1,2...n)为每个样本的 n n n个特征值。这个表示可以简化,我们增加一个特征 x 0 = 1 x_0=1 x0=1 ,这样
    h θ ( x 0 , x 1 , . . . , x n ) = ∑ i = 0 n θ i x i h_\theta(x_0,x_1,...,x_n)= \sum_{i=0}^n\theta_ix_i hθ(x0,x1,...,xn)=i=0nθixi。进一步用矩阵形式表达更加简洁如下: h θ ( X ) = X θ h_\theta(X)=X\theta hθ(X)=Xθ其中, 假设函数 h θ ( X ) h_\theta(X) hθ(X) m × 1 m\times1 m×1的向量, θ θ θ n × 1 n\times1 n×1的向量,里面有 n n n个代数法的模型参数。 X X X m × n m\times n m×n维的矩阵。 m m m代表样本的个数, n n n代表样本的特征数。
    得到了模型,我们需要求出需要的损失函数,一般线性回归我们用均方误差作为损失函数。损失函数的代数法表示如下: J ( θ 0 , θ 1 , . . . , θ n ) = ∑ i = 1 m ( h θ ( x 0 ( i ) , x 1 ( i ) , . . . x n ( i ) ) − y i ) 2 J(\theta_0,\theta_1,...,\theta_n)=\sum_{i=1}^m(h_\theta(x^{(i)}_0,x^{(i)}_1,...x^{(i)}_n)-y_i)^2 J(θ0,θ1,...,θn)=i=1m(hθ(x0(i),x1(i),...xn(i))yi)2进一步用矩阵形式表达损失函数: J ( θ ) = 1 2 ( X θ − Y ) ⊺ ( X θ − Y ) J(\theta)=\dfrac{1}{2}{(X\theta−Y)}^\intercal(X\theta−Y) J(θ)=21(XθY)(XθY) Y Y Y m × 1 m\times1 m×1维的矩阵,表示输出矩阵,即由 y i ( i = 1 , 2 , . . . , n ) y_i(i=1,2,...,n) yi(i=1,2,...,n)组成的矩阵。由于矩阵法表达比较的简洁,后面我们将统一采用矩阵方式表达模型函数和损失函数。

    线性回归算法

    对于线性回归的损失函数 J ( θ ) = 1 2 ( X θ − Y ) ⊺ ( X θ − Y ) J(\theta)=\dfrac{1}{2}(X\theta−Y)^\intercal(X\theta−Y) J(θ)=21(XθY)(XθY),我们常用的有两种方法来求损失函数最小化时候的 θ \theta θ 参数:一种是梯度下降法,一种是最小二乘法。由于不是本文内容且不影响读者理解线性回归,在此不对梯度下降法和最小二乘法进行详细介绍,若不明白,可以百度,推荐这个网址,梯度下降法最小二乘法
    如果采用梯度下降法,则 θ \theta θ 的迭代公式是这样的: θ = θ − α X ⊺ ( X θ − Y ) \theta=\theta−\alpha X^\intercal(X\theta−Y) θ=θαX(XθY)通过若干次迭代后,我们可以得到最终的θ的结果。
    如果采用最小二乘法,则 θ \theta θ 的结果公式如下: θ = ( X ⊺ X ) − 1 X ⊺ Y \theta=(X^\intercal X)^{−1}X^\intercal Y θ=(XX)1XY当然对于求线性回归的系数,还有其他的常用算法,比如牛顿法和拟牛顿法,不是本文重点,这里不详细描述。

    多项式回归(线性回归的推广)

    回到我们开始的线性模型, h θ ( x 1 , x 2 , . . . , x n ) = θ 0 + θ 1 x 1 + . . . + θ n x n h_θ(x_1,x_2,...,x_n)=θ_0+θ_1x_1+...+θ_nx_n hθ(x1,x2,...,xn)=θ0+θ1x1+...+θnxn, 如果这里不仅仅是 x x x 的一次方,比如增加二次方,那么模型就变成了多项式回归。这里写一个只有两个特征的2次方多项式回归的模型: h θ ( x 1 , x 2 ) = θ 0 + θ 1 x 1 + θ 2 x 2 + θ 3 x 1 2 + θ 4 x 2 2 + θ 5 x 1 x 2 h_θ(x_1,x_2)=θ_0+θ_1x_1+θ_2x_2+θ_3x_1^2+θ_4x_2^2+θ_5x_1x_2 hθ(x1,x2)=θ0+θ1x1+θ2x2+θ3x12+θ4x22+θ5x1x2我们令 x 0 = 1 , x 1 = x 1 , x 2 = x 2 , x 3 = x 1 2 , x 4 = x 2 2 , x 5 = x 1 x 2 x_0=1,x_1=x_1,x_2=x_2,x_3=x_1^2,x_4=x_2^2,x_5=x_1x_2 x0=1,x1=x1,x2=x2,x3=x12,x4=x22,x5=x1x2 ,这样我们就得到了下式: h θ ( x 1 , x 2 ) = θ 0 + θ 1 x 1 + θ 2 x 2 + θ 3 x 3 + θ 4 x 4 + θ 5 x 5 h_θ(x_1,x_2)=θ_0+θ_1x_1+θ_2x_2+θ_3x_3+θ_4x_4+θ_5x_5 hθ(x1,x2)=θ0+θ1x1+θ2x2+θ3x3+θ4x4+θ5x5可以发现,我们又重新回到了线性回归,这是一个五元线性回归,可以用线性回归的方法来完成算法。对于每个二元样本特征 ( x 1 , x 2 ) (x_1,x_2) (x1,x2),我们得到一个五元样本特征 ( 1 , x 1 , x 2 , x 1 2 , x 2 2 , x 1 x 2 ) (1,x_1,x_2,x_1^2,x_2^2,x_1x_2) (1,x1,x2,x12,x22,x1x2),通过这个改进的五元样本特征,我们重新把不是线性回归的函数变回线性回归。

    广义线性回归(线性回归的推广)

    在上一节的线性回归的推广中,我们对样本特征端做了推广,这里我们对于特征 y y y 做推广。比如我们的输出 Y Y Y 不满足和 X X X 的线性关系,但是 ln ⁡ Y \ln Y lnY X X X 满足线性关系,模型函数如下: ln ⁡ Y = X θ \ln Y=X\theta lnY=Xθ这样对与每个样本的输入 y y y,我们用 ln ⁡ y \ln y lny 去对应, 从而仍然可以用线性回归的算法去处理这个问题。我们把 ln ⁡ y \ln y lny 一般化,假设这个函数是单调可微函数 g ( . ) g(.) g(.),则一般化的广义线性回归形式是: g ( Y ) = X θ g(Y)=X\theta g(Y)=Xθ 或者 Y = g − 1 ( X θ ) Y=g^{−1}(X\theta) Y=g1(Xθ)这个函数 g ( . ) g(.) g(.)我们通常称为联系函数, g − 1 ( . ) g^{-1}(.) g1(.) g ( . ) g(.) g(.)反函数

    岭回归(Ridge回归)

    在前面的概述中已经对岭回归(Ridge)和lasso回归的产生背景进行了介绍,本小节将对岭回归的原理进行概述。
    线性回归的L2正则化通常称为Ridge回归,它和一般线性回归的区别是在损失函数上增加了一个L2正则化的项,和Lasso回归的区别是Ridge回归的正则化项是L2范数,而Lasso回归的正则化项是L1范数。具体Ridge回归的损失函数表达式如下: J ( θ ) = 1 2 ( X θ − Y ) ⊺ ( X θ − Y ) + 1 2 α ∣ ∣ θ ∣ ∣ 2 2 J(θ)=\dfrac{1}{2}(Xθ−Y)^\intercal(Xθ−Y)+\dfrac{1}{2}\alpha||\theta||_2^2 J(θ)=21(XθY)(XθY)+21αθ22其中 α \alpha α为常数系数,代表正则化系数,太小就会失去处理过拟合的能力,太大就会因矫正过重而出现欠拟合的现象,需要进行调优。 ∣ ∣ θ ∣ ∣ 2 ||θ||_2 θ2为L2范数。
    Ridge回归在不抛弃任何一个特征的情况下,缩小了回归系数,使得模型相对而言比较的稳定,但和Lasso回归比,这会使得模型的特征留的特别多,模型解释性差。至于为什么会这样,在后面的章节中会讲到。
    Ridge回归的求解比较简单,一般用最小二乘法。这里给出用最小二乘法的矩阵推导形式,和普通线性回归类似。
    令J(θ)的导数为0,得到下式: X ⊺ ( X θ − Y ) + α θ = 0 X^\intercal(Xθ−Y)+\alpha\theta=0 X(XθY)+αθ=0整理即可得到最后的θ的结果: θ = ( X ⊺ X + α E ) − 1 X ⊺ Y \theta=(X^\intercal X+\alpha E)^{−1}X^\intercal Y θ=(XX+αE)1XY其中 E E E为单位矩阵。
    针对 α \alpha α的设置,需要单独提一下,python中有可以辅助设置此参数的库RidgeCV,RidgeCV算法与Ridge算法的损失函数与损失函数的优化方法是一致的,只是在验证方法上有所不同。RidgeCV算法对损失函数的常数系数进行了交叉验证,从而自动选择一个合适的系数。在初始化RidgeCV类时候,我们可以传一组备选的值,10个,100个都可以。RidgeCV类会帮我们选择一个合适的系数。

    lasso回归

    Ridge回归在不抛弃任何一个变量的情况下,缩小了回归系数,使得模型相对而言比较的稳定,但这会使得模型的变量特别多,模型解释性差。有没有折中一点的办法呢?即又可以防止过拟合,同时克服Ridge回归模型变量多的缺点呢?有,这就是下面说的Lasso回归。
     Lasso回归有时也叫做线性回归的L1正则化,和Ridge回归的主要区别就是在正则化项,Ridge回归用的是L2正则化,而Lasso回归用的是L1正则化。Lasso回归的损失函数表达式如下: J ( θ ) = 1 2 n ( X θ − Y ) ⊺ ( X θ − Y ) + α ∣ ∣ θ ∣ ∣ 1 J(\theta)=\dfrac{1}{2n}(X\theta−Y)^\intercal(X\theta−Y)+\alpha||\theta||_1 J(θ)=2n1(XθY)(XθY)+αθ1其中 n n n为样本个数, α \alpha α为常数系数,需要进行调优。 ∣ ∣ θ ∣ ∣ 1 ||\theta||_1 θ1为L1范数。
     
    Lasso回归使得一些系数变小,甚至还是一些绝对值较小的系数直接变为0,因此特别适用于参数数目缩减与参数的选择,因而用来估计稀疏参数的线性模型。
    但是Lasso回归有一个很大的问题,导致我们需要把它单独拎出来讲,就是它的损失函数不是连续可导的,由于L1范数用的是绝对值之和,导致损失函数有不可导的点。也就是说,我们的最小二乘法,梯度下降法,牛顿法与拟牛顿法对它统统失效了。此时我们可以通过坐标轴下降法(coordinate descent)和最小角回归法( Least Angle Regression, LARS)来求有这个L1范数的损失函数极小值。
    使用坐标轴下降法和最小角回归法进行求解的过程可以参考这个网址

    为什么lasso回归容易使得不重要的变量的系数变为0而岭回归却会保留它们

    经过上面的介绍,大家已经对岭回归和lasso回归有了基本的认识。不知大家有没有这个疑问,为什么lasso回归容易使得不重要的变量的系数变为0而岭回归却会保留它们呢?本小节将通过图形来解释。

    假设线性回归模型中只有两个自变量,系数为 β 1 、 β 2 \beta_1、\beta_2 β1β2(等同于上文中 θ 1 、 θ 2 \theta_1、\theta_2 θ1θ2。由于岭回归是在线性回归损失函数中加入了系数的L2正则项,lasso回归是在线性回归损失函数中加入了系数的L1正则项,所以可以得到下图,分别展示了岭回归和lasso回归系数的解,
    在这里插入图片描述
    可以清晰地看到:求解的交点不再是最小二乘的最小值(红点),而变成了与正则项的交点(黄点)。这个区别可以从二维图中更好地观察出来:岭回归中两个图形(没有棱角)的交点永远不会落在两个轴上,而LASSO回归中,正则化的几何图形是有棱角的,可以很好的让交点落在某一个轴上。这种稀疏化的不同也导致了LASSO回归可以用于特征选择(让特征权重变为0从而筛选掉特征),而岭回归却不行。

    弹性网络(Elastic Net)

    介绍完lasso回归和ridge回归,弹性网络就很简单了,损失函数如下: J ( θ ) = 1 2 ( X θ − Y ) ⊺ ( X θ − Y ) + r α ∣ ∣ θ ∣ ∣ 1 + 1 − r 2 α ∣ ∣ θ ∣ ∣ 2 2 J(\theta)=\dfrac{1}{2}(Xθ−Y)^\intercal(Xθ−Y)+r\alpha||\theta||_1+\dfrac{1−r}2\alpha||\theta||_2^2 J(θ)=21(XθY)(XθY)+rαθ1+21rαθ22使用这种方式方法所得到的模型就像纯粹的Lasso回归一样稀疏,但同时具有与岭回归提供的一样的正则化能力。
    弹性网络在很多特征互相联系的情况下是非常有用的。Lasso 很可能只随机考虑这些特征中的一个,而弹性网络更倾向于选择两个,在实践中,Lasso 和 Ridge 之间权衡的一个优势是它允许在循环过程(Under rotate)中继承 Ridge 的稳定性。

    结语

    本文对线性回归及其相关的延伸进行了基础的介绍,可以帮助大家有一个基本的理解,里面有些细节没有深入展开,若有兴趣,读者可通过更专业的资料进行学习。

    参考资料

    1. https://www.cnblogs.com/yongfuxue/p/9971749.html
    2. https://blog.csdn.net/lsxxx2011/article/details/98764995
    3. https://blog.csdn.net/JH_Zhai/article/details/82694937
    4. https://blog.csdn.net/lsxxx2011/article/details/98764594
    5. https://www.cnblogs.com/pinard/p/6004041.html
    6. https://www.cnblogs.com/pinard/p/6018889.html
    展开全文
  • LASSO回归 LASSO是由1996年Robert Tibshirani首次提出,该方法是一种压缩估计。与岭回归类似,LASSO也是通过构造一个惩罚函数得到一个性能更好的模型。相比于岭回归,LASSO更极端。它通过惩罚函数压缩回归系数,使得...

    LASSO回归

    LASSO是由1996年Robert Tibshirani首次提出,该方法是一种压缩估计。与岭回归类似,LASSO也是通过构造一个惩罚函数得到一个性能更好的模型。相比于岭回归,LASSO更极端。它通过惩罚函数压缩回归系数,使得这些回归系数绝对值之和小于某个固定值,甚至将一些重复的没必要的参数直接缩减为0。因此LASSO保留了子集收缩的优点,达到提取有用特征的作用,是一种处理具有复共线性数据的有偏估计。

    LASSO回归与岭回归的模型的区别在于岭回归使用的是L2正则,而LASSO回归使用的是L1正则,其目标函数:
    f ( w ) = 1 2 m ∑ i = 1 m [ ( y i − x i T w ) 2 + λ ∑ j = 1 n ∣ w j ∣ ] f(w) = \frac{1}{2m}\sum_{i=1}^{m}[(y_{i}-x_{i}^{T}w)^{2}+\lambda \sum_{j=1}^{n}\left |w_{j} \right |] f(w)=2m1i=1m[(yixiTw)2+λj=1nwj]

    LASSO算法可以达到变量选择的效果,将不显著的变量系数压缩至0。对于经过数据处理后的变量矩阵,其中有的变量是可以忽略,甚至会影响整体模型效果,因此采用LASSO作为集成模型的基模型很适合。

    弹性网络回归

    弹性网络回归ElasticNet是LASSO回归和岭回归的混合体,是一种同时使用L1和L2先验作为正则化矩阵的线性回归模型。ElasticNet回归适用于存在多个不显著变量的数据,同时还能保持正则化属性。当多个变量与某一变量存在相关关系时,ElasticNet回归模型效果就会比较好。它既能像LASSO回归删除无效变量,同时又能保持岭回归的稳定性。
    ElasticNet回归的目标函数同时包含L1和L2正则项:
    f ( w ) = 1 2 m ∑ i = 1 m [ ( y i − x i T w ) 2 + λ 1 ∑ j = 1 n ∣ w j ∣ + λ 2 ∑ j = 1 n w j 2 ] f(w) = \frac{1}{2m}\sum_{i=1}^{m}[(y_{i}-x_{i}^{T}w)^{2}+\lambda _{1}\sum_{j=1}^{n}\left |w_{j} \right |+\lambda _{2}\sum_{j=1}^{n}w_{j}^{2}] f(w)=2m1i=1m[(yixiTw)2+λ1j=1nwj+λ2j=1nwj2]

    python代码实现

    import numpy as np
    import pandas as pd
    import os
    ''' 
    导入数据
    '''
    file = os.path.abspath(os.path.join(os.getcwd(), ".."))  
    data_file = os.path.join(file, 'data/train.csv')  
    train = pd.read_csv(data_file)
    data_file = os.path.join(file, 'data/test.csv')
    test = pd.read_csv(data_file)
    target_variable = train["y"].values
    del train["y"]
    
    
    from sklearn.model_selection import KFold, cross_val_score
    from sklearn.pipeline import make_pipeline
    from sklearn.linear_model import ElasticNet, Lasso
    from sklearn.preprocessing import RobustScaler
    ''' 
    建模
    '''
    # 定义一个交叉评估函数 Validation function
    n_folds = 5
    def rmsle_cv(model):
        kf = KFold(n_folds, shuffle=True, random_state=42).get_n_splits(train.values)
        rmse= np.sqrt(-cross_val_score(model, train.values, target_variable, scoring="neg_mean_squared_error", cv = kf))
        return(rmse)
    
    # LASSO回归(LASSO Regression)             Lasso score: 0.1101 (0.0058)
    lasso = make_pipeline(RobustScaler(), Lasso(alpha =0.0005, random_state=1))
    score = rmsle_cv(lasso)
    print("\nLasso score: {:.4f} ({:.4f})\n".format(score.mean(), score.std()))
    
    # 弹性网络回归(Elastic Net Regression)    Lasso score: 0.1100 (0.0059)
    ENet = make_pipeline(RobustScaler(), ElasticNet(alpha=0.0005, l1_ratio=.9, random_state=3))
    score = rmsle_cv(ENet)
    print("\nLasso score: {:.4f} ({:.4f})\n".format(score.mean(), score.std()))   
    ''' 
    预测
    '''
    y_train = target_variable
    x_train = train.values   
    lasso .fit(x_train,y_train)
    y = lasso .predict(test.values)
    

    引用

    [1]: Tibshirani R . Regression shrinkage and selection via the lasso: a retrospective[J]. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 2011, 73(3):267-288.
    [2]: Durbin R , Willshaw D . An analogue approach to the travelling salesman problem using an elastic net method[J]. Nature, 1987, 326(6114):689-691.

    展开全文
  • 2、如何实现弹性网络回归?3、如何实施Logistic回归?4、如何理解将线性回归转化为二元分类?上一篇:TensorFlow ML cookbook 第三章4、5节 理解线性回归中的损失函数和实施戴明回归实现套索和岭回归这里也有办法限制...

    问题导读:

    1、如何实现套索和岭回归?

    2、如何实现弹性网络回归?

    3、如何实施Logistic回归?

    4、如何理解将线性回归转化为二元分类?

    forum.php?mod=viewthread&tid=24683

    上一篇:TensorFlow ML cookbook 第三章4、5节 理解线性回归中的损失函数和实施戴明回归

    实现套索和岭回归

    这里也有办法限制系数对回归输出的影响。 这些方法被称为正则化方法,两种最常见的正则化方法是套索和岭回归。 我们介绍如何在这个章节中实现这两个。

    准备好

    除了我们加入正则化项以限制公式中的斜率(或偏斜率)之外,Lasso和岭回归与常规线性回归非常相似。这可能有多种原因,但常见的原因是我们希望限制对因变量有影响的功能。这可以通过向损失函数添加一个项来完成,该项取决于我们的斜率值A。

    对于套索回归,如果斜率A超过某个值,我们必须添加一个可以大大增加损失函数的项。我们可以使用TensorFlow的逻辑运算,但它们没有与它们相关的梯度。相反,我们将使用一个连续的近似步进函数,称为连续重步函数,这个函数被放大并转换到我们选择的正则化截止点。我们将很快展示如何进行套索回归。

    对于岭回归,我们只是给L2范数添加一个项,这是斜率系数的缩放L2范数。这个修改很简单,在这个章节的最后有更多...部分。

    怎么做

    1.我们将再次使用虹膜数据集并以与之前相同的方式设置我们的脚本。 我们首先加载库,启动会话,加载数据,声明批量大小,创建占位符,变量和模型输出,如下所示:

    [mw_shl_code=python,true]import matplotlib.pyplot as plt

    import numpy as np

    import tensorflow as tf

    from sklearn import datasets

    from tensorflow.python.framework import ops

    ops.reset_default_graph()

    sess = tf.Session()

    iris = datasets.load_iris()

    x_vals = np.array([x[3] for x in iris.data])

    y_vals = np.array([y[0] for y in iris.data])

    batch_size = 50

    learning_rate = 0.001

    x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)

    y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

    A = tf.Variable(tf.random_normal(shape=[1,1]))

    b = tf.Variable(tf.random_normal(shape=[1,1]))

    model_output = tf.add(tf.matmul(x_data, A), b)[/mw_shl_code]

    2.我们增加了损失函数,这是一个修改后的连续重度阶梯函数。 我们还将套索回归的截止值设置为0.9。 这意味着我们要限制斜率系数小于0.9。 使用下面的代码:

    [mw_shl_code=python,true]lasso_param = tf.constant(0.9)

    heavyside_step = tf.truediv(1., tf.add(1., tf.exp(tf.mul(-100., tf.sub(A, lasso_param)))))

    regularization_param = tf.mul(heavyside_step, 99.)

    loss = tf.add(tf.reduce_mean(tf.square(y_target - model_output)), regularization_param)[/mw_shl_code]

    3.我们现在初始化我们的变量并声明我们的优化器,如下所示:

    [mw_shl_code=python,true]init = tf.global_variables_initializer()

    sess.run(init)

    my_opt = tf.train.GradientDescentOptimizer(learning_rate)

    train_step = my_opt.minimize(loss) [/mw_shl_code]

    4.我们将再次运行训练循环,因为它可能需要一段时间才能收敛。 我们可以看到斜率系数小于0.9。 使用下面的代码:

    [mw_shl_code=python,true]loss_vec = []

    for i in range(1500):

    rand_index = np.random.choice(len(x_vals), size=batch_size)

    rand_x = np.transpose([x_vals[rand_index]])

    rand_y = np.transpose([y_vals[rand_index]])

    sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})

    temp_loss = sess.run(loss, feed_dict={x_data: rand_x, y_ target: rand_y})

    loss_vec.append(temp_loss[0])

    if (i+1)%300==0:

    print('Step #''' + str(i+1) + ' A = ' + str(sess.run(A)) + ' b = ' + str(sess.run(b)))

    print('Loss = ' + str(temp_loss))

    Step #300 A = [[ 0.82512331]] b = [[ 2.30319238]]

    Loss = [[ 6.84168959]]

    Step #600 A = [[ 0.8200165]] b = [[ 3.45292258]]

    Loss = [[ 2.02759886]]

    Step #900 A = [[ 0.81428504]] b = [[ 4.08901262]]

    Loss = [[ 0.49081498]]

    Step #1200 A = [[ 0.80919558]] b = [[ 4.43668795]]

    Loss = [[ 0.40478843]]

    Step #1500 A = [[ 0.80433637]] b = [[ 4.6360755]]

    Loss = [[ 0.23839757]] [/mw_shl_code]

    怎么运行

    我们通过向线性回归的损失函数添加连续的超重阶跃函数来实现套索回归。 由于阶梯函数的陡峭性,我们必须小心步长。 太大的步长,它不会收敛。 对于岭回归,请参阅下一节中的必要更改。

    还有更多

    对于岭回归,我们将损失函数更改为如下代码所示:

    [mw_shl_code=python,true]ridge_param = tf.constant(1.)

    ridge_loss = tf.reduce_mean(tf.square(A))

    loss = tf.expand_dims(tf.add(tf.reduce_mean(tf.square(y_target - model_output)), tf.mul(ridge_param, ridge_loss)), 0) [/mw_shl_code]

    实现弹性网络回归

    弹性净回归是一种回归方法,它通过在损失函数中加入L1和L2正则化项来将套索回归和岭回归相结合。

    准备好

    在前两个配方之后实现弹性网络回归应该很简单,因此我们将在虹膜数据集上进行多重线性回归,而不是像以前那样坚持二维数据。 我们将使用踏板长度,踏板宽度和萼片宽度来预测萼片长度。

    怎么做

    1.首先我们加载必要的库并初始化一个图,如下所示:

    [mw_shl_code=python,true]import matplotlib.pyplot as plt

    import numpy as np

    import tensorflow as tf

    from sklearn import datasets

    sess = tf.Session() [/mw_shl_code]

    2.现在我们将加载数据。 这一次,x数据的每个元素将是一个三个值的列表,而不是一个。 使用下面的代码:

    [mw_shl_code=python,true]iris = datasets.load_iris()

    x_vals = np.array([[x[1], x[2], x[3]] for x in iris.data])

    y_vals = np.array([y[0] for y in iris.data]) [/mw_shl_code]

    3.接下来我们声明批量大小,占位符,变量和模型输出。 这里唯一的区别是,我们更改了x数据占位符的大小规格以取三个值而不是一个,如下所示:

    [mw_shl_code=python,true]batch_size = 50

    learning_rate = 0.001

    x_data = tf.placeholder(shape=[None, 3], dtype=tf.float32)

    y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

    A = tf.Variable(tf.random_normal(shape=[3,1]))

    b = tf.Variable(tf.random_normal(shape=[1,1]))

    model_output = tf.add(tf.matmul(x_data, A), b) [/mw_shl_code]

    4.对弹性网而言,损失函数具有部分斜率的L1和L2范数。 我们创建这些条款,然后将它们添加到损失函数中,如下所示:

    [mw_shl_code=python,true]elastic_param1 = tf.constant(1.)

    elastic_param2 = tf.constant(1.)

    l1_a_loss = tf.reduce_mean(tf.abs(A))

    l2_a_loss = tf.reduce_mean(tf.square(A))

    e1_term = tf.mul(elastic_param1, l1_a_loss)

    e2_term = tf.mul(elastic_param2, l2_a_loss)

    loss = tf.expand_dims(tf.add(tf.add(tf.reduce_mean(tf.square(y_ target - model_output)), e1_term), e2_term), 0) [/mw_shl_code]

    5.现在我们可以初始化变量,声明我们的优化器,然后运行训练循环并拟合我们的系数,如下所示:

    [mw_shl_code=python,true]init = tf.global_variables_initializer()

    sess.run(init)

    my_opt = tf.train.GradientDescentOptimizer(learning_rate)

    train_step = my_opt.minimize(loss)

    loss_vec = []

    for i in range(1000):

    rand_index = np.random.choice(len(x_vals), size=batch_size)

    rand_x = x_vals[rand_index]

    rand_y = np.transpose([y_vals[rand_index]])

    sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})

    temp_loss = sess.run(loss, feed_dict={x_data: rand_x, y_ target: rand_y})

    loss_vec.append(temp_loss[0])

    if (i+1)%250==0:

    print('Step #' + str(i+1) + ' A = ' + str(sess.run(A)) + ' b = ' + str(sess.run(b)))

    print('Loss = ' + str(temp_loss)) [/mw_shl_code]

    6.这里是代码的输出:

    [mw_shl_code=python,true]Step #250 A = [[ 0.42095602]

    [ 0.1055888 ]

    [ 1.77064979]] b = [[ 1.76164341]]

    Loss = [ 2.87764359]

    Step #500 A = [[ 0.62762028]

    [ 0.06065864]

    [ 1.36294949]] b = [[ 1.87629771]]

    Loss = [ 1.8032167]

    Step #750 A = [[ 0.67953539]

    [ 0.102514 ]

    [ 1.06914485]] b = [[ 1.95604002]]

    Loss = [ 1.33256555]

    Step #1000 A = [[ 0.6777274 ]

    [ 0.16535147]

    [ 0.8403284 ]] b = [[ 2.02246833]]

    Loss = [ 1.21458709] [/mw_shl_code]

    7.现在我们可以观察到训练迭代的损失,以确保它收敛,如下所示:

    [mw_shl_code=python,true]plt.plot(loss_vec, 'k-')

    plt.title('Loss' per Generation')

    plt.xlabel('Generation')

    plt.ylabel('Loss')

    plt.show()[/mw_shl_code]

    6cbb977928e529ff6f0e46249f365cb1.gif

    2018-06-19_145028.png (30.96 KB, 下载次数: 0)

    2018-6-19 14:51 上传

    图10:1000次训练迭代绘制的弹性净回归损失

    怎么运行

    这里实施弹性净回归以及多元线性回归。我们可以看到,在损失函数中使用这些正则化项时,收敛速度比以前的部分慢。正则化就像在损失函数中添加适当的术语一样简单。

    实施Logistic回归

    对于这个配方,我们将实施逻辑回归来预测低出生体重的概率。

    准备好

    逻辑回归是将线性回归转化为二元分类的一种方法。这是通过在一个sigmoid函数中转换线性输出来实现的,该函数将输出在0和1之间进行缩放。目标是0或1,表示数据点是否在一个类中或另一个类中。由于我们预测的是0或1之间的数字,如果预测高于指定的截止值,则预测被分类到类别值1'''中,否则将类别0分类。为了这个例子的目的,我们将指定中断为0.5,这将使分类变得简单,就像对输出进行四舍五入。

    我们将用于这个例子的数据将是通过马萨诸塞大学阿默斯特统计数据库存储库(https://www.umass.edu/statdata/statdata/)获得的低出生体重数据。我们将从其他几个因素预测低出生体重。

    怎么做

    1.我们首先加载库,包括请求库,因为我们将通过超链接访问低出生体重数据。我们也将开始会议:

    [mw_shl_code=python,true]import matplotlib.pyplot as plt

    import numpy as np

    import tensorflow as tf

    import requests

    from sklearn import datasets

    from sklearn.preprocessing import normalize

    from tensorflow.python.framework import ops

    ops.reset_default_graph()

    sess = tf.Session() [/mw_shl_code]

    请注意,在我们缩放数据集之前,我们将数据集分解为训练和测试。 这是一个重要的区别。 我们希望确保训练集完全不影响测试集。 如果我们在分割之前缩放整个集合,那么我们不能保证它们不会相互影响。

    2.接下来,我们将通过请求模块加载数据并指定我们要使用的功能。 我们必须具体,因为一个特征是实际的出生体重,我们不希望用这个来预测出生体重是大于还是小于特定量。 我们也不希望将ID列用作预测因子:

    [mw_shl_code=python,true]birthdata_url = 'https://www.umass.edu/statdata/statdata/data/ lowbwt.dat'

    birth_file = requests.get(birthdata_url)

    birth_data = birth_file.text.split('\r\n')[5:]

    birth_header = [x for x in birth_data[0].split( '') if len(x)>=1]

    birth_data = [[float(x) for x in y.split( '') if len(x)>=1] for y in birth_data[1:] if len(y)>=1]

    y_vals = np.array([x[1] for x in birth_data])

    x_vals = np.array([x[2:9] for x in birth_data]) [/mw_shl_code]

    3.首先我们将数据集分解为测试和训练集:

    [mw_shl_code=python,true]train_indices = np.random.choice(len(x_vals), round(len(x_ vals)*0.8), replace=False)

    test_indices = np.array(list(set(range(len(x_vals))) - set(train_ indices)))

    x_vals_train = x_vals[train_indices]

    x_vals_test = x_vals[test_indices]

    y_vals_train = y_vals[train_indices]

    y_vals_test = y_vals[test_indices]

    [/mw_shl_code]

    4.当特征在0和1之间缩放(最小 - 最大比例缩放)时,Logistic回归收敛效果更好。 接下来我们将扩展每个功能:

    [mw_shl_code=python,true]def normalize_cols(m):

    col_max = m.max(axis=0)

    col_min = m.min(axis=0)

    return (m-col_min) / (col_max - col_min)

    x_vals_train = np.nan_to_num(normalize_cols(x_vals_train))

    x_vals_test = np.nan_to_num(normalize_cols(x_vals_test)) [/mw_shl_code]

    请注意,在我们缩放数据集之前,我们将数据集分解为训练和测试。 这是一个重要的区别。 我们希望确保训练集完全不影响测试集。 如果我们在分割之前缩放整个集合,那么我们不能保证它们不会相互影响。

    5.现在我们可以开始我们的训练循环并记录损失和准确度:

    [mw_shl_code=python,true]loss_vec = []

    train_acc = []

    test_acc = []

    for i in range(1500):

    rand_index = np.random.choice(len(x_vals_train), size=batch_ size)

    rand_x = x_vals_train[rand_index]

    rand_y = np.transpose([y_vals_train[rand_index]])

    sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})

    temp_loss = sess.run(loss, feed_dict={x_data: rand_x, y_ target: rand_y})

    loss_vec.append(temp_loss)

    temp_acc_train = sess.run(accuracy, feed_dict={x_data: x_vals_ train, y_target: np.transpose([y_vals_train])})

    train_acc.append(temp_acc_train)

    temp_acc_test = sess.run(accuracy, feed_dict={x_data: x_vals_ test, y_target: np.transpose([y_vals_test])})

    test_acc.append(temp_acc_test) [/mw_shl_code]

    6.这里是代码来看看损失和准确性的情节:

    [mw_shl_code=python,true]plt.plot(loss_vec, 'k-')

    plt.title('Cross Entropy Loss per Generation')

    plt.xlabel('Generation')

    plt.ylabel('Cross' Entropy Loss')

    plt.show()

    plt.plot(train_acc, 'k-', label='Train Set Accuracy')

    plt.plot(test_acc, 'r--', label='Test Set Accuracy')

    plt.title('Train' and Test Accuracy')

    plt.xlabel('Generation')

    plt.ylabel('Accuracy')

    plt.legend(loc='lower right')

    plt.show()[/mw_shl_code]

    怎么运行

    这是迭代和训练和测试集精度的损失。 由于数据集只有189个观测值,因此数据集的随机分裂会导致列车和测试精度图变化:

    6cbb977928e529ff6f0e46249f365cb1.gif

    2018-06-19_145209.png (62.12 KB, 下载次数: 0)

    2018-6-19 14:53 上传

    图11:在1,500次迭代过程中绘制的交叉熵损失

    6cbb977928e529ff6f0e46249f365cb1.gif

    2018-06-19_145217.png (48.12 KB, 下载次数: 0)

    2018-6-19 14:53 上传

    图12:超过1,500代的测试和训练集精度。

    原文:

    Implementing Lasso and Ridge Regression

    There are also ways to limit the influence of coefficients on the regression output. These methods are called regularization methods and two of the most common regularization methods are lasso and ridge regression. We cover how to implement both of these in this recipe.

    Getting ready

    Lasso and ridge regression are very similar to regular linear regression, except we adding regularization terms to limit the slopes (or partial slopes) in the formula. There may be multiple reasons for this, but a common one is that we wish to restrict the features that have an impact on the dependent variable. This can be accomplished by adding a term to the loss function that depends on the value of our slope, A.

    For lasso regression, we must add a term that greatly increases our loss function if the slope, A, gets above a certain value. We could use TensorFlow's logical operations, but they do not have a gradient associated with them. Instead, we will use a continuous approximation to a step function, called the continuous heavy step function, that is scaled up and over to the regularization cut off we choose. We will show how to do lasso regression shortly.

    For ridge regression, we just add a term to the L2 norm, which is the scaled L2 norm of the slope coefficient. This modification is simple and is shown in the There's more… section at the end of this recipe.

    How to do it…

    1.We will use the iris dataset again and set up our script the same way as before. We first load the libraries, start a session, load the data, declare the batch size, create the placeholders, variables, and model output as follows:

    import matplotlib.pyplot as plt

    import numpy as np

    import tensorflow as tf

    from sklearn import datasets

    from tensorflow.python.framework import ops

    ops.reset_default_graph()

    sess = tf.Session()

    iris = datasets.load_iris()

    x_vals = np.array([x[3] for x in iris.data])

    y_vals = np.array([y[0] for y in iris.data])

    batch_size = 50

    learning_rate = 0.001

    x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)

    y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

    A = tf.Variable(tf.random_normal(shape=[1,1]))

    b = tf.Variable(tf.random_normal(shape=[1,1]))

    model_output = tf.add(tf.matmul(x_data, A), b)

    2.We add the loss function, which is a modified continuous heavyside step function. We also set the cutoff for lasso regression at 0.9. This means that we want to restrict the slope coefficient to be less than 0.9. Use the following code:

    lasso_param = tf.constant(0.9)

    heavyside_step = tf.truediv(1., tf.add(1., tf.exp(tf.mul(-100., tf.sub(A, lasso_param)))))

    regularization_param = tf.mul(heavyside_step, 99.)

    loss = tf.add(tf.reduce_mean(tf.square(y_target - model_output)), regularization_param)

    3.We now initialize our variables and declare our optimizer, as follows:

    init = tf.global_variables_initializer()

    sess.run(init)

    my_opt = tf.train.GradientDescentOptimizer(learning_rate)

    train_step = my_opt.minimize(loss)

    4.We will run the training loop a fair bit longer because it can take a while to converge. We can see that the slope coefficient is less than 0.9. Use the following code:

    loss_vec = []

    for i in range(1500):

    rand_index = np.random.choice(len(x_vals), size=batch_size)

    rand_x = np.transpose([x_vals[rand_index]])

    rand_y = np.transpose([y_vals[rand_index]])

    sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})

    temp_loss = sess.run(loss, feed_dict={x_data: rand_x, y_ target: rand_y})

    loss_vec.append(temp_loss[0])

    if (i+1)%300==0:

    print('Step #''' + str(i+1) + ' A = ' + str(sess.run(A)) + ' b = ' + str(sess.run(b)))

    print('Loss = ' + str(temp_loss))

    Step #300 A = [[ 0.82512331]] b = [[ 2.30319238]]

    Loss = [[ 6.84168959]]

    Step #600 A = [[ 0.8200165]] b = [[ 3.45292258]]

    Loss = [[ 2.02759886]]

    Step #900 A = [[ 0.81428504]] b = [[ 4.08901262]]

    Loss = [[ 0.49081498]]

    Step #1200 A = [[ 0.80919558]] b = [[ 4.43668795]]

    Loss = [[ 0.40478843]]

    Step #1500 A = [[ 0.80433637]] b = [[ 4.6360755]]

    Loss = [[ 0.23839757]]

    How it works…

    We implement lasso regression by adding a continuous heavyside step function to the loss function of linear regression. Because of the steepness of the step function, we have to be careful with the step size. Too big of a step size and it will not converge. For ridge regression, see the necessary change in the next section.

    There's' more…

    For ridge regression, we change the loss function to look like the following code:

    ridge_param = tf.constant(1.)

    ridge_loss = tf.reduce_mean(tf.square(A))

    loss = tf.expand_dims(tf.add(tf.reduce_mean(tf.square(y_target - model_output)), tf.mul(ridge_param, ridge_loss)), 0)

    Implementing Elastic Net Regression

    Elastic net regression is a type of regression that combines lasso regression with ridge regression by adding a L1 and L2 regularization term to the loss function.

    Getting ready

    Implementing elastic net regression should be straightforward after the previous two recipes, so we will implement this in multiple linear regression on the iris dataset, instead of sticking to the two-dimensional data as before. We will use pedal length, pedal width, and sepal width to predict sepal length.

    How to do it…

    1.First we load the necessary libraries and initialize a graph, as follows:

    import matplotlib.pyplot as plt

    import numpy as np

    import tensorflow as tf

    from sklearn import datasets

    sess = tf.Session()

    2.Now we will load the data. This time, each element of x data will be a list of three values instead of one. Use the following code:

    iris = datasets.load_iris()

    x_vals = np.array([[x[1], x[2], x[3]] for x in iris.data])

    y_vals = np.array([y[0] for y in iris.data])

    3.Next we declare the batch size, placeholders, variables, and model output. The only difference here is that we change the size specifications of the x data placeholder to take three values instead of one, as follows:

    batch_size = 50

    learning_rate = 0.001

    x_data = tf.placeholder(shape=[None, 3], dtype=tf.float32)

    y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

    A = tf.Variable(tf.random_normal(shape=[3,1]))

    b = tf.Variable(tf.random_normal(shape=[1,1]))

    model_output = tf.add(tf.matmul(x_data, A), b)

    4.For elastic net, the loss function has the L1 and L2 norms of the partial slopes. We create these terms and then add them into the loss function, as follows:

    elastic_param1 = tf.constant(1.)

    elastic_param2 = tf.constant(1.)

    l1_a_loss = tf.reduce_mean(tf.abs(A))

    l2_a_loss = tf.reduce_mean(tf.square(A))

    e1_term = tf.mul(elastic_param1, l1_a_loss)

    e2_term = tf.mul(elastic_param2, l2_a_loss)

    loss = tf.expand_dims(tf.add(tf.add(tf.reduce_mean(tf.square(y_ target - model_output)), e1_term), e2_term), 0)

    5.Now we can initialize the variables, declare our optimizer, and run the training loop and fit our coefficients, as follows:

    init = tf.global_variables_initializer()

    sess.run(init)

    my_opt = tf.train.GradientDescentOptimizer(learning_rate)

    train_step = my_opt.minimize(loss)

    loss_vec = []

    for i in range(1000):

    rand_index = np.random.choice(len(x_vals), size=batch_size)

    rand_x = x_vals[rand_index]

    rand_y = np.transpose([y_vals[rand_index]])

    sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})

    temp_loss = sess.run(loss, feed_dict={x_data: rand_x, y_ target: rand_y})

    loss_vec.append(temp_loss[0])

    if (i+1)%250==0:

    print('Step #' + str(i+1) + ' A = ' + str(sess.run(A)) + ' b = ' + str(sess.run(b)))

    print('Loss = ' + str(temp_loss))

    6.Here is the output of the code:

    Step #250 A = [[ 0.42095602]

    [ 0.1055888 ]

    [ 1.77064979]] b = [[ 1.76164341]]

    Loss = [ 2.87764359]

    Step #500 A = [[ 0.62762028]

    [ 0.06065864]

    [ 1.36294949]] b = [[ 1.87629771]]

    Loss = [ 1.8032167]

    Step #750 A = [[ 0.67953539]

    [ 0.102514 ]

    [ 1.06914485]] b = [[ 1.95604002]]

    Loss = [ 1.33256555]

    Step #1000 A = [[ 0.6777274 ]

    [ 0.16535147]

    [ 0.8403284 ]] b = [[ 2.02246833]]

    Loss = [ 1.21458709]

    7.Now we can observe the loss over the training iterations to be sure that it converged, as follows:

    plt.plot(loss_vec, 'k-')

    plt.title('Loss' per Generation')

    plt.xlabel('Generation')

    plt.ylabel('Loss')

    plt.show()

    6cbb977928e529ff6f0e46249f365cb1.gif

    2018-06-19_145028.png (30.96 KB, 下载次数: 3)

    2018-6-19 14:55 上传

    Figure 10: Elastic net regression loss plotted over the 1,000 training iterations

    How it works…

    Elastic net regression is implemented here as well as multiple linear regression. We can see that with these regularization terms in the loss function the convergence is slower than in prior sections. Regularization is as simple as adding in the appropriate terms in the loss functions.

    Implementing Logistic Regression

    For this recipe, we will implement logistic regression to predict the probability of low birthweight.

    Getting ready

    Logistic regression is a way to turn linear regression into a binary classification. This is accomplished by transforming the linear output in a sigmoid function that scales the output between zero and 1. The target is a zero or 1, which indicates whether or not a data point is in one class or another. Since we are predicting a number between zero or 1, the prediction is classified into class value 1''' if the prediction is above a specified cut off value and class 0 otherwise. For the purpose of this example, we will specify that cut off to be 0.5, which will make the classification as simple as rounding the output.

    The data we will use for this example will be the low birthweight data that is obtained through the University of Massachusetts Amherst statistical dataset repository (https://www. umass.edu/statdata/statdata/). We will be predicting low birthweight from several other factors.

    How to do it…

    1.We start by loading the libraries, including the request library, because we will access the low birth weight data through a hyperlink. We will also initiate a session:

    import matplotlib.pyplot as plt

    import numpy as np

    import tensorflow as tf

    import requests

    from sklearn import datasets

    from sklearn.preprocessing import normalize

    from tensorflow.python.framework import ops

    ops.reset_default_graph()

    sess = tf.Session()

    Note that we split the dataset into train and test before we scaled the dataset. This is an important distinction to make. We want to make sure that the training set does not influence the test set at all. If we scaled the whole set before splitting, then we cannot guarantee that they don't influence each other.

    2.Next we will load the data through the request module and specify which features we want to use. We have to be specific because one feature is the actual birth weight and we don't want to use this to predict if the birthweight is greater or less than a specific amount. We also do not want to use the ID column as a predictor either:

    birthdata_url = 'https://www.umass.edu/statdata/statdata/data/ lowbwt.dat'

    birth_file = requests.get(birthdata_url)

    birth_data = birth_file.text.split('\r\n')[5:]

    birth_header = [x for x in birth_data[0].split( '') if len(x)>=1]

    birth_data = [[float(x) for x in y.split( '') if len(x)>=1] for y in birth_data[1:] if len(y)>=1]

    y_vals = np.array([x[1] for x in birth_data])

    x_vals = np.array([x[2:9] for x in birth_data])

    3.First we split the dataset into test and train sets:

    train_indices = np.random.choice(len(x_vals), round(len(x_ vals)*0.8), replace=False)

    test_indices = np.array(list(set(range(len(x_vals))) - set(train_ indices)))

    x_vals_train = x_vals[train_indices]

    x_vals_test = x_vals[test_indices]

    y_vals_train = y_vals[train_indices]

    y_vals_test = y_vals[test_indices]

    4.Logistic regression convergence works better when the features are scaled between 0 and 1 (min-max scaling). So next we will scale each feature:

    def normalize_cols(m):

    col_max = m.max(axis=0)

    col_min = m.min(axis=0)

    return (m-col_min) / (col_max - col_min)

    x_vals_train = np.nan_to_num(normalize_cols(x_vals_train))

    x_vals_test = np.nan_to_num(normalize_cols(x_vals_test))

    Note that we split the dataset into train and test before we scaled the dataset. This is an important distinction to make. We want to make sure that the training set does not influence the test set at all. If we scaled the whole set before splitting, then we cannot guarantee that they don't influence each other.

    5.Now we can start our training loop and recording the loss and accuracies:

    loss_vec = []

    train_acc = []

    test_acc = []

    for i in range(1500):

    rand_index = np.random.choice(len(x_vals_train), size=batch_ size)

    rand_x = x_vals_train[rand_index]

    rand_y = np.transpose([y_vals_train[rand_index]])

    sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})

    temp_loss = sess.run(loss, feed_dict={x_data: rand_x, y_ target: rand_y})

    loss_vec.append(temp_loss)

    temp_acc_train = sess.run(accuracy, feed_dict={x_data: x_vals_ train, y_target: np.transpose([y_vals_train])})

    train_acc.append(temp_acc_train)

    temp_acc_test = sess.run(accuracy, feed_dict={x_data: x_vals_ test, y_target: np.transpose([y_vals_test])})

    test_acc.append(temp_acc_test)

    6.Here is the code to look at the plots of the loss and accuracies:

    plt.plot(loss_vec, 'k-')

    plt.title('Cross Entropy Loss per Generation')

    plt.xlabel('Generation')

    plt.ylabel('Cross' Entropy Loss')

    plt.show()

    plt.plot(train_acc, 'k-', label='Train Set Accuracy')

    plt.plot(test_acc, 'r--', label='Test Set Accuracy')

    plt.title('Train' and Test Accuracy')

    plt.xlabel('Generation')

    plt.ylabel('Accuracy')

    plt.legend(loc='lower right')

    plt.show()

    How it works…

    Here is the loss over the iterations and train and test set accuracies. Since the dataset is only 189 observations, the train and test accuracy plots will change owing to the random splitting of the dataset:

    6cbb977928e529ff6f0e46249f365cb1.gif

    2018-06-19_145209.png (62.12 KB, 下载次数: 3)

    2018-6-19 14:55 上传

    Figure 11: Cross-entropy loss plotted over the course of 1,500 iterations

    6cbb977928e529ff6f0e46249f365cb1.gif

    2018-06-19_145217.png (48.12 KB, 下载次数: 1)

    2018-6-19 14:56 上传

    Figure 12: Test and train set accuracy plotted over 1,500 generations.

    展开全文
  • 该方法利用SIFT特征描述子构建特征字典,再通过弹性网回归模型求解每个描述子所对应的 稀疏系数向量,最后将目标图像内的稀疏系数向量合并用于分类。与传统的特征袋模型和基于l1范数稀疏编码的特征袋 方法...
  • 正则化路径是针对正则化参数λ的值网格处的套索或弹性网络罚值计算的。该算法速度极快,可以利用输入矩阵中的稀疏性x。它符合线性,逻辑和多项式,泊松和Cox回归模型。可以从拟合模型中做出各种预测。它也可以适合多...
  • 全文链接:http://tecdat.cn/?p=24777 原文出处:拓端数据部落公众号 相关视频:R语言逻辑回归(Logistic回归)模型分类预测病人冠心病风险 逻辑回归Logistic模型原理和R语言分类预测冠心病风险实例 ,时长06:48 ...
  • 有许多开源软件包可以训练逻辑回归模型,但是我们找不到能够满足我们技术要求的扩展软件包。 因此,我们编写了自己的。 产品要求和挑战 (Product Requirements and Challenges) At Xandr, the combination of our ...
  • 交叉验证和自举弹性网惩罚回归 创建者:Federico Calesella,Silvia Cazzetta,Federica Colombo和Benedetta Vai IRCCS圣拉斐尔科学研究所神经科学系精神病学和临床心理生物学部门,意大利米兰 目录 1.项目概述 该...
  • 运用逻辑回归进行二分类及多分类

    千次阅读 2020-04-16 19:30:11
    逻辑回归知识要点一、逻辑回归模型模型简介:算法的分类思想算法模型sigmoid函数函数原型sigmoid函数图像参数求解二、逻辑回归实现二分类模型训练与预测结果可视化计算概率值绘制决策边界三、逻辑回归实现多分类建模...
  • 基于自适应弹性网络回归的目标跟踪(OBJECT TRACKING WITH ADAPTIVE ELASTIC NET REGRESSION)阅读笔记 摘要 近年来,各种基于回归的跟踪方法取得了很大的成功,然而,在大多数方法中,提取的所有特征都是用来表示...
  • Encog是一个先进的机器学习框架,使用来创建神经网络,这章重点在回归分类和聚类,最后,这章也展示了怎样创建一个能够学习XOR操作的Encog应用程序。回归神经网络接受输入和产生一个数值型输出,分类神经网络接受...
  • 机器学习-回归分类、聚类1.是什么?2.一些基础概念(建议先看具体例子再返过来看概念)mse均方误差、r2等等衡量标准过拟合和欠拟合方差var和偏差bias3.按照标签的多少和有无来分类:3.1.监督学习回归一次方线性...
  • 基于周志华老师的《机器学习》、上一篇学习笔记以及网络的其他资料,对线性模型的这一部分内容进行一个总结。上接:机器学习:线性模型学习总结(1)...用于分类:sklearn.linear_model.LogisticRegression penalty正.
  • 文章目录回归算法-线性回归分析线性模型线性回归损失函数(误差大小)最小二乘法之正规方程(不做要求)最小...Ridge分类算法-逻辑回归逻辑回归公式逻辑回归的损失函数、优化(了解)sklearn 逻辑回归APILogisticRegres
  • 我们将介绍spark在ml包中封装的逻辑回归Elastic Net,通过配置可以灵活的同时使用L1和L2,或者其一,同时根据正则化选择使用L-BFGS或OWLQN优化。本文是其中的第二篇,介绍模型训练。
  • spark mllib源码分析之逻辑回归弹性网络ElasticNet(二) spark源码分析之L-BFGS spark mllib源码分析之OWLQN spark中的online均值/方差统计 spark源码分析之二分类逻辑回归evaluation spark正则化 spark在ml包...
  • 我们将介绍spark在ml包中封装的逻辑回归Elastic Net,通过配置可以灵活的同时使用L1和L2,或者其一,同时根据正则化选择使用L-BFGS或OWLQN优化。本文是其中的第一篇,介绍模型训练,预测中使用的一些辅助类。
  • 逻辑回归matlab代码开发和测试弹性网逻辑回归免疫细胞分类器 该存储库提供了在Torang等人的研究中开发的代码。 “一种弹性网逻辑回归方法,可以为免疫细胞和T辅助细胞亚型的类型生成分类器和基因签名” 。 相应的...
  • 机器学习中的分类模型和回归模型

    千次阅读 2018-06-20 16:34:44
    机器学习中的分类模型 1.KNN 2.感知机 3.朴素贝叶斯法 4.决策树 5.逻辑斯谛回归模型 6.SVM 7.AdaBoost 8.随机森林 9.贝叶斯网络 10.神经网络 机器学习中的回归模型 1.线性回归 2.多项式回归 3.岭...
  • 对机器学习算法-Logistic回归进行总结,包括原理详解和sklearn的实现
  • 最近在使用pyspark来进行spark编程,之前对这个没有了解过,所以接下来需要多花点时间学习这个模块了,今天主要是简单地基于官方给出来实例来实践一下逻辑回归分类模型,pyspark提供的逻辑回归分类模型主要包括:二...
  •   AdaBoost.R2算法是当前AdaBoost实现流程中使用最多的回归类实践方式,它囊括了对数据进行有放回抽样、按损失函数结果调整样本权重、自动计算弱分类器权重、并输出预测结果等AdaBoost算法经典的全流程。...
  • 你应该掌握的 7 种回归模型!

    万次阅读 多人点赞 2018-07-19 21:26:56
    线性回归和逻辑回归通常是人们学习预测模型的第一个算法。由于这二者的知名度很大,许多分析人员以为它们就是回归的唯一形式了。而了解更多的学者会知道它们是所有回归模型的主要两种形式。 事实是有很多种回归形式...
  • import numpy as np import matplotlib as mpl ...比如将特征提取、归一化、分类组织在一起形成一个典型的机器学习问题工作流 from sklearn.linear_model.coordinate_descent import ConvergenceWarning
  • 回归分析(Regression Analysis)-定义与分类回归分析(Regression Analysis)是一种统计学上分析数据的方法,目的在于了解两个或多个变数间是否相关、相关方向与强度,并建立数学模型以便观察特定变数来预测研究者感...
  • 上一篇文章说到,我们可以用线性回归做预测,但显然现实生活中不止有预测的问题还有分类的问题。我们可以从预测值的类型上简单区分:连续变量的预测为回归,离散变量的预测为分类。 一、逻辑回归:二分类 1.1 理解...
  • 本文是机器学习系列的第三篇,算上前置机器学习系列是第八篇。本文的概念相对简单,主要侧重于代码实践。上一篇文章说到,我们可以用线性回归做预测,但显然现实生活中不止有预测的问题还有分类的问题。...
  • 复习回归模型

    2021-09-19 10:22:28
    回归模型(regression model)对统计关系进行定量描述的一种数学模型。 回归模型是一种预测性的建模技术,它研究的是因变量(目标)和自变量(预测器)之间的关系。这种技术通常用于预测分析,时间序列模型以及发现...
  • 分类分类:from sklearn.model_selection import train_test_splitfrom sklearn.svm import SVCimport mglearn.datasetsimport matplotlib.pyplot as plt#forge数据集是一个二维二分类数据集X,y=mglearn.tools....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,017
精华内容 2,006
关键字:

弹性网回归分类