“机器学习实战”刻意练习——回归问题：线性回归(最小二乘、岭回归、逐步回归)

梦里梦外; 2023-06-22 04:21 33阅读 0赞

参考：

1.  [Python3《机器学习实战》学习笔记（十一）：线性回归基础篇之预测鲍鱼年龄 - Jack-Cui][Python3_ - Jack-Cui]
2.  [Python3《机器学习实战》学习笔记（十二）：线性回归提高篇之乐高玩具套件二手价预测 - Jack-Cui][Python3_ - Jack-Cui 1]

# 一、回归问题概述 #

回归的**目的**是预测数值型的目标值。  
最直接的办法是依据输入写出一个目标值的计算公式。这些公式被称作**回归方程（regression equation**），而其中的参数称作**回归系数（regression weights**），求这些回归系数的过程就是**回归**。一旦有了这些回归系数，再给定输入，做预测就非常容易了。  
具体的做法是用回归系数乘以输入值，再将结果全部加在一起，就得到了预测值。

说到回归，一般都是指**线性回归（linear regression**），线性回归意味着可以将输入项分别乘以一些**常量**，再将结果加起来得到输出。

*  优缺点  
    优点：结果易于理解，计算上不复杂。  
    缺点：对非线性的数据拟合不好。
 *  适用数据类型：  
    **数值型**和**标称型数据**。
 *  回归的一般方法  
    (1) 收集数据：采用任意方法收集数据。  
    (2) 准备数据：回归需要数值型数据，标称型数据将被转成**二值型数据**。  
    (3) 分析数据：绘出数据的可视化二维图将有助于对数据做出理解和分析，在采用缩减法求得新回归系数之后，可以将新拟合线绘在图上作为对比。  
    (4) 训练算法：找到回归系数。  
    (5) 测试算法：使用**R2**或者**预测值和数据的拟合度**，来分析模型的效果。  
    (6) 使用算法：使用回归，可以在给定输入的时候预测出一个数值，这是对分类方法的提升，因为这样可以**预测连续型数据**而不仅仅是离散的类别标签。

# 二、线性回归及相关原理 #

## 1.用线性回归找到最佳拟合直线 ##

*应当怎样从一大堆数据里求出回归方程呢？*  
假定输入数据存放在矩阵X中，而回归系数存放在向量w中。那么对于给定的数据X1，预测结果将会通过 Y 1 = X 1 T w Y\_\{1\}=X^\{T\}\_\{1\}w Y1=X1Tw给出。  
*现在的问题是，手里有一些X和对应的y，怎样才能找到w呢？*  
一个常用的方法就是找出使**误差最小**的w。  
这里的误差是指预测y值和真实y值之间的差值，使用该误差的简单累加将使得正差值和负差值相互抵消，所以我们采用**平方误差**。

平方误差的矩阵形式可以写做：  
 ( y − X w ) T ( y − X w ) (y-Xw)^\{T\}(y-Xw) (y−Xw)T(y−Xw)

如果对w求导，得到 X T ( Y − X w ) X^\{T\}(Y-Xw) XT(Y−Xw)，令其等于零，解出  
w如下：  
 ω ^ = ( X T X ) − 1 X T Y \\hat\{\\omega\}=(X^\{T\}X)^\{-1\}X^\{T\}Y ω^=(XTX)−1XTY

w上方的小标记表示，这是当前可以估计出的w的最优解。从现有数据上估计出的w可能并不是数据中的真实w值，所以这里使用了**一个“帽”符号来表示它仅是w的一个最佳估计**。

上述的最佳w求解是统计学中的常见问题，除了矩阵方法外还有很多其他方法可以解决。该方法也称作**OLS**，意思是“**普通最小二乘法**”（ordinary least squares）。

## 2.局部加权线性回归 ##

线性回归的一个问题是有可能出现**欠拟合现象**，因为它求的是具有最小均方误差的无偏估计。如果模型欠拟合将不能取得最好的预测效果。  
所以有些方法允许在估计中引入一些偏差，从而**降低预测的均方误差**。

