• 回归 Regression

    之前讲的逻辑回归是处理分类问题，而线性回归是处理连续问题。

    与线性回归不同的是，逻辑回归由于其联系函数的选择，它的参数估计方法不再使用最小二乘法，而是极大似然法。

    最小二乘法是最小化预测和实际之间的欧氏距离，极大似然法的思想也是如出一辙的，但是它是通过最大化预测属于实际的概率来最小化预测和实际之间的“距离”。

    损失函数：

    \sum (y_{i}-x_{i}^{T}w)^{2}

    对w求导，令其=0，找出最小loss。

    (y-Xw)^{T}(y-Xw)

    矩阵求导：

    两个最基本的概念：分子布局和分母布局：

    分子布局：

    分子是列向量，分母是行向量

    \frac{\partial f_{2\times 1}(x)}{\partial x_{3\times 1}^{T}}=\begin{bmatrix} \frac{\partial f_{1}}{\partial x_{1}} & \frac{\partial f_{1}}{\partial x_{2}} & \frac{\partial f_{1}}{\partial x_{3}} \\ \frac{\partial f_{2}}{\partial x_{1}} &\frac{\partial f_{2}}{\partial x_{2}} & \frac{\partial f_{2}}{\partial x_{3}} \end{bmatrix}

    分母布局：

    分母是列向量，分子是行向量

    \frac{\partial f_{2\times 1}^{T}(x)}{\partial x_{3\times 1}}=\begin{bmatrix} \frac{\partial f_{1}}{\partial x_{1}} & \frac{\partial f_{2}}{\partial x_{1}} \\ \frac{\partial f_{1}}{\partial x_{2}} & \frac{\partial f_{2}}{\partial x_{2}} \\\frac{\partial f_{1}}{\partial x_{3}} & \frac{\partial f_{2}}{\partial x_{3}} \end{bmatrix}

    1.\frac{\partial y^{T}Xw}{\partial w}求导：\frac{\partial y^{T}Xw}{\partial w}=X^{T}y

    证明：

    用一个基本例子验证，然后用数学归纳法证明

    y=\begin{bmatrix} y1\\ y2 \end{bmatrix}，X=\begin{bmatrix} x11 & x12\\ x21 & x22 \end{bmatrix}，w=\begin{bmatrix} w1\\ w2 \end{bmatrix}

    相乘，然后求导，不难看出公式是正确的

    2.\frac{\partial w^{T}X^{T}y}{\partial w}求导：\frac{\partial w^{T}X^{T}y}{\partial w}=\frac{\partial (w^{T}X^{T}y)^{T}}{\partial w}=\frac{\partial y^{T}Xw}{\partial w}=X^{T}y

    3.\frac{\partial w^{T}X^{T}Xw}{\partial w}求导：\frac{\partial w^{T}X^{T}Xw}{\partial w}=2X^{T}Xw

    同样此公式也可以用公式1的例子验证。

    所以(y-Xw)^{T}(y-Xw)求导：

    \frac{\partial y^{T}y}{\partial w}-\frac{\partial y^{T}Xw}{\partial w}-\frac{\partial w^{T}X^{T}y}{\partial w}+\frac{\partial w^{T}X^{T}Xw}{\partial w}=0-X^{T}y-X^{T}y+2X^{T}Xw=-2X^{T}(y+Xw)

    读入数据，将数据特征x、特征标签y存储在矩阵x、y中
    验证 x^Tx 矩阵是否可逆
    使用最小二乘法求得 回归系数 w 的最佳估计

    1. from __future__ import print_function
    2.  
    3. from numpy import *
    4. import matplotlib.pylab as plt
    5.  
    6. def loadDataSet(fileName):
    7.     '''
    8.     加载数据
    9.         解析以tab键分隔的文件中的浮点数
    10.     Returns: 
    11.         dataMat :   feature 对应的数据集
    12.         labelMat :  feature 对应的分类标签，即类别标签
    13.     '''
    14.     # 获取样本特征的总数，不算最后的目标变量
    15.     numFeat=len(open(fileName).readline().split('\t'))-1
    16.     dataMat=[]
    17.     labelMat=[]
    18.     fr=open(fileName)
    19.     for line in fr.readlines():
    20.         # 读取每一行
    21.         lineArr=[]
    22.         # 删除一行中以tab分隔的数据前后的空白符号
    23.         curLine=line.strip().split('\t')
    24.         # i 从0到2，不包括2
    25.         for i in range(numFeat):
    26.             # 将数据添加到lineArr List中，每一行数据测试数据组成一个行向量
    27.             lineArr.append(float(curLine[i]))
    28.             # 将测试数据的输入数据部分存储到dataMat的List中
    29.         dataMat.append(lineArr)
    30.         # 将每一行的最后一个数据，即类别，或者叫目标变量存储到labelMat List中
    31.         labelMat.append(float(curLine[-1]))
    32.     return dataMat,labelMat
    33.  
    34. def standRegres(xArr, yArr):
    35.     '''
    36.     Description: 
    37.         线性回归
    38.     Args:
    39.         xArr : 输入的样本数据，包含每个样本数据的 feature
    40.         yArr : 对应于输入数据的类别标签，也就是每个样本对应的目标变量
    41.     Returns:
    42.         ws: 回归系数
    43.     '''
    44.  
    45.     # mat()函数将xArr，yArr转换为矩阵 mat().T 代表的是对矩阵进行转置操作
    46.     xMat = mat(xArr)
    47.     yMat = mat(yArr).T
    48.     # 矩阵乘法的条件是左矩阵的列数等于右矩阵的行数
    49.     xTx = xMat.T * xMat
    50.     # 因为要用到xTx的逆矩阵，所以事先需要确定计算得到的xTx是否可逆，条件是矩阵的行列式不为0
    51.     # linalg.det() 函数是用来求得矩阵的行列式的，如果矩阵的行列式为0，则这个矩阵是不可逆的，就无法进行接下来的运算                   
    52.     if linalg.det(xTx) == 0.0:
    53.         print("This matrix is singular, cannot do inverse")
    54.         return
    55.     # 最小二乘法
    56.     # http://cwiki.apachecn.org/pages/viewpage.action?pageId=5505133
    57.     # 书中的公式，求得w的最优解
    58.     ws = xTx.I * (xMat.T * yMat)
    59.     return ws
    60.  
    61. # 局部加权线性回归
    62. def lwlr(testPoint, xArr, yArr, k=1.0):
    63.     '''
    64.         Description: 
    65.             局部加权线性回归，在待预测点附近的每个点赋予一定的权重，在子集上基于最小均方差来进行普通的回归。
    66.         Args: 
    67.             testPoint: 样本点
    68.             xArr: 样本的特征数据，即 feature
    69.             yArr: 每个样本对应的类别标签，即目标变量
    70.             k:关于赋予权重矩阵的核的一个参数，与权重的衰减速率有关
    71.         Returns:
    72.             testPoint * ws: 数据点与具有权重的系数相乘得到的预测点
    73.         Notes:
    74.             这其中会用到计算权重的公式，w = e^((x^((i))-x) / -2k^2)
    75.             理解: x为某个预测点，x^((i))为样本点，样本点距离预测点越近，贡献的误差越大（权值越大），越远则贡献的误差越小（权值越小）。
    76.             关于预测点的选取，在我的代码中取的是样本点。其中k是带宽参数，控制w（钟形函数）的宽窄程度，类似于高斯函数的标准差。
    77.             算法思路: 假设预测点取样本点中的第i个样本点（共m个样本点），遍历1到m个样本点（含第i个），算出每一个样本点与预测点的距离，
    78.             也就可以计算出每个样本贡献误差的权值，可以看出w是一个有m个元素的向量（写成对角阵形式）。
    79.     '''
    80.     # mat() 函数是将array转换为矩阵的函数， mat().T 是转换为矩阵之后，再进行转置操作
    81.     xMat = mat(xArr)
    82.     yMat = mat(yArr).T
    83.     # 获得xMat矩阵的行数
    84.     m = shape(xMat)[0]
    85.     # eye()返回一个对角线元素为1，其他元素为0的二维数组，创建权重矩阵weights，该矩阵为每个样本点初始化了一个权重                   
    86.     weights = mat(eye((m)))
    87.     for j in range(m):
    88.         # testPoint 的形式是 一个行向量的形式
    89.         # 计算 testPoint 与输入样本点之间的距离，然后下面计算出每个样本贡献误差的权值
    90.         diffMat = testPoint - xMat[j, :]
    91.         # k控制衰减的速度
    92.         weights[j, j] = exp(diffMat * diffMat.T / (-2.0 * k**2))
    93.     # 根据矩阵乘法计算 xTx ，其中的 weights 矩阵是样本点对应的权重矩阵
    94.     xTx = xMat.T * (weights * xMat)
    95.     if linalg.det(xTx) == 0.0:
    96.         print("This matrix is singular, cannot do inverse")
    97.         return
    98.     # 计算出回归系数的一个估计
    99.     ws = xTx.I * (xMat.T * (weights * yMat))
    100.     return testPoint * ws
    101.  
    102. def lwlrTest(testArr,xArr,yArr,k=1.0):
    103.     '''
    104.         Description: 
    105.             测试局部加权线性回归，对数据集中每个点调用 lwlr() 函数
    106.         Args: 
    107.             testArr: 测试所用的所有样本点
    108.             xArr: 样本的特征数据，即 feature
    109.             yArr: 每个样本对应的类别标签，即目标变量
    110.             k: 控制核函数的衰减速率
    111.         Returns: 
    112.             yHat: 预测点的估计值
    113.     '''
    114.     # 得到样本点的总数
    115.     m=shape(testArr)[0]
    116.     # 构建一个全部都是0的1*m的矩阵
    117.     yHat=zeros(m)
    118.     # 循环所有的数据点，并将lwlr运用于所有的数据点
    119.     for i in range(m):
    120.         yHat[i]=lwlr(testArr[i],xArr,yArr,k)
    121.     # 返回估计值
    122.     return yHat
    123. def lwlrTestPlot(xArr, yArr, k=1.0):
    124.     '''
    125.         Description:
    126.             首先将 X 排序，其余的都与lwlrTest相同，这样更容易绘图
    127.         Args: 
    128.             xArr: 样本的特征数据，即 feature
    129.             yArr: 每个样本对应的类别标签，即目标变量，实际值
    130.             k: 控制核函数的衰减速率的有关参数，这里设定的是常量值 1
    131.         Return: 
    132.             yHat: 样本点的估计值
    133.             xCopy: xArr的复制
    134.     '''
    135.     # 生成一个与目标变量数目相同的 0 向量
    136.     yHat = zeros(shape(yArr))
    137.     # 将 xArr 转换为 矩阵形式
    138.     xCopy = mat(xArr)
    139.     # 排序
    140.     xCopy.sort(0)
    141.     # 开始循环，为每个样本点进行局部加权线性回归，得到最终的目标变量估计值
    142.     for i in range(shape(xArr)[0]):
    143.         yHat[i] = lwlr(xCopy[i], xArr, yArr, k)
    144.     return yHat, xCopy
    145. def rssError(yArr,yHatArr):
    146.     '''
    147.         Desc:
    148.             计算分析预测误差的大小
    149.         Args:
    150.             yArr: 真实的目标变量
    151.             yHatArr: 预测得到的估计值
    152.         Returns:
    153.             计算真实值和估计值得到的值的平方和作为最后的返回值
    154.     '''
    155.     return ((yArr-yHatArr)**2).sum()
    156.  
    157. def ridgeRegres(xMat,yMat,lam=0.2):
    158.     '''
    159.         Desc: 
    160.             这个函数实现了给定 lambda 下的岭回归求解。
    161.             如果数据的特征比样本点还多，就不能再使用上面介绍的的线性回归和局部线性回归了，因为计算 (xTx)^(-1)会出现错误。
    162.             如果特征比样本点还多（n > m），也就是说，输入数据的矩阵x不是满秩矩阵。非满秩矩阵在求逆时会出现问题。
    163.             为了解决这个问题，我们下边讲一下: 岭回归，这是我们要讲的第一种缩减方法。
    164.         Args: 
    165.             xMat: 样本的特征数据，即 feature
    166.             yMat: 每个样本对应的类别标签，即目标变量，实际值
    167.             lam: 引入的一个λ值，使得矩阵非奇异
    168.         Returns: 
    169.             经过岭回归公式计算得到的回归系数
    170.     '''
    171.     xTx=xMat.T*xMat
    172.     # 岭回归就是在矩阵 xTx 上加一个 λI 从而使得矩阵非奇异，进而能对 xTx + λI 求逆
    173.     denom=xTx+eye(shape(xMat)[1])*lam
    174.     # 检查行列式是否为零，即矩阵是否可逆，行列式为0的话就不可逆，不为0的话就是可逆。
    175.     if linalg.det(denom)==0.0:
    176.         print("This matrix is singular, cannot do inverse")
    177.         return
    178.     ws=denom.I*(xMat.T*yMat)
    179.     return ws
    180.  
    181. def ridgeTest(xArr,yArr):
    182.     '''
    183.         Desc: 
    184.             函数 ridgeTest() 用于在一组 λ 上测试结果
    185.         Args: 
    186.             xArr: 样本数据的特征，即 feature
    187.             yArr: 样本数据的类别标签，即真实数据
    188.         Returns: 
    189.             wMat: 将所有的回归系数输出到一个矩阵并返回
    190.     '''
    191.     xMat=mat(xArr)
    192.     yMat=mat(yArr).T
    193.     #计算Y的均值
    194.     yMean=mean(yMat,0)
    195.     # Y的所有的特征减去均值
    196.     yMat=yMat-yMean
    197.     # 标准化 x，计算xMat平均值
    198.     xMeans=mean(xMat,0)
    199.     # 然后计算x的方差
    200.     xVar=var(xMat,0)
    201.     # 所有特征都减去各自的均值并除以方差
    202.     xMat=(xMat-xMeans)/xVar
    203.     # 可以在 30 个不同的 lambda 下调用 ridgeRegres() 函数。
    204.     numTestPts=30
    205.     # 创建30 * m 的全部数据为0 的矩阵
    206.     wMat=zeros((numTestPts,shape(xMat)[1]))
    207.     for i in range(numTestPts):
    208.         # exp() 返回e^x
    209.         ws=ridgeRegres(xMat,yMat,exp(i-10))
    210.         wMat[i,:]=ws.T
    211.     return wMat
    212.  
    213. def regularize(xMat): #按列进行规范化
    214.     inMat=xMat.copy()
    215.     inMeans=mean(inMat,0) # 计算平均值然后减去它
    216.     inVar=var(inMat,0)#计算除以xi的方差
    217.     inMat=(inMat-inMeans)/inVar
    218.     return inMat
    219.  
    220. def stageWise(xArr,yArr,eps=0.01,numIt=100):
    221.     xMat=mat(xArr)
    222.     yMat=mat(yArr).T
    223.     yMean=mean(yMat,0)
    224.     yMat=yMat-yMean # 也可以规则化ys但会得到更小的coef
    225.     xMat=regularize(xMat)
    226.     m,n=shape(xMat)
    227.     # returnMat = zeros((numIt,n)) # 测试代码删除
    228.     ws=zeros((n,1))
    229.     wsTest=ws.copy()
    230.     wsMax=ws.copy()
    231.     for i in range(numIt):
    232.         print(ws.T)
    233.         lowestError=inf
    234.         for j in range(n):
    235.             for sign in [-1,1]:
    236.                 wsTest=ws.copy()
    237.                 wsTest[j]+=eps*sign
    238.                 yTest=xMat*wsTest
    239.                 rssE=rssError(yMat.A,yTest.A)
    240.                 if rssE < lowestError:
    241.                     lowestError = rssE
    242.                     wsMax = wsTest
    243.         ws = wsMax.copy()
    1. from numpy import *
    2. from bs4 import BeautifulSoup
    3. # 从页面读取数据，生成retX和retY列表
    4. def scrapePage(retX, retY, inFile, yr, numPce, origPrc):
    5.  
    6.     # 打开并读取HTML文件
    7.     fr = open(inFile)
    8.     soup = BeautifulSoup(fr.read())
    9.     i=1
    10.  
    11.     # 根据HTML页面结构进行解析
    12.     currentRow = soup.findAll('table', r="%d" % i)
    13.     while(len(currentRow)!=0):
    14.         currentRow = soup.findAll('table', r="%d" % i)
    15.         title = currentRow[0].findAll('a')[1].text
    16.         lwrTitle = title.lower()
    17.  
    18.         # 查找是否有全新标签
    19.         if (lwrTitle.find('new') > -1) or (lwrTitle.find('nisb') > -1):
    20.             newFlag = 1.0
    21.         else:
    22.             newFlag = 0.0
    23.  
    24.         # 查找是否已经标志出售，我们只收集已出售的数据
    25.         soldUnicde = currentRow[0].findAll('td')[3].findAll('span')
    26.         if len(soldUnicde)==0:
    27.             print ("item #%d did not sell" % i)
    28.         else:
    29.             # 解析页面获取当前价格
    30.             soldPrice = currentRow[0].findAll('td')[4]
    31.             priceStr = soldPrice.text
    32.             priceStr = priceStr.replace('$','') #strips out $
    33.             priceStr = priceStr.replace(',','') #strips out ,
    34.             if len(soldPrice)>1:
    35.                 priceStr = priceStr.replace('Free shipping', '')
    36.             sellingPrice = float(priceStr)
    37.  
    38.             # 去掉不完整的套装价格
    39.             if  sellingPrice > origPrc * 0.5:
    40.                     print ("%d\t%d\t%d\t%f\t%f" % (yr,numPce,newFlag,origPrc, sellingPrice))
    41.                     retX.append([yr, numPce, newFlag, origPrc])
    42.                     retY.append(sellingPrice)
    43.         i += 1
    44.         currentRow = soup.findAll('table', r="%d" % i)
    45.  
    46. # 依次读取六种乐高套装的数据，并生成数据矩阵        
    47. def setDataCollect(retX, retY):
    48.     scrapePage(retX, retY, 'data/8.Regression/setHtml/lego8288.html', 2006, 800, 49.99)
    49.     scrapePage(retX, retY, 'data/8.Regression/setHtml/lego10030.html', 2002, 3096, 269.99)
    50.     scrapePage(retX, retY, 'data/8.Regression/setHtml/lego10179.html', 2007, 5195, 499.99)
    51.     scrapePage(retX, retY, 'data/8.Regression/setHtml/lego10181.html', 2007, 3428, 199.99)
    52.     scrapePage(retX, retY, 'data/8.Regression/setHtml/lego10189.html', 2008, 5922, 299.99)
    53.     scrapePage(retX, retY, 'data/8.Regression/setHtml/lego10196.html', 2009, 3263, 249.99)
    54.  
    55.  
    56. # 交叉验证测试岭回归
    57. def crossValidation(xArr,yArr,numVal=10):
    58.     # 获得数据点个数，xArr和yArr具有相同长度
    59.     m = len(yArr)
    60.     indexList = range(m)
    61.     errorMat = zeros((numVal,30))
    62.  
    63.     # 主循环 交叉验证循环
    64.     for i in range(numVal):
    65.         # 随机拆分数据，将数据分为训练集（90%）和测试集（10%）
    66.         trainX=[]; trainY=[]
    67.         testX = []; testY = []
    68.  
    69.         # 对数据进行混洗操作
    70.         random.shuffle(indexList)
    71.  
    72.         # 切分训练集和测试集
    73.         for j in range(m):
    74.             if j < m*0.9: 
    75.                 trainX.append(xArr[indexList[j]])
    76.                 trainY.append(yArr[indexList[j]])
    77.             else:
    78.                 testX.append(xArr[indexList[j]])
    79.                 testY.append(yArr[indexList[j]])
    80.  
    81.         # 获得回归系数矩阵
    82.         wMat = ridgeTest(trainX,trainY)
    83.  
    84.         # 循环遍历矩阵中的30组回归系数
    85.         for k in range(30):
    86.             # 读取训练集和数据集
    87.             matTestX = mat(testX); matTrainX=mat(trainX)
    88.             # 对数据进行标准化
    89.             meanTrain = mean(matTrainX,0)
    90.             varTrain = var(matTrainX,0)
    91.             matTestX = (matTestX-meanTrain)/varTrain
    92.  
    93.             # 测试回归效果并存储
    94.             yEst = matTestX * mat(wMat[k,:]).T + mean(trainY)
    95.  
    96.             # 计算误差
    97.             errorMat[i,k] = ((yEst.T.A-array(testY))**2).sum()
    98.  
    99.     # 计算误差估计值的均值
    100.     meanErrors = mean(errorMat,0)
    101.     minMean = float(min(meanErrors))
    102.     bestWeights = wMat[nonzero(meanErrors==minMean)]
    103.  
    104.     # 不要使用标准化的数据，需要对数据进行还原来得到输出结果
    105.     xMat = mat(xArr); yMat=mat(yArr).T
    106.     meanX = mean(xMat,0); varX = var(xMat,0)
    107.     unReg = bestWeights/varX
    108.  
    109.     # 输出构建的模型
    110.     print ("the best model from Ridge Regression is:\n",unReg)
    111.     print ("with constant term: ",-1*sum(multiply(meanX,unReg)) + mean(yMat))
    1. # test for standRegression
    2. def regression1():
    3.     xArr, yArr = loadDataSet("data/8.Regression/data.txt")
    4.     xMat = mat(xArr)
    5.     yMat = mat(yArr)
    6.     ws = standRegres(xArr, yArr)
    7.     fig = plt.figure()
    8.     ax = fig.add_subplot(
    9.         111)  # add_subplot(349)函数的参数的意思是，将画布分成3行4列图像画在从左到右从上到下第9块
    10.     ax.scatter(
    11.         [xMat[:, 1].flatten()],
    12.         [yMat.T[:, 0].flatten().A[0]])  # scatter 的x是xMat中的第二列，y是yMat的第一列
    13.     xCopy = xMat.copy()
    14.     xCopy.sort(0)
    15.     yHat = xCopy * ws
    16.     ax.plot(xCopy[:, 1], yHat)
    17.     plt.show()
    18.     # test for LWLR
    19. def regression2():
    20.     xArr, yArr = loadDataSet("data/8.Regression/data.txt")
    21.     yHat = lwlrTest(xArr, xArr, yArr, 0.003)
    22.     xMat = mat(xArr)
    23.     srtInd = xMat[:, 1].argsort(
    24.         0)  #argsort()函数是将x中的元素从小到大排列，提取其对应的index(索引)，然后输出
    25.     xSort = xMat[srtInd][:, 0, :]
    26.     fig = plt.figure()
    27.     ax = fig.add_subplot(111)
    28.     ax.plot(xSort[:, 1], yHat[srtInd])
    29.     ax.scatter(
    30.         [xMat[:, 1].flatten().A[0]], [mat(yArr).T.flatten().A[0]],
    31.         s=2,
    32.         c='red')
    33.     plt.show()
    34.     # test for abloneDataSet
    35. def abaloneTest():
    36.     '''
    37.     Desc:
    38.         预测鲍鱼的年龄
    39.     Args:
    40.         None
    41.     Returns:
    42.         None
    43.     '''
    44.     # 加载数据
    45.     abX, abY = loadDataSet("data/8.Regression/abalone.txt")
    46.     # 使用不同的核进行预测
    47.     oldyHat01 = lwlrTest(abX[0:99], abX[0:99], abY[0:99], 0.1)
    48.     oldyHat1 = lwlrTest(abX[0:99], abX[0:99], abY[0:99], 1)
    49.     oldyHat10 = lwlrTest(abX[0:99], abX[0:99], abY[0:99], 10)
    50.     # 打印出不同的核预测值与训练数据集上的真实值之间的误差大小
    51.     print(("old yHat01 error Size is :", rssError(abY[0:99], oldyHat01.T)))
    52.     print(("old yHat1 error Size is :", rssError(abY[0:99], oldyHat1.T)))
    53.     print(("old yHat10 error Size is :", rssError(abY[0:99], oldyHat10.T)))
    54.  
    55.     # 打印出 不同的核预测值 与 新数据集（测试数据集）上的真实值之间的误差大小
    56.     newyHat01 = lwlrTest(abX[100:199], abX[0:99], abY[0:99], 0.1)
    57.     print(("new yHat01 error Size is :", rssError(abY[0:99], newyHat01.T)))
    58.     newyHat1 = lwlrTest(abX[100:199], abX[0:99], abY[0:99], 1)
    59.     print(("new yHat1 error Size is :", rssError(abY[0:99], newyHat1.T)))
    60.     newyHat10 = lwlrTest(abX[100:199], abX[0:99], abY[0:99], 10)
    61.     print(("new yHat10 error Size is :", rssError(abY[0:99], newyHat10.T)))
    62.  
    63.     # 使用简单的 线性回归 进行预测，与上面的计算进行比较
    64.     standWs = standRegres(abX[0:99], abY[0:99])
    65.     standyHat = mat(abX[100:199]) * standWs
    66.     print(("standRegress error Size is:", rssError(abY[100:199], standyHat.T.A)))
    67.     # test for ridgeRegression
    68. def regression3():
    69.     abX, abY = loadDataSet("data/8.Regression/abalone.txt")
    70.     ridgeWeights = ridgeTest(abX, abY)
    71.     fig = plt.figure()
    72.     ax = fig.add_subplot(111)
    73.     ax.plot(ridgeWeights)
    74.     plt.show()
    75.  
    76.  
    77. # test for stageWise
    78. def regression4():
    79.     xArr, yArr = loadDataSet("data/8.Regression/abalone.txt")
    80.     stageWise(xArr, yArr, 0.01, 200)
    81.     xMat = mat(xArr)
    82.     yMat = mat(yArr).T
    83.     xMat = regularize(xMat)
    84.     yM = mean(yMat, 0)
    85.     yMat = yMat - yM
    86.     weights = standRegres(xMat, yMat.T)
    87.     print(weights.T)
    88.  
    89.  
    90. # predict for lego's price
    91. def regression5():
    92.     lgX = []
    93.     lgY = []
    94.  
    95.     setDataCollect(lgX, lgY)
    96.     crossValidation(lgX, lgY, 10)
    1. regression1()
    2. regression2()
    3. abaloneTest()
    4. regression3()
    5. regression4()
    6. regression5()

  • 相关阅读:
    第三次作业
    精通数据集成：轻易云数据集成平台应用实战与技术内幕
    React报错之Style prop value must be an object
    力扣每日一题63：不同路径||
    多线程与高并发——并发编程（4）
    Word如何任意页开始插入页码
    pytorch模型转换为rknn模型，使用npu推理
    最小二乘法的实现与线性回归的应用
    dp练习题
    在中国 ToB 市场，选一个对的供应商太难了
  • 原文地址：https://blog.csdn.net/qq_36973725/article/details/132715461