岭回归 订阅
岭回归(英文名:ridge regression, Tikhonov regularization)是一种专用于共线性数据分析的有偏估计回归方法,实质上是一种改良的最小二乘估计法,通过放弃最小二乘法的无偏性,以损失部分信息、降低精度为代价获得回归系数更为符合实际、更可靠的回归方法,对病态数据的拟合要强于最小二乘法。 展开全文
岭回归(英文名:ridge regression, Tikhonov regularization)是一种专用于共线性数据分析的有偏估计回归方法,实质上是一种改良的最小二乘估计法,通过放弃最小二乘法的无偏性,以损失部分信息、降低精度为代价获得回归系数更为符合实际、更可靠的回归方法,对病态数据的拟合要强于最小二乘法。
信息
别    称
脊回归
提出者
Andrey Tikhonov
应用学科
数据分析, 机器学习, 统计学习
中文名
岭回归
适用领域范围
统计学
外文名
ridge regression, Tikhonov regularization
岭回归简介
岭回归,又称脊回归、吉洪诺夫正则化(Tikhonov regularization),是对不适定问题(ill-posed problem)进行回归分析时最经常使用的一种正则化方法。 [1] 
收起全文
精华内容
下载资源
问答
  • 常见的回归:线性回归、岭回归、非线性回归 回归拟合目标:计算自变量与因变量关系的函数参数 通过不断拟合缩小预测值与真实值的差距:最终使得这个差距(误差项)成为一组均值为0,方差为1的随机数。 2、损失函数 ...
  • 这段代码实现了 Kernel Ridge Regression,只需运行 main.m,还有一个函数可以生成一些多项式玩具数据并将数据随机划分为训练和验证数据。 创建一个 KernelRidgeRegression 对象并生成预测。 使用的内核包括线性、...
  • 高斯内核可以更改为任何所需的内核。 然而,这样的改变不会显着改善结果。 这是使用核技巧(Mercers Theorem)的岭回归的变体。
  • 代码功能介绍在《初探 岭回归 LASSO回归 (python 实现)》中有详细的介绍,文章中若有不正确的,也希望能够不吝赐教,相互学习。
  • 线性回归的改进-岭回归 文章源代码下载地址:波士顿房价岭回归正则化预测代码实现 文章目录线性回归的改进-岭回归1.API2.观察正则化程度的变化,对结果的影响?3.波士顿房价正则化预测代码4.结果 1.API sklearn....
  • 上篇论文中用到的重要stata命令,包括lasso岭回归、插值法、赫芬达尔赫希曼指数的测算等
  • eviews岭回归

    2019-03-22 18:21:26
    岭回归的eviews的算法,以及岭参数的确定,检验等等。
  • 岭回归 岭回归(Ridge Regression), 在最小二乘估计问题的基础上,向离差平方和增加了一个L2范数的惩罚项,即, min⁡w∥Xw−y∥22+α∥w∥22\mathop{\min}\limits_{w} \| Xw-y\|_2^2+\alpha\|w\|_2^2wmin​∥Xw−y∥...
  • 这个包里面涵盖了很多现在主流的一些关于岭回归的论文集合,对算法研究十分全面
  • 岭回归 python class

    2016-05-23 19:09:28
    运用python编写的岭回归,封装成了class
  • 也有些正则方法可以限制回归算法输出结果中系数的影响,其中最常用的两种正则方法是lasso回归和岭回归。 lasso回归和岭回归算法跟常规线性回归算法极其相似,有一点不同的是,在公式中增加正则项来限制斜率(或者净...
  • 岭回归分析0 载入库1 数据预处理2 普通线性回归和岭回归2.1 最小二乘法,参数估计2.2 岭回归,参数估计,固定岭参数2.3 岭回归,按 CV 标准自动选择岭参数2.4 列举岭参数的值,计算回归参数,画出岭迹图,计算 VIF ...
  • 在这里,我们修改了 4 种流行的分类/回归算法的目标函数,并提供了逻辑回归、岭回归、SVM 和 SVR 的特征加权版本,所有这些都适用于线性情况。 SVM 和 SVR 基于我们修改过的 liblinear 工具箱,它包含在这个包中。 ...
  • 包含了线性回归无法进行时所引出的岭回归和LASSO回归,使用python实现,其中文件路径可以根据自己路径修改,或者使用os库来写入相对路径
  • eviews与岭回归

    2015-06-28 23:16:05
    eviews与岭回归,非常好的一个资源,论文经常用得到
  • 岭回归代码

    2016-11-06 14:41:37
    coursera华盛顿大学机器学习专项第二门课第四周习题
  • 岭回归

    万次阅读 2018-12-19 17:56:58
    一、满秩矩阵 设A是n阶矩阵, 若r(A) = n, 则称A为满秩矩阵。但满秩不局限于n阶矩阵。 若矩阵秩等于行数,称为行满秩;...这里先介绍下数据的中心化和标准化,在回归问题和一些机器学习算法中通常...

    一、满秩矩阵
    设A是n阶矩阵, 若r(A) = n, 则称A为满秩矩阵。但满秩不局限于n阶矩阵。
    若矩阵秩等于行数,称为行满秩;若矩阵秩等于列数,称为列满秩。既是行满秩又是列满秩则为n阶矩阵即n阶方阵。行满秩矩阵就是行向量线性无关,列满秩矩阵就是列向量线性无关;所以如果是方阵,行满秩矩阵与列满秩矩阵是等价的。·
    二、中心化和标准化
    这里先介绍下数据的中心化和标准化,在回归问题和一些机器学习算法中通常要对原始数据进行中心化和标准化处理,也就是需要将数据的均值调整到0,标准差调整为1, 计算过程很简单就是将所有数据减去平均值后再除以标准差:
    在这里插入图片描述
    这样调整后的均值:
    在这里插入图片描述
    调整后的标准差:
    在这里插入图片描述
    之所以需要进行中心化其实就是个平移过程,将所有数据的中心平移到原点。而标准化则是使得所有数据的不同特征都有相同的尺度Scale, 这样在使用梯度下降法以及其他方法优化的时候不同特征参数的影响程度就会一致了。
    三、岭回归
    标准最小二乘法优化问题:
    在这里插入图片描述
    也可以通过矩阵表示:
    在这里插入图片描述

    得到回归系数为:
    在这里插入图片描述
    若给定数据集X,如果XTX的逆存在,可以使用常规的线性回归方法。但是,

    (1)数据样本数比特征数少的情况,矩阵的逆不能直接计算;

    (2)即使样本数多于特征数,若特征高度相关,XTX的逆依然无法计算。

    此时,可以考虑岭回归。
    在最小二乘估计的基础上,岭回归增加了一项,称为岭回归估计:
    在这里插入图片描述
    此时求解的式子变成了:
    在这里插入图片描述
    其中新增的最后一项称为惩罚函数。
    在这里插入图片描述

    进一步,这个问题又可以转化成:
    在这里插入图片描述
    相当于在最小二乘法的基础上添加了对参数β的约束。岭参数λ接近0时,岭回归变为最小二乘法;岭参数λ变大时,参数β趋近于0。
    三、岭回归代码

    为了使用岭回归和缩减技术,首先需要对特征做标准化处理。因为,我们需要使每个维度特征具有相同的重要性。本文使用的标准化处理比较简单,就是将所有特征都减去各自的均值并除以方差。
    代码很简单,只需要稍做修改,其中,λ为模型的参数。
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述

    import numpy as np
    
    
    def loadDataSet(fileName):
    """
    加载数据
    :param fileName: 文件名
    :return: 
     xArr - x数据集
    yArr - y数据集
    """
    numFeat = len(open(fileName).readline().split('\t')) - 1
    xArr = [] 
    yArr = []
    f = open(fileName)
    for line in f.readlines():
        lineArr =[]
        curLine = line.strip().split('\t')
        for i in range(numFeat):
            lineArr.append(float(curLine[i]))
        xArr.append(lineArr)
        yArr.append(float(curLine[-1]))
    return xArr, yArr
    def ridgeRegres(xMat, yMat, lam = 0.2):
    """
     岭回归
    :param xMat: x数据集
    :param yMat: y数据集
    :param lam: 缩减系数
    :return: 
      ws - 回归系数
    """
    xTx = xMat.T * xMat
    denom = xTx + np.eye(np.shape(xMat)[1]) * lam
    if np.linalg.det(denom) == 0.0:
        print("矩阵为奇异矩阵,不能转置")
        return
    ws = denom.I * (xMat.T * yMat)
    return ws
    
    • mean() 函数定义:
      numpy.mean(a, axis, dtype, out,keepdims )

    mean()函数功能:求取均值
    经常操作的参数为axis,以m * n矩阵举例:

    axis 不设置值,对 mn 个数求均值,返回一个实数
    axis = 0:压缩行,对各列求均值,返回 1
    n 矩阵
    axis =1 :压缩列,对各行求均值,返回 m *1 矩阵

    • mean在数组中的操作
      在这里插入图片描述在这里插入图片描述在这里插入图片描述

    • mean在矩阵中的操作
      在这里插入图片描述

    • var()函数:
      def var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue):
      对于二维矩阵,axis的值可以是0也可以是1,其中axis=0表示按列求平均,当axis=1表示按行求平均,未给出axis则表示将所有元素加起来求平均。
      在这里插入图片描述
      数据集ex1.txt
      在这里插入图片描述根据数据集求得的ws如下:
      在这里插入图片描述
      所以在岭回归中初始回归系数矩阵写成: wMat = np.zeros((numTestPts, np.shape(xMat)[1]))

       def ridgeTest(xArr, yArr):
       """
       岭回归测试函数
      :param xArr: x数据集
       :param yArr: y数据集
       :return: 
        wMat - 回归系数矩阵
       """
       xMat = np.mat(xArr); yMat = np.mat(yArr).T
       #数据标准化
       yMean = np.mean(yMat, axis = 0)                        #求每列均值
       yMat = yMat - yMean                                    #数据减去均值
       xMeans = np.mean(xMat, axis = 0)                    #求每列均值
       xVar = np.var(xMat, axis = 0)                        #求每列方差
       xMat = (xMat - xMeans) / xVar                        #数据减去均值除以方差实现标准化
       numTestPts = 30                                        #30个不同的lambda测试
       wMat = np.zeros((numTestPts, np.shape(xMat)[1]))    #初始回归系数矩阵
       for i in range(numTestPts):                            #改变lambda计算回归系数
           ws = ridgeRegres(xMat, yMat, np.exp(i - 10))    #lambda以e的指数变化,最初是一个非常小的数,
           wMat[i, :] = ws.T                                 #计算回归系数矩阵
       return wMat
      

    四、前向逐步线性回归
    前向逐步线性回归算法属于一种贪心算法,即每一步都尽可能减少误差。我们计算回归系数,不再是通过公式计算,而是通过每次微调各个回归系数,然后计算预测误差。那个使误差最小的一组回归系数,就是我们需要的最佳回归系数。

    import numpy as np
    def loadDataSet(fileName):
        """
        加载数据
        :param fileName: 文件名
        :return:
         xArr - x数据集
        yArr - y数据集
        """
        numFeat = len(open(fileName).readline().split('\t')) - 1
        xArr = []
        yArr = []
        fr = open(fileName)
        for line in fr.readlines():
            lineArr =[]
            curLine = line.strip().split('\t')
            for i in range(numFeat):
                lineArr.append(float(curLine[i]))
            xArr.append(lineArr)
            yArr.append(float(curLine[-1]))
        return xArr, yArr
    
    
    def regularize(xMat, yMat):
        """
        函数说明:数据标准化
        Parameters:
            xMat - x数据集
            yMat - y数据集
        Returns:
            inxMat - 标准化后的x数据集
            inyMat - 标准化后的y数据集
        """
        inxMat = xMat.copy()  # 数据拷贝
        inyMat = yMat.copy()
        yMean = np.mean(yMat, 0)  # 行与行操作,求均值
        inyMat = yMat - yMean  # 数据减去均值
        inMeans = np.mean(inxMat, 0)  # 行与行操作,求均值
        inVar = np.var(inxMat, 0)  # 行与行操作,求方差
        inxMat = (inxMat - inMeans) / inVar  # 数据减去均值除以方差实现标准化
        return inxMat, inyMat
    
    
    def rssError(yArr, yHatArr):
        """
        计算平方误差
        Parameters:yArr - 预测值
        Parameters:yHatArr - 真实值
    
        Returns:
    
        """
        return ((yArr - yHatArr) ** 2).sum()
    
    	def stageWise(xArr, yArr, eps=0.01, numIt=100):
        """
        前向逐步线性回归
        Parameters:xArr - x输入数据
        Parameters:yArr - y预测数据
        Parameters:eps - 每次迭代需要调整的步长
        Parameters:numIt - 迭代次数
        Returns:
    
        """
        xMat = np.mat(xArr)
        yMat = np.mat(yArr).T  # 数据集
        xMat, yMat = regularize(xMat, yMat)  # 数据标准化
        m, n = np.shape(xMat)
        returnMat = np.zeros((numIt, n))  # 初始化numIt次迭代的回归系数矩阵
        ws = np.zeros((n, 1))  # 初始化回归系数矩阵
        wsTest = ws.copy()
        wsMax = ws.copy()
        for i in range(numIt):  # 迭代numIt次
            print(ws.T)                                                                    #打印当前回归系数矩阵
            lowestError = float('inf');  # 正无穷
            for j in range(n):  # 遍历每个特征的回归系数
                for sign in [-1, 1]:
                    wsTest = ws.copy()
                    wsTest[j] += eps * sign  # 微调回归系数
                    yTest = xMat * wsTest  # 计算预测值
                    rssE = rssError(yMat.A, yTest.A)  # 计算平方误差
                    if rssE < lowestError:  # 如果误差更小,则更新当前的最佳回归系数
                        lowestError = rssE
                        wsMax = wsTest
            ws = wsMax.copy()
            returnMat[i, :] = ws.T  # 记录numIt次迭代的回归系数矩阵
        return returnMat
    

    在这里插入图片描述可以看到,有些系数从始至终都是约为0的,这说明它们不对目标造成任何影响,也就是说这些特征很可能是不需要的。逐步线性回归算法的优点在于它可以帮助人们理解有的模型并做出改进。当构建了一个模型后,可以运行该算法找出重要的特征,这样就有可能及时停止对那些不重要特征的收集。
    五、预测乐高玩具套件的价格
    使用岭回归,通过交叉验证,找到使误差最小的λ对应的回归系数。
    在这里插入图片描述numpy中np.nonzero()函数可参考:https://blog.csdn.net/u013698770/article/details/54632047

    def crossValidation(xArr, yArr, numVal=10):                                                                        
        """                                                                                                            
        函数说明:交叉验证岭回归                                                                                                   
        Parameters:                                                                                                    
            xArr - x数据集                                                                                                
            yArr - y数据集                                                                                                
            numVal - 交叉验证次数                                                                                            
        Returns:                                                                                                       
            wMat - 回归系数矩阵                                                                                              
                                                                                                                       
        """                                                                                                            
        m = len(yArr)  # 统计样本个数                                                                                        
        indexList = list(range(m))  # 生成索引值列表                                                                          
        errorMat = np.zeros((numVal, 30))  # create error mat 30columns numVal rows                                    
        for i in range(numVal):  # 交叉验证numVal次                                                                         
            trainX = [];                                                                                               
            trainY = []  # 训练集                                                                                         
            testX = [];                                                                                                
            testY = []  # 测试集                                                                                          
            random.shuffle(indexList)  # 打乱次序                                                                          
            for j in range(m):  # 划分数据集:90%训练集,10%测试集                                                                  
                if j < m * 0.9:                                                                                        
                    trainX.append(xArr[indexList[j]])                                                                  
                    trainY.append(yArr[indexList[j]])                                                                  
                else:                                                                                                  
                    testX.append(xArr[indexList[j]])                                                                   
                    testY.append(yArr[indexList[j]])                                                                   
            wMat = ridgeTest(trainX, trainY)  # 获得30个不同lambda下的岭回归系数                                                   
            for k in range(30):  # 遍历所有的岭回归系数                                                                          
                matTestX = np.mat(testX);                                                                              
                matTrainX = np.mat(trainX)  # 测试集                                                                      
                meanTrain = np.mean(matTrainX, 0)  # 测试集均值                                                             
                varTrain = np.var(matTrainX, 0)  # 测试集方差                                                               
                matTestX = (matTestX - meanTrain) / varTrain  # 测试集标准化                                                 
                yEst = matTestX * np.mat(wMat[k, :]).T + np.mean(trainY)  # 根据ws预测y值                                   
                errorMat[i, k] = rssError(yEst.T.A, np.array(testY))  # 统计误差                                           
        meanErrors = np.mean(errorMat, 0)  # 计算每次交叉验证的平均误差                                                             
        minMean = float(min(meanErrors))  # 找到最小误差                                                                     
        bestWeights = wMat[np.nonzero(meanErrors == minMean)]  # 找到最佳回归系数                                              
        xMat = np.mat(xArr);                                                                                           
        yMat = np.mat(yArr).T                                                                                          
        meanX = np.mean(xMat, 0);                                                                                      
        varX = np.var(xMat, 0)                                                                                         
        unReg = bestWeights / varX  # 数据经过标准化,因此需要还原                                                                   
        print('%f%+f*年份%+f*部件数量%+f*是否为全新%+f*原价' % (                                                                    
        (-1 * np.sum(np.multiply(meanX, unReg)) + np.mean(yMat)), unReg[0, 0], unReg[0, 1], unReg[0, 2], unReg[0, 3])) 
    

    更多内容可参考:https://www.jianshu.com/p/9d14c3c34a0c

    展开全文
  • Julia 中的岭回归和分类: using Ridge, Vega n, p = 1_000, 1_000 X = randn(p, n) beta = randn(p) y = X' * beta + randn(n) beta_hat = ridge_regression(X, y, lambda = 1.0) cor(beta, beta_hat) plot(x = ...
  • Matlab的耳语基于快速核学习识别LncRNA-蛋白质与核岭回归的相互作用 关于 我们通过使用内核岭回归与多核学习方法,开发了一种新的lncRNAs-蛋白质相互作用(LPIs)预测方法。 输出包含五个文件,分别名为bench_auc....
  • 岭回归应用实例

    2013-11-21 11:56:12
    matlab 数据挖掘 课后作业 岭回归作用于多元线性回归模型 岭回归函数另附
  • matlab中岭回归的实现,分析financial distress数据库中的误差和MSPE,可视化
  • 此提交实现了岭回归工具,即使预测变量 (p) 的数量大于样本数量 (n),该工具也能有效工作。 此外,它还实现了: * 使用最小消息长度和修正的 AIC 搜索最佳正则化参数*生成正则化路径* 拟合具有指定正则化参数或指定...
  • 岭回归代码,有源代码和实例文件,钻石数据库
  • 机器学习岭回归思维导图学习法pdf:详细介绍岭回归各个步骤(建立计算矩阵-幂函数,计算回归系数,训练,预测),并提供具体算例。
  • 岭回归-回归实操

    千次阅读 2021-01-21 15:06:37
    python 岭回归算法之回归实操 基本概念 正则化 正则化是指对模型做显式约束,以避免过拟合。本文用到的岭回归就是L2正则化。(从数学的观点来看,岭回归惩罚了系数的L2范数或w的欧式长度) 正则化的具体原理就不在...

    python 岭回归算法之回归实操

    基本概念

    正则化

    正则化是指对模型做显式约束,以避免过拟合。本文用到的岭回归就是L2正则化。(从数学的观点来看,岭回归惩罚了系数的L2范数或w的欧式长度)

    正则化的具体原理就不在这里多叙述了,感兴趣的朋友可以看一下这篇文章:机器学习中正则化项L1和L2的直观理解

    算法简介

    岭回归

    岭回归也是一种用于回归的线性模型,因此它的模型公式与最小二乘法的相同,如下式所示:

    y=w[0]*x[0]+w[1]*x[1]+w[2]x[2]+…+w[p]x[p]+b

    但在岭回归中,对系数w的选择不仅要在训练数据上得到很好的预测结果,而且还要拟合附加约束。换句话说,w的所有元素都应接近于0。直观上来看,这意味着每个特征对输出的影响应尽可能小(即斜率很小),同时仍给出很好的预测结果,这个约束也就是正则化

    数据来源

    波士顿房价:https://www.kaggle.com/altavish/boston-housing-dataset
    也是非常经典的一个数据
    在这里插入图片描述

    简单解释一下这个数据的几个主要指标:
    ZN:25,000平方英尺以上的土地划为住宅用地的比例。
    RM:每个住宅的平均房间数。
    AGE:1940年之前建造的自有住房的比例
    CHAS:有没有河流经过 (如果等于1,说明有,等于0就说明没有)
    CRIM:犯罪率
    MEDV:住房的价格
    其它指标就不用说了,都是一些住房的其它指标,感兴趣的小伙伴可以自己查一下。

    数据挖掘

    1.导入第三方库

    import pandas as pd
    import numpy as np
    import winreg
    from sklearn.model_selection import train_test_split
    from sklearn.linear_model import Ridge###导入岭回归算法
    from sklearn.metrics import r2_score
    

    老规矩,上来先依次导入建模需要的各个模块
    2.读取文件

    import winreg
    real_address = winreg.OpenKey(winreg.HKEY_CURRENT_USER,r'Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders',)
    file_address=winreg.QueryValueEx(real_address, "Desktop")[0]
    file_address+='\\'
    file_origin=file_address+"\\源数据-分析\\HousingData.csv"#设立源数据文件的桌面绝对路径
    house_price=pd.read_csv(file_origin)#https://www.kaggle.com/altavish/boston-housing-dataset
    

    因为之前每次下载数据之后都要将文件转移到python根目录里面,或者到下载文件夹里面去读取,很麻烦。所以我通过winreg库,来设立绝对桌面路径,这样只要把数据下载到桌面上,或者粘到桌面上的特定文件夹里面去读取就好了,不会跟其它数据搞混。
    其实到这一步都是在走流程,基本上每个数据挖掘都要来一遍,没什么好说的。

    3.清洗数据
    1.查找缺失值
    在这里插入图片描述

    可以看到这个数据并包括一些缺失值,并不是很多,所以直接删掉就好了。

    house_price1=house_price.dropna().reset_index()
    del house_price1["index"]
    

    2.突变值查找

    在这里插入图片描述
    一般是看看特征值里面是否包含等于零的数据。其实说的直接一点就是看看数据里面是否包含不符合实际的数值,比如像是犯罪率,实际中不可能出现犯罪率等于0的片区。那么从上面的结果来看,这份数据并没有其它问题。
    这份数据里面的ZN和CHAS都是利用0和1来当作一种指标,所以包含0是很正常的。
    4.建模

    train=house_price1.drop(["MEDV"],axis=1)
    X_train,X_test,y_train,y_test=train_test_split(train,house_price1["MEDV"],random_state=1)
    #将MEDV划分为预测值,其它的属性划分为特征值,并将数据划分成训练集和测试集。
    ridge=Ridge(alpha=10)#确定约束参数
    ridge.fit(X_train,y_train)
    print("岭回归训练模型得分:"+str(r2_score(y_train,ridge.predict(X_train))))#训练集
    print("岭回归待测模型得分:"+str(r2_score(y_test,ridge.predict(X_test))))#待测集
    

    引入ridge算法,进行建模后,对测试集进行精度评分,得到的结果如下:
    在这里插入图片描述

    可以看到,该模型的训练精度为79%左右,对于新的数据来说,模型精度在63%左右。
    至此,这个数据集的将建模就算是完成了。

    讨论

    1.参数的讨论

    由于岭回归与线性回归(最小二乘法)的模型公式是一样的,所以这里我们与线性回归做一个比较。不了解线性回归的朋友可以看一下我的另一篇文章:最小二乘算法之回归实操
    在这里插入图片描述

    之前我们设立的约束参数是10,而上面模型参数设的是0,可以看出模型的训练精度有所提高,但泛化能力有所降低。同时与线性回归模型相比,二者的分数是完全一样的。所以,当岭回归的约束参数设为0时,失去约束的岭回归与普通最小二乘法就是同一个算法。

    2.与普通最小二乘法的比较

    我们通过变换约束参数的取值,来具体看一下岭回归与普通最小二乘法的优缺点。

    result_b=pd.DataFrame(columns=["参数","岭回归训练模型得分","岭回归待测模型得分","线性回归训练模型得分","线性回归待测模型得分"])
    train=house_price1.drop(["MEDV"],axis=1)
    X_train,X_test,y_train,y_test=train_test_split(train,house_price1["MEDV"],random_state=23)
    for i in range(21):
        alpha=i/10#约定参数可以选定为小数
        ridge=Ridge(alpha=alpha)
        ridge.fit(X_train,y_train)
        linear=LinearRegression()
        linear.fit(X_train,y_train)
        result_b=result_b.append([{"参数":alpha,"岭回归训练模型得分":r2_score(y_train,ridge.predict(X_train)),"岭回归待测模型得分":r2_score(y_test,ridge.predict(X_test)),"线性回归训练模型得分":r2_score(y_train,linear.predict(X_train)),"线性回归待测模型得分":r2_score(y_test,linear.predict(X_test))}])
    

    结果如下所示:
    在这里插入图片描述
    可以看出如果只是针对训练模型的精度,最小二乘法是要优于岭回归的,但是对新的数据作出预测时,也就是考虑模型的泛化能力上,可以看出岭回归的模型得分比最小二乘法要好一点。
    我们通过一个折线图来更直观地表现上面的数据:

    import matplotlib.pyplot as plt
    import seaborn as sns
    plt.style.use("fivethirtyeight")
    sns.set_style({'font.sans-serif':['SimHei','Arial']})#设定汉字字体,防止出现方框
    %matplotlib inline
    #在jupyter notebook上直接显示图表
    fig= plt.subplots(figsize=(15,5))
    plt.plot(result_b["参数"],result_b["岭回归训练模型得分"],label="岭回归训练模型得分")#画折线图
    plt.plot(result_b["参数"],result_b["岭回归待测模型得分"],label="岭回归待测模型得分")
    plt.plot(result_b["参数"],result_b["线性回归训练模型得分"],label="线性回归训练模型得分")
    plt.plot(result_b["参数"],result_b["线性回归待测模型得分"],label="线性回归待测模型得分")
    plt.rcParams.update({'font.size': 12})
    plt.legend()
    plt.xticks(fontsize=15)#设置坐标轴上的刻度字体大小
    plt.yticks(fontsize=15)
    plt.xlabel("参数",fontsize=15)#设置坐标轴上的标签内容和字体
    plt.ylabel("得分",fontsize=15)
    

    结果如下所示:
    在这里插入图片描述
    可以看出岭回归模型在模型的简单性(系数都接近于0)与训练集性能之间作出权衡。简单性和训练性能二者对于模型的重要程度可以由用户通过设置aplha参数来制定。增大alpha会使得系数更加趋向于0,从而降低训练集性能,但会提高泛化性能。

    而且无论是岭回归还是线性回归,所有数据集大小对应的训练分数都要高于预测分数。由于岭回归是正则化的,所以它的训练分数要整体低于线性回归的训练分数。但岭回归的测试分数高,特别是对于较小的数据集。如果数据量小于一定程度的时候,线性回归将学不到任何内容,随着模型可用数据越来越多,两个模型的性能都在提升,最终线性回归的性能追上了岭回归。所以如果有足够多的训练内容,正则化变得不那么重要,并且岭回归和线性回归将具有相同的性能。

    个人博客:https://www.yyb705.com/
    欢迎大家来我的个人博客逛一逛,里面不仅有技术文,也有系列书籍的内化笔记。
    有很多地方做的不是很好,欢迎网友来提出建议,也希望可以遇到些朋友来一起交流讨论。

    展开全文
  • 针对室内高精度定位需求和蓝牙信号强度动态变化特征,提出了一种基于核岭回归(KRR)的定位方法,只需利用蓝牙锚节点之间的信号强度及其物理坐标信息,学习蓝牙信号强度与物理坐标的回归模型,并能在线动态更新模型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,992
精华内容 5,596
关键字:

岭回归