其中的一个方法是**局部加权线性回归（Locally Weighted Linear Regression，LWLR**）。  
在该算法中，我们给待**预测点附近**的每个点赋予一定的**权重**，然后在这个子集上基于最小均方差来进行普通的回归。与kNN一样，这种算法每次预测均需要**事先选取出对应的数据子集**。

该算法解出回归系数 ω \\omega ω的形式如下：  
 ω ^ = ( X T W X ) − 1 X T W Y \\hat\{\\omega\}=(X^\{T\}WX)^\{-1\}X^\{T\}WY ω^=(XTWX)−1XTWY

其中 W W W是一个矩阵，用来给每个数据点赋予权重。

LWLR使用“核”（与支持向量机中的核类似）来对附近的点赋予更高的权重。核的类型可以自由选择，最常用的核就是**高斯核**，高斯核对应的权重如下：  
 W ( i , i ) = e x p ( ∣ x i − x ∣ − 2 k 2 ) W(i,i)=exp(\\frac\{|x^\{i\}-x|\}\{-2k^2\}) W(i,i)=exp(−2k2∣xi−x∣)

这样就构建了一个**只含对角元素**的权重矩阵w，并且**点x与x(i)越近，w(i,i)将会越大**。  
上述公式包含一个需要用户指定的**参数k**，它决定了对附近的点赋予多大的权重，这也是使用LWLR时唯一需要考虑的参数。

## 3.岭回归 ##

如果**数据的特征比样本点还多**应该怎么办？  
是否还可以使用线性回归和之前的方法来做预测？答案是否定的，即不能再使用前面介绍的方法。这是因为在计算 ( X T X ) − 1 (X^\{T\}X)^\{-1\} (XTX)−1的时候会出错。

如果特征比样本点还多（n > m），也就是说输入数据的矩阵X不是满秩矩阵。非满秩矩阵在求逆时会出现问题。

为了解决这个问题，统计学家引入了**岭回归（ridge regression**）的概念，这就是第一种缩减方法。另外还有**lasso法**，该方法效果很好但计算复杂。第二种缩减方法称为**前向逐步回归**，可以得到与lasso差不多的效果，且更容易实现。

简单说来，岭回归就是在矩阵 X T X X^\{T\}X XTX上加一个λI从而使得矩阵非奇异，进而能对 X T X + λ I X^\{T\}X+ λI XTX\+λI求逆。  
其中矩阵I是一个m×m的单位矩阵，对角线上元素全为1，其他元素全为0。而λ是一个用户定义的数值。  
在这种情况下，回归系数的计算公式将变成：  
 ω ^ = ( X T X + λ I ) − 1 X T Y \\hat\{\\omega\}=(X^\{T\}X+ λI)^\{-1\}X^\{T\}Y ω^=(XTX\+λI)−1XTY  
岭回归最先用来处理特征数多于样本数的情况，现在也用于在估计中加入偏差，从而得到更好的估计。这里通过引入λ来限制了所有w之和，通过引入该惩罚项，能够减少不重要的参数，这个技术在统计学中也叫做**缩减（shrinkage**）。.

缩减方法可以去掉不重要的参数，因此能更好地理解数据。此外，与简单的线性回归相比，缩减法能取得更好的预测效果。  
与前几章里训练其他参数所用的方法类似，这里通过预测误差最小化得到λ：数据获取之后，首先抽一部分数据用于测试，剩余的作为训练集用于训练参数w。训练完毕后在测试集上测试预测性能。通过选取不同的λ来重复上述测试过程，最终得到一个**使预测误差最小的λ**。

## 4.lasso ##

在增加如下约束时，普通的最小二乘法回归会得到与岭回归的一样的公式：  
 ∑ k = 1 n w k 2 ≤ λ \\sum ^\{n\}\_\{k=1\}w\_\{k\}^\{2\}\\leq \\lambda k=1∑nwk2≤λ  
上式**限定了所有回归系数的平方和不能大于λ**。  
使用普通的最小二乘法回归在当两个或更多的特征相关时，可能会得出一个很大的正系数和一个很大的负系数。正是因为上述限制条件的存在，使用岭回归可以避免这个问题。

与岭回归类似，另一个缩减方法lasso也对回归系数做了限定，对应的约束条件如下：  
 ∑ k = 1 n ∣ w k ∣ ≤ λ \\sum ^\{n\}\_\{k=1\}|w\_\{k\}|\\leq \\lambda k=1∑n∣wk∣≤λ  
这个约束条件使用绝对值取代了平方和。虽然约束形式只是稍作变化，结果却大相径庭：在λ足够小的时候，一些系数会因此被迫缩减到0，这个特性可以帮助我们更好地理解数据。

这个细微的变化却极大地增加了计算复杂度（为了在这个新的约束条件下解出回归系数，需要使用二次规划算法）。所以我们将使用更为简单的方法来得到结果，该方法叫做前向逐步回归。

## 5.前向逐步回归 ##

前向逐步回归算法可以得到与lasso差不多的效果，但更加简单。它属于一种**贪心算法**，即每一步都尽可能减少误差。一开始，所有的权重都设为1，然后每一步所做的决策是对某个权重增加或减少一个很小的值。

逐步线性回归算法的主要优点在于它可以帮助人们**理解现有的模型**并做出改进。当构建了一个模型后，可以运行该算法找出重要的特征，这样就有可能及时停止对那些不重要特征的收集。  
最后，如果用于测试，该算法每100次迭代后就可以构建出一个模型，可以使用类似于10折交叉验证的方法比较这些模型，最终选择使误差最小的模型。

当应用缩减方法（如逐步线性回归或岭回归）时，模型也就**增加了偏差（bias），与此同时却减小了模型的方差**。

## 6.权衡偏差与方差 ##

任何时候，一旦发现模型和测量值之间存在差异，就说出现了误差。当考虑模型中的“噪声”或者说误差时，必须考虑其来源。你可能会对复杂的过程进行简化，这将导致在模型和测量值之  
间出现“噪声”或误差，若无法理解数据的真实生成过程，也会导致差异的发生。另外，测量过程本身也可能产生“噪声”或者问题。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg_size_16_color_FFFFFF_t_70]  
上图给出了训练误差和测试误差的曲线图，上面的曲线就是测试误差，下面的曲线是训练误差。我们知道：如果降低核的大小，那么训练误差将变小。从上图来看，从左到右就表示了**核逐渐减小**的过程。 上图的左侧是参数缩减过于严厉的结果，而右侧是无缩减的效果。

缩减法可以将一些系数缩减成很小的值或直接缩减为0，增大了模型偏差。通过把一些特征的回归系数缩减到0，同时也就**减少了模型的复杂度**。当数据集中有多个特征时，消除其中部分后不仅使模型更易理解，同时还降低了预测误差。

# 三、代码实现 #

## 1.普通最小二乘法 ##

import numpy as np
    import matplotlib.pyplot as plt
    
    def loadDataSet(fileName):
        """ 加载数据集 - - - - fileName - 文件路径 """
        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 standRegres(xArr,yArr):
        """ 计算回归系数w - - - - xArr - x数据集 yArr - y数据集 """
        xMat = np.mat(xArr); yMat = np.mat(yArr).T
        xTx = xMat.T * xMat
        if np.linalg.det(xTx) == 0.0:
            print("矩阵为奇异矩阵,不能求逆")
            return
        ws = xTx.I * (xMat.T*yMat)
        return ws
    
    def plotRegression():
        """ 绘制回归曲线和数据点 """
        #加载数据集并计算回归系数
        xArr, yArr = loadDataSet('7-Regression/data.txt')
        ws = standRegres(xArr, yArr) 
        xMat = np.mat(xArr)
        yMat = np.mat(yArr)
        #深拷贝xMat矩阵并排序
        xCopy = xMat.copy()
        xCopy.sort(0)
        yHat = xCopy * ws
        fig = plt.figure()
        ax = fig.add_subplot(111)
        ax.plot(xCopy[:, 1], yHat, c = 'red')
        ax.scatter(xMat[:,1].flatten().A[0], yMat.flatten().A[0], s = 20, c = 'blue',alpha = .5)
        plt.title('DataSet')
        plt.xlabel('X')
        plt.show()
    
    if __name__ == '__main__':
        plotRegression()

结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg_size_16_color_FFFFFF_t_70 1]

## 2.局部加权线性回归 ##

from matplotlib.font_manager import FontProperties
    
    def lwlr(testPoint, xArr, yArr, k = 1.0):
        """ 函数说明:使用局部加权线性回归计算回归系数w - - - - testPoint - 测试样本点 xArr - x数据集 yArr - y数据集 k - 高斯核的k,自定义参数 """
        xMat = np.mat(xArr); yMat = np.mat(yArr).T
        m = np.shape(xMat)[0]
        #创建权重对角矩阵
        weights = np.mat(np.eye((m)))  
        #遍历数据集计算每个样本的权重 
        for j in range(m):                                                  
            diffMat = testPoint - xMat[j, :]                                 
            weights[j, j] = np.exp(diffMat * diffMat.T/(-2.0 * k**2))
        xTx = xMat.T * (weights * xMat)                                        
        if np.linalg.det(xTx) == 0.0:
            print("矩阵为奇异矩阵,不能求逆")
            return
        #计算回归系数
        ws = xTx.I * (xMat.T * (weights * yMat))                            
        return testPoint * ws
    
    def lwlrTest(testArr, xArr, yArr, k=1.0):  
        """ 函数说明:局部加权线性回归测试 - - - - testArr - 测试数据集 xArr - x数据集 yArr - y数据集 k - 高斯核的k,自定义参数 """
        #计算测试数据集大小
        m = np.shape(testArr)[0]                                            
        yHat = np.zeros(m)    
        #对每个样本点进行预测
        for i in range(m):                                                    
            yHat[i] = lwlr(testArr[i],xArr,yArr,k)
        return yHat
    
    def plotlwlrRegression():
        """ 绘制多条局部加权回归曲线 """
        font = FontProperties(fname=r'/Users/lql70/Downloads/simsun.ttc', size=16) 
        xArr, yArr = loadDataSet('7-Regression/data.txt')    
        #根据局部加权线性回归计算yHat,分别取k=1,0.01,0.003
        yHat_1 = lwlrTest(xArr, xArr, yArr, 1.0) 
        yHat_2 = lwlrTest(xArr, xArr, yArr, 0.01)
        yHat_3 = lwlrTest(xArr, xArr, yArr, 0.003)
        xMat = np.mat(xArr) 
        yMat = np.mat(yArr) 
        #排序，返回索引值
        srtInd = xMat[:, 1].argsort(0) 
        xSort = xMat[srtInd][:,0,:]
    
        fig, axs = plt.subplots(nrows=3, ncols=1,sharex=False, sharey=False, figsize=(10,8)) 
        #绘制回归曲线 
        axs[0].plot(xSort[:, 1], yHat_1[srtInd], c = 'red')
        axs[1].plot(xSort[:, 1], yHat_2[srtInd], c = 'red')
        axs[2].plot(xSort[:, 1], yHat_3[srtInd], c = 'red')
        #绘制样本点
        axs[0].scatter(xMat[:,1].flatten().A[0], yMat.flatten().A[0], s = 20, c = 'blue', alpha = .5)
        axs[1].scatter(xMat[:,1].flatten().A[0], yMat.flatten().A[0], s = 20, c = 'blue', alpha = .5)
        axs[2].scatter(xMat[:,1].flatten().A[0], yMat.flatten().A[0], s = 20, c = 'blue', alpha = .5)
        #设置标题,x轴label,y轴label
        axs0_title_text = axs[0].set_title(u'局部加权回归曲线,k=1.0',FontProperties=font)
        axs1_title_text = axs[1].set_title(u'局部加权回归曲线,k=0.01',FontProperties=font)
        axs2_title_text = axs[2].set_title(u'局部加权回归曲线,k=0.003',FontProperties=font)
        plt.setp(axs0_title_text, size=8, weight='bold', color='red')  
        plt.setp(axs1_title_text, size=8, weight='bold', color='red')  
        plt.setp(axs2_title_text, size=8, weight='bold', color='red')  
        plt.xlabel('X')
        plt.show()
    
    if __name__ == '__main__':
        #1.线性回归
        #plotRegression()
        #2.局部加权回归
        plotlwlrRegression()

结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg_size_16_color_FFFFFF_t_70 2]  
可以看出：  
当k = 1.0时权重很大，如同将所有的数据视为等权重，得出的最佳拟合直线与标准的回归一致，出现了**欠拟合**。  
使用k = 0.01时得到了非常好的效果，抓住了数据的潜在模式。  
使用k = 0.003时纳入了太多的噪声点，拟合的直线与数据点过于贴近，出现了**过拟合**。

## 3.岭回归 ##

为了使用岭回归和缩减技术，首先需要对特征做**标准化处理**。因为，我们需要使每个维度特征具有相同的重要性。  
这里使用的标准化处理比较简单，就是将所有特征都减去各自的均值并除以方差。

def ridgeRegres(xMat, yMat, lam = 0.2):
        """ 岭回归 - - - - xMat - x数据集 yMat - y数据集 lam - 缩减系数 """
        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
    
    def ridgeTest(xArr, yArr):
        """ 岭回归测试 xMat - x数据集 yMat - y数据集 """
        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  
        #30个不同的lambda测试 
        numTestPts = 30                         
        #初始回归系数矩阵 
        wMat = np.zeros((numTestPts, np.shape(xMat)[1]))    
        for i in range(numTestPts):
            ws = ridgeRegres(xMat, yMat, np.exp(i - 10))
            wMat[i, :] = ws.T
        return wMat
    
    def plotwMat():
        """ 绘制岭回归系数矩阵 """
        font = FontProperties(fname=r'/Users/lql70/Downloads/simsun.ttc', size=16) 
        abX, abY = loadDataSet('7-Regression/abalone.txt')
        redgeWeights = ridgeTest(abX, abY)
        fig = plt.figure()
        ax = fig.add_subplot(111)
        ax.plot(redgeWeights)    
        ax_title_text = ax.set_title(u'log(lambda)与回归系数的关系', FontProperties = font)
        ax_xlabel_text = ax.set_xlabel(u'log(lambda)', FontProperties = font)
        ax_ylabel_text = ax.set_ylabel(u'回归系数', FontProperties = font)
        plt.setp(ax_title_text, size = 20, weight = 'bold', color = 'red')
        plt.setp(ax_xlabel_text, size = 10, weight = 'bold', color = 'black')
        plt.setp(ax_ylabel_text, size = 10, weight = 'bold', color = 'black')
        plt.show()
    
    if __name__ == '__main__':
    	#1.线性回归
        #plotRegression()
        #2.局部加权回归
        #plotlwlrRegression()
        #3.岭回归
        plotwMat()

结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg_size_16_color_FFFFFF_t_70 3]  
可以看出，在最左边，即λ最小时，可以得到所有系数的原始值（与线性回归一致）；而在右边，系数全部缩减成0；在中间部分的某值将可以取得最好的预测效果。为了定量地找到最佳参数值，还需要进行交叉验证。

## 4.前向逐步回归 ##

def regularize(xMat, yMat):
        """ 数据标准化 - - - - xMat - x数据集 yMat - 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):
        """ 计算平方误差 - - - - yArr - 预测值 yHatArr - 真实值 """
        return ((yArr-yHatArr)**2).sum()
    
    def stageWise(xArr, yArr, eps = 0.01, numIt = 100):
        """ 前向逐步线性回归 - - - - xArr - x输入数据 yArr - y预测数据 eps - 每次迭代需要调整的步长 numIt - 迭代次数 """
        #数据初始化、标准化
        xMat = np.mat(xArr); yMat = np.mat(yArr).T
        xMat, yMat = regularize(xMat, yMat)
        m, n = np.shape(xMat)
        returnMat = np.zeros((numIt, n))                                                
        ws = np.zeros((n, 1))                                                            
        wsTest = ws.copy()
        wsMax = ws.copy()
        #迭代numIt次
        for i in range(numIt):
            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()
            #记录numIt次迭代的回归系数矩阵
            returnMat[i,:] = ws.T 
        return returnMat
    
    def plotstageWiseMat():
        """ 绘制岭回归系数矩阵 """
        font = FontProperties(fname=r'/Users/lql70/Downloads/simsun.ttc', size=16) 
        xArr, yArr = loadDataSet('7-Regression/abalone.txt')
        returnMat = stageWise(xArr, yArr, 0.005, 1000)
        fig = plt.figure()
        ax = fig.add_subplot(111)
        ax.plot(returnMat)    
        ax_title_text = ax.set_title(u'前向逐步回归:迭代次数与回归系数的关系', FontProperties = font)
        ax_xlabel_text = ax.set_xlabel(u'迭代次数', FontProperties = font)
        ax_ylabel_text = ax.set_ylabel(u'回归系数', FontProperties = font)
        plt.setp(ax_title_text, size = 15, weight = 'bold', color = 'red')
        plt.setp(ax_xlabel_text, size = 10, weight = 'bold', color = 'black')
        plt.setp(ax_ylabel_text, size = 10, weight = 'bold', color = 'black')
        plt.show()
    
    if __name__ == '__main__':
        #1.线性回归
        #plotRegression()
        #2.局部加权回归
        #plotlwlrRegression()
        #3.岭回归
        #plotwMat()
        #4.前向逐步回归
        plotstageWiseMat()

结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg_size_16_color_FFFFFF_t_70 4]  
上图是鲍鱼数据集上执行逐步线性回归法得到的系数与迭代次数间的关系。逐步线性回归得到了与lasso相似的结果，但计算起来更加简便。

# 四、实战：预测乐高玩具套装的价格 #

*  **步骤**：用回归法预测乐高套装的价格  
    (1) 收集数据：用Google Shopping的API收集数据。  
    （现在这个所需API已经关闭，只能通过读取指定html文件获取相关商品数据）  
    (2) 准备数据：从返回的JSON数据中抽取价格。  
    (3) 分析数据：可视化并观察数据。  
    (4) 训练算法：构建不同的模型，采用逐步线性回归和直接的线性回归模型。  
    (5) 测试算法：使用交叉验证来测试不同的模型，分析哪个效果最好。  
    (6) 使用算法：这次练习的目标就是生成数据模型。

## 1.载入模型 ##

from bs4 import BeautifulSoup
    
    def scrapePage(retX, retY, inFile, yr, numPce, origPrc):
        """ 从页面读取数据，生成retX和retY列表 retX - 数据X retY - 数据Y inFile - HTML文件 yr - 年份 numPce - 乐高部件数目 origPrc - 原价 """
        # 打开并读取HTML文件
        with open(inFile, encoding='utf-8') as f:
            html = f.read()
        soup = BeautifulSoup(html)
        i = 1
        # 根据HTML页面结构进行解析
        currentRow = soup.find_all('table', r = "%d" % i)
        while(len(currentRow) != 0):
            currentRow = soup.find_all('table', r = "%d" % i)
            title = currentRow[0].find_all('a')[1].text
            lwrTitle = title.lower()
            # 查找是否有全新标签
            if (lwrTitle.find('new') > -1) or (lwrTitle.find('nisb') > -1):
                newFlag = 1.0
            else:
                newFlag = 0.0
            # 查找是否已经标志出售，我们只收集已出售的数据
            soldUnicde = currentRow[0].find_all('td')[3].find_all('span')
            if len(soldUnicde) == 0:
                print("商品 #%d 没有出售" % i)
            else:
                # 解析页面获取当前价格
                soldPrice = currentRow[0].find_all('td')[4]
                priceStr = soldPrice.text
                priceStr = priceStr.replace('$','')
                priceStr = priceStr.replace(',','')
                if len(soldPrice) > 1:
                    priceStr = priceStr.replace('Free shipping', '')
                sellingPrice = float(priceStr)
                # 去掉不完整的套装价格
                if  sellingPrice > origPrc * 0.5:
                    print("%d\t%d\t%d\t%f\t%f" % (yr, numPce, newFlag, origPrc, sellingPrice))
                    retX.append([yr, numPce, newFlag, origPrc])
                    retY.append(sellingPrice)
            i += 1
            currentRow = soup.find_all('table', r = "%d" % i)
             
    def setDataCollect(retX, retY):
        """ 依次读取六种乐高套装的数据，并生成数据矩阵 """
        #2006年的乐高8288,部件数目800,原价49.99;其他同理可推
        scrapePage(retX, retY, '7-Regression/setHtml/lego8288.html', 2006, 800, 49.99)
        scrapePage(retX, retY, '7-Regression/setHtml/lego10030.html', 2002, 3096, 269.99)
        scrapePage(retX, retY, '7-Regression/setHtml/lego10179.html', 2007, 5195, 499.99)
        scrapePage(retX, retY, '7-Regression/setHtml/lego10181.html', 2007, 3428, 199.99)
        scrapePage(retX, retY, '7-Regression/setHtml/lego10189.html', 2008, 5922, 299.99)
        scrapePage(retX, retY, '7-Regression/setHtml/lego10196.html', 2009, 3263, 249.99)
    
    if __name__ == '__main__':
        #1.线性回归
        #plotRegression()
        #2.局部加权回归
        #plotlwlrRegression()
        #3.岭回归
        #plotwMat()
        #4.前向逐步回归
        #plotstageWiseMat()
        #5.实战：预测乐高玩具套装的价格
        lgX = []
        lgY = []
        setDataCollect(lgX, lgY)

结果：

2006    800     0       49.990000       85.000000
    2006    800     0       49.990000       102.500000
    2006    800     0       49.990000       77.000000
    商品 #4 没有出售
    ...
    2009    3263    1       249.990000      499.990000
    商品 #10 没有出售
    2009    3263    0       249.990000      399.950000
    商品 #12 没有出售
    2009    3263    1       249.990000      331.510000

## 2.简单的线性回归 ##

def useStandRegres():
        """ 使用简单的线性回归 """
        lgX = []
        lgY = []
        setDataCollect(lgX, lgY)
        #在第0列加入1，作为最后常数项
        data_num, features_num = np.shape(lgX)
        lgX1 = np.mat(np.ones((data_num, features_num + 1)))
        lgX1[:, 1:5] = np.mat(lgX)
        ws = standRegres(lgX1, lgY)
        print('%f%+f*年份%+f*部件数量%+f*是否为全新%+f*原价' % (ws[0],ws[1],ws[2],ws[3],ws[4]))

结果：

55319.970081-27.592822*年份-0.026839*部件数量-11.220848*是否为全新+2.576041*原价

这个模型的预测效果非常好，但模型本身并不能令人满意。它对于数据拟合得很好，但看上去没有什么道理。从公式看，套装里零部件越多售价反而会越低。另外，该公式对新套装也有一定的惩罚。

## 3.岭回归 ##

def crossValidation(xArr, yArr, numVal = 10):
        """ 交叉验证岭回归 - - - - xArr - x数据集 yArr - y数据集 numVal - 交叉验证次数 """
        #统计样本个数并生成索引值列表
        m = len(yArr)
        indexList = list(range(m))
        errorMat = np.zeros((numVal,30))
        #交叉验证numVal次
        for i in range(numVal):
            trainX = []; trainY = []
            testX = []; testY = []
            #打乱次序
            random.shuffle(indexList)
            #划分数据集:90%训练集，10%测试集
            for j in range(m):
                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)
                #统计误差
                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]))  
    
    if __name__ == '__main__':
        #1.线性回归
        #plotRegression()
        #2.局部加权回归
        #plotlwlrRegression()
        #3.岭回归
        #plotwMat()
        #4.前向逐步回归
        #plotstageWiseMat()
        #5.实战：预测乐高玩具套装的价格
        #useStandRegres()
        lgX = []
        lgY = []
        setDataCollect(lgX, lgY)
        crossValidation(lgX, lgY)

结果：

76623.641543-38.176231*年份-0.003174*部件数量+35.161731*是否为全新+2.001705*原价

可以看到，该结果与最小二乘法没有太大差异。我们本期望找到一个更易于理解的模型，显然没有达到预期效果。

## 4.观察缩减过程中回归系数的变化 ##

if __name__ == '__main__':
        #1.线性回归
        #plotRegression()
        #2.局部加权回归
        #plotlwlrRegression()
        #3.岭回归
        #plotwMat()
        #4.前向逐步回归
        #plotstageWiseMat()
        #5.实战：预测乐高玩具套装的价格
        #useStandRegres()
        lgX = []
        lgY = []
        setDataCollect(lgX, lgY)
        print(ridgeTest(lgX, lgY))

结果：

[[-1.45288906e+02 -8.39360442e+03 -3.28682450e+00  4.42362406e+04]
     [-1.46649725e+02 -1.89952152e+03 -2.80638599e+00  4.27891633e+04]
     [-1.44450432e+02  8.55488076e+02 -1.35089285e+00  4.00885735e+04]
     ...
     [-3.62836944e-05  3.70302314e-07  1.77873811e-04  6.01500768e-06]
     [-1.33480028e-05  1.36226645e-07  6.54365445e-05  2.21279795e-06]
     [-4.91045279e-06  5.01149871e-08  2.40728171e-05  8.14042912e-07]]

这些系数是经过不同程度的缩减得到的。  
首先看第1行，第4项比第2项的系数大5倍，比第1项大57倍。  
这样看来，如果只能*选择一个特征*来做预测的话，我们应该选择第4个特征，也就是原始价格。  
如果可以*选择2个特征*的话，应该选择第4个和第2个特征。

这种分析方法使得我们可以挖掘大量数据的内在规律。在仅有4个特征时，该方法的效果也许并不明显；但如果有100个以上的特征，该方法就会变得十分有效：**它可以指出哪些特征是关键的，而哪些特征是不重要的**。

# 五、小结 #

1.  与分类一样，回归也是预测目标值的过程。回归与分类的不同点在于，前者预测**连续型变量**,而后者预测离散型变量。
2.  在回归方程里，求得特征对应的最佳回归系数的方法是**最小化误差的平方和**。  
    给定输入矩阵X，如果 X T X X^\{T\}X XTX的逆存在并可以求得的话，回归法都可以直接使用。  
    数据集上计算出的回归方程并不一定意味着它是最佳的，可以使用预测值 y ^ \\hat\{y\} y^和原始值y的**相关性**来度量回归方程的好坏。
3.  当数据的样本数比特征数还少时候，矩阵 X T X X^\{T\}X XTX的逆不能直接计算。即便当样本数比特征数多时， X T X X^\{T\}X XTX的逆仍有可能无法直接计算，这是因为特征有可能高度相关。这时可以考虑使用**岭回归**，因为当 X T X X^\{T\}X XTX的逆不能计算时，它仍保证能求得回归参数。  
    岭回归是缩减法的一种，相当于对回归系数的大小施加了限制。
4.  另一种很好的缩减法是lasso。  
    Lasso难以求解，但可以使用计算简便的**逐步线性回归方法**来求得近似结果。**缩减法**还可以看做是对一个模型增加偏差的同时减少方差。
5.  **偏差方差折中**是一个重要的概念，可以帮助我们理解现有模型并做出改进，从而得到更好的模型。

[Python3_ - Jack-Cui]: https://blog.csdn.net/c406495762/article/details/78760239
[Python3_ - Jack-Cui 1]: https://blog.csdn.net/c406495762/article/details/82967529
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191214150258353.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191214085802633.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191214091603392.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191214140840861.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191214143759632.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmFzaGlfRg==,size_16,color_FFFFFF,t_70