机器学习实战学习笔记4-预测数值型数据:回归

2019/7/24 13:33:01 人评论 次浏览 分类:学习教程

回归的一般方法

(1)收集数据:可以使用任何方法收集数据

(2)准备数据:回归需要数值型数据,标称型数据将被转换成二值型数据

(3)分析数据: 绘出数据的可视化二维图将有助于对数据做出理解和分析,在采用缩减法求得新回归系数之后,可以将新拟合线绘再图上作为对比

(4)训练算法:找到回归系数

(5)测试算法:使用R2R^2 或者预测值和数据的拟合度,来分析模型的效果

(6)使用算法:使用回归,可以在给定输入的时候预测出一个数值,这是对分类方法的提升,因为这样可以预测连续型数据而不仅仅是离散的类别标签

程序清单8-1 标准回归函数和数据导入函数

from numpy import *
def loadDataSet(fileName):    
    numFeat = len(open(fileName).readline().split('\t')) - 1 #特征值个数
    dataMat = []; labelMat = []
    fr = open(fileName)
    for line in fr.readlines():
        lineArr =[]
        curLine = line.strip().split('\t')
        for i in range(numFeat):
            lineArr.append(float(curLine[i]))
        dataMat.append(lineArr)
        labelMat.append(float(curLine[-1]))
    return dataMat,labelMat
def standRegres(xArr,yArr):
    xMat = mat(xArr);yMat = mat(yArr).T #xMat:200*2, yMat:1*200
    xTx = xMat.T*xMat #xTx:2*2
    #print(xTx)
    if linalg.det(xTx) == 0.0:  # 判断行列式是否为0 linalg.det()计算行列式,,需要判断矩阵行列式不为零,否则不能直接求逆。
        print("This matrix is singular,cannot do inverse") #这个矩阵是奇异的,不能做逆矩阵
        return
    ws = xTx.I * (xMat.T * yMat)  #xTx.I,矩阵的逆矩阵,也可以写成 ws = linalg.solve(xTx,xMat.T * yMat)
    #np.linalg.inv():矩阵求逆
    #np.linalg.det():矩阵求行列式(标量)
    #solve函数可以求解多元一次方程组
    return ws 

xArr,yArr = loadDataSet('ex0.txt')
#print(xArr)
shape(xArr)
(200, 2)
#print(yArr)
shape(yArr)
(200,)
ws=standRegres(xArr,yArr)
print(ws)
[[ 3.00774324]
 [ 1.69532264]]
xMat = mat(xArr)
#print(xMat)
yMat = mat(yArr)
yHat = xMat * ws
import matplotlib.pyplot as plt #--绘图
fig=plt.figure()
ax=fig.add_subplot(111)
#print(xMat[:,1].flatten())  #flatten是numpy.ndarray.flatten的一个函数,即返回一个一维数组。
#print(yMat.A[0])
#print(yMat.T[:,0].flatten().A[0])
ax.scatter(xMat[:,1].flatten().A[0],yMat.T[:,0].flatten().A[0]) #绘--原始数据

<matplotlib.collections.PathCollection at 0x93cea20>
xCopy = xMat.copy()
xCopy.sort(0) #将点按照feature2升序排列,all featrue1=1.0
#print(xCopy)
yHat = xCopy * ws
ax.plot(xCopy[:,1],yHat)
[<matplotlib.lines.Line2D at 0x5a3a9b0>]
plt.show()

在这里插入图片描述

yHat = xMat * ws

corrcoef(yHat.T,yMat) #numpy的corrcoef (yEstimate , yActual) 来计算预测值和真实值的相关性。yHat和yMat的相关系数是0.98
array([[ 1.        ,  0.98647356],
       [ 0.98647356,  1.        ]])

局部加权线性回归(Locally Weighted Linear Regression,LWLR)

给待预测点附近的每个点赋予一定的权重,该算法解出回归系数w的形式如下:

     ω^=XTWX1XTWy \hat{\omega}=(X^{T}WX)^{-1}X^{T}Wy

LWLR 使用“核”(与支持向量机中的核类似)来对附近点赋予更高的权重。最常用高斯核,对用权重如下:

     ω(i,i)=exp(x(i)x2k2) \omega (i,i)=exp\left ( \frac{\left | x^{^{(i)}}-x \right |}{-2k^{^{2}}} \right )

k=0.5 时,大部分的数据都用于训练回归模型,k=0.01,仅有很少数的局部点被用于训练回归模型

程序清单8-2 局部加权线性回归函数

def lwlr(testPoint,xArr,yArr,k=1.0):
    xMat = mat(xArr);yMat=mat(yArr).T
    m = shape(xMat)[0]  #200 行
    weights = mat(eye((m))) #创建1对角阵
    for j in range(m):
        diffMat = testPoint - xMat[j,:]
        weights[j,j] = exp(diffMat*diffMat.T/(-2.0*k**2)) #权重大小以指数级衰减
    xTx = xMat.T * (weights * xMat)
    if linalg.det(xTx) == 0.0:  # 判断行列式是否为0 linalg.det()计算行列式,,需要判断矩阵行列式不为零,否则不能直接求逆。
        print("This matrix is singular,cannot do inverse") #这个矩阵是奇异的,不能做逆矩阵
        return
    ws = xTx.I * (xMat.T * (weights*yMat))
    return testPoint * ws
def lwlrTest(testArr,xArr,yArr,k=1.0):
    m = shape(testArr)[0]
    yHat = zeros(m)
    for i in range(m):
        yHat[i] = lwlr(testArr[i],xArr,yArr,k)
    return yHat
lwlr(xArr[0],xArr,yArr,1.0)  # 对单点进行估计
print(xArr[0])
print(lwlr(xArr[0],xArr,yArr,1.0))
[1.0, 0.067732]
[[ 3.12204471]]
yArr[0]
3.176513
print(lwlr(xArr[0],xArr,yArr,0.001)) 
[[ 3.20175729]]
yHat = lwlrTest(xArr,xArr,yArr,0.003) #k = 0.003
xMat = mat(xArr)
srtInd = xMat[:,1].argsort(0) #rgsort函数返回的是数组值从小到大的索引值, #等价于argsort(xMat[:,1],0)
#print(srtInd)
xSort = xMat[srtInd][:,0,:] #200*2 #等价于xMat[srtInd.flatten().A[0]] 
#print(xSort)
import matplotlib.pyplot as plt #--绘图
fig=plt.figure()
ax=fig.add_subplot(111)
ax.plot(xSort[:,1],yHat[srtInd]) #绘--预测数据
ax.scatter(xMat[:,1].flatten().A[0],mat(yArr).T.flatten().A[0],s=2,c='red')#绘--原始数据
plt.show()

在这里插入图片描述

yHat = lwlrTest(xArr,xArr,yArr,0.01)#k = 0.01
xMat = mat(xArr)
srtInd = xMat[:,1].argsort(0) #rgsort函数返回的是数组值从小到大的索引值, #等价于argsort(xMat[:,1],0)
#print(srtInd)
xSort = xMat[srtInd][:,0,:] #200*2 #等价于xMat[srtInd.flatten().A[0]] 
#print(xSort)
import matplotlib.pyplot as plt #--绘图
fig=plt.figure()
ax=fig.add_subplot(111)
ax.plot(xSort[:,1],yHat[srtInd]) #绘--预测数据
ax.scatter(xMat[:,1].flatten().A[0],mat(yArr).T.flatten().A[0],s=2,c='red')#绘--原始数据
plt.show()

在这里插入图片描述

yHat = lwlrTest(xArr,xArr,yArr,1.0)#k = 1.0
xMat = mat(xArr)
srtInd = xMat[:,1].argsort(0) #rgsort函数返回的是数组值从小到大的索引值, #等价于argsort(xMat[:,1],0)
#print(srtInd)
xSort = xMat[srtInd][:,0,:] #200*2 #等价于xMat[srtInd.flatten().A[0]] 
#print(xSort)
import matplotlib.pyplot as plt #--绘图
fig=plt.figure()
ax=fig.add_subplot(111)
ax.plot(xSort[:,1],yHat[srtInd]) #绘--预测数据
ax.scatter(xMat[:,1].flatten().A[0],mat(yArr).T.flatten().A[0],s=2,c='red')#绘--原始数据
plt.show()

在这里插入图片描述

预测鲍鱼年龄

def rssError(yArr,yHatArr):
    return((yArr-yHatArr)**2).sum()
abX,abY = loadDataSet('abalone.txt')
yHat01 = lwlrTest(abX[0:99],abX[0:99],abY[0:99],0.1)
yHat1 = lwlrTest(abX[0:99],abX[0:99],abY[0:99],1)
yHat10 = lwlrTest(abX[0:99],abX[0:99],abY[0:99],10)
rssError(abY[0:99],yHat01.T)
56.825235689728842
rssError(abY[0:99],yHat1.T)
429.89056187006514
rssError(abY[0:99],yHat10.T)
549.11817088264513
yHat01 = lwlrTest(abX[100:199],abX[0:99],abY[0:99],0.1)
yHat1 = lwlrTest(abX[100:199],abX[0:99],abY[0:99],1)
yHat10 = lwlrTest(abX[100:199],abX[0:99],abY[0:99],10)
rssError(abY[100:199],yHat01.T)
41317.161723642595
rssError(abY[100:199],yHat1.T)
573.52614418976702
rssError(abY[100:199],yHat10.T)
517.57119053875977
ws = standRegres(abX[0:99],abY[0:99])
yHat = mat(abX[100:199])*ws
rssError(abY[100:199],yHat.T.A) # .A将矩阵转化为数组
518.63631532496379

岭回归使用了单位矩阵乘以常量λ\lambda,其中单位矩阵I,可以看到值1贯穿整个对角线,其余元素全是0,形象地在0构成的平面上有一天1组成的岭,回归系数计算公式

     ω^=XTX+λI1XTy \hat{\omega}=(X^{T}X+\lambda I)^{-1}X^{T}y

岭回归最先用来处理特征数多于样本的情况,现在也用于再估计总加入偏差,从而得到更好的估计,这里通过引入λ\lambda来限制所有ω\omega之和,通过引入惩罚项,能够减少不重要的参数,这个技术在统计学中也叫做缩减(shrinkage)

程序清单8-3 岭回归

def ridgeRegres(xMat,yMat,lam = 0.2):
    xTx = xMat.T*xMat #xTx:2*2
    denom = xTx + eye(shape(xMat)[1])*lam    
    if linalg.det(xTx) == 0.0:  
        print("This matrix is singular,cannot do inverse") 
        return
    ws = denom.I * (xMat.T * yMat)
    return ws 
def ridgeTest(xArr,yArr):
    xMat = mat(xArr);yMat=mat(yArr).T
    yMean = mean(yMat,0)  #数据标准化
    yMat = yMat - yMean
    xMeans = mean(xMat,0)
    xVar = var(xMat,0)
    xMat = (xMat-xMeans)/xVar#所有特征减去各自的均值并除以方差
    numTestPts = 30#取30个不同的lambda调用函数,30个不同的lambda值进行测试,选最优
    wMat = zeros((numTestPts,shape(xMat)[1]))
    for i in range(numTestPts):
        ws = ridgeRegres(xMat,yMat,exp(i-10))
        wMat[i,:] = ws.T
    return wMat

ridgeWeights = ridgeTest(abX,abY)
 #缩减效果图
import matplotlib.pyplot as plt
fig=plt.figure()
ax=fig.add_subplot(111)
ax.plot(ridgeWeights)
plt.show()

在这里插入图片描述

前向逐步回归算法的伪代码

数据标准化,使其分布满足0均值和单位方差

在每轮迭代过程中:

  设置当前最小误差lowestError为正无穷:

   对每个特征:

      增大或缩小:

        改变一个系数得到一个新的W

        计算新W小的误差

        如果误差Error小于当前最小误差lowestError:设置Wbest等于当前的W

   如果所有向量都没被优化,增加迭代数目,继续下一次循环

程序清单8-4 前向逐步线性回归

def regularize(xMat):#regularize 标准化
    inMat = xMat.copy()
    inMeans= mean(inMat,0)
    inVar = var(inMat,0)
    inMat = (inMat - inMeans)/inVar
    return inMat

def stageWise(xArr,yArr,eps = 0.01,numIt=100):
    xMat = mat(xArr);yMat=mat(yArr).T
    yMean = mean(yMat,0)  #数据标准化
    yMat = yMat - yMean
    xMat = regularize(xMat)
    m,n = shape(xMat)
    returnMat = zeros((numIt,n))
    ws = zeros((n,1))
    wsTest = ws.copy()
    wsMax = ws.copy()
    for i in range(numIt):
        print(ws.T)
        lowestError = 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
    return returnMat
xArr, yArr = loadDataSet('abalone.txt')
#stageWeights=stageWise(xArr,yArr,0.001,5000)
import matplotlib.pyplot as plt
fig=plt.figure()
ax=fig.add_subplot(111)
ax.plot(stageWeights)
plt.show()

在这里插入图片描述

用回归法预测乐高套装的价格

(1)收集数据:用Google Shopping的API收集数据

(2)准备数据:返回的JSON数据中抽取价格

(3)分析数据: 可视化并观察数据

(4)训练算法:构建不同的模型,采用逐步线性回归和直接的线性回归模型

(5)测试算法:使用交叉验证测试不同的模型,来分析哪个效果最好

(6)使用算法:这次练习的目标就是生成数据模型

#原文中通过Google提供的API来抓取价格,但由于现在访问不了Google,所以,直接通过文本给的html文件直接读取价格信息。然后进一步进行分析预测。

程序清单8-5 购物信息的获取函数

from bs4 import BeautifulSoup
import numpy as np
import random
def scrapePage(retX, retY, inFile, 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):
    scrapePage(retX, retY, 'lego8288.html', 2006, 800, 49.99)             
    scrapePage(retX, retY, 'lego10030.html', 2002, 3096, 269.99)          
    scrapePage(retX, retY, 'lego10179.html', 2007, 5195, 499.99)             
    scrapePage(retX, retY, 'lego10181.html', 2007, 3428, 199.99)               
    scrapePage(retX, retY, 'lego10189.html', 2008, 5922, 299.99)                
    scrapePage(retX, retY, 'lego10196.html', 2009, 3263, 249.99)
lgX = [];lgY=[]
setDataCollect(lgX,lgY)
E:\Anaconda3\lib\site-packages\bs4\__init__.py:181: UserWarning: No parser was explicitly specified, so I'm using the best available HTML parser for this system ("lxml"). This usually isn't a problem, but if you run this code on another system, or in a different virtual environment, it may use a different parser and behave differently.

The code that caused this warning is on line 193 of the file E:\Anaconda3\lib\runpy.py. To get rid of this warning, change code that looks like this:

 BeautifulSoup(YOUR_MARKUP})

to this:

 BeautifulSoup(YOUR_MARKUP, "lxml")

  markup_type=markup_type))


2006	800	0	49.990000	85.000000
2006	800	0	49.990000	102.500000
2006	800	0	49.990000	77.000000
商品 #4 没有出售
2006	800	0	49.990000	162.500000
2002	3096	0	269.990000	699.990000
2002	3096	0	269.990000	602.000000
2002	3096	0	269.990000	515.000000
2002	3096	0	269.990000	510.000000
2002	3096	0	269.990000	375.000000
2002	3096	1	269.990000	1050.000000
2002	3096	0	269.990000	740.000000
2002	3096	1	269.990000	759.000000
2002	3096	0	269.990000	730.000000
2002	3096	1	269.990000	750.000000
商品 #11 没有出售
2007	5195	0	499.990000	910.000000
2007	5195	1	499.990000	1199.990000
2007	5195	0	499.990000	811.880000
商品 #4 没有出售
2007	5195	0	499.990000	1324.790000
2007	5195	1	499.990000	850.000000
2007	5195	1	499.990000	800.000000
2007	5195	0	499.990000	810.000000
2007	5195	1	499.990000	1075.000000
2007	5195	0	499.990000	1050.000000
2007	5195	1	499.990000	1199.990000
2007	5195	0	499.990000	1342.310000
2007	5195	1	499.990000	1000.000000
2007	5195	0	499.990000	1780.000000
2007	5195	0	499.990000	750.000000
商品 #16 没有出售
2007	5195	0	499.990000	2204.990000
商品 #18 没有出售
2007	5195	1	499.990000	925.000000
2007	5195	0	499.990000	860.000000
商品 #21 没有出售
商品 #22 没有出售
2007	5195	1	499.990000	1199.990000
2007	5195	1	499.990000	1099.990000
2007	5195	1	499.990000	1149.990000
2007	5195	1	499.990000	800.000000
2007	5195	1	499.990000	850.000000
2007	3428	0	199.990000	469.950000
2007	3428	0	199.990000	479.000000
2007	3428	0	199.990000	299.990000
2007	3428	0	199.990000	369.000000
2007	3428	1	199.990000	424.950000
2007	3428	1	199.990000	380.000000
2007	3428	0	199.990000	305.000000
2008	5922	1	299.990000	530.000000
商品 #2 没有出售
2008	5922	1	299.990000	599.950000
2008	5922	0	299.990000	510.000000
2008	5922	0	299.990000	423.000000
商品 #6 没有出售
商品 #7 没有出售
2008	5922	1	299.990000	599.990000
商品 #9 没有出售
2008	5922	1	299.990000	589.990000
2008	5922	1	299.990000	569.990000
2008	5922	1	299.990000	529.990000
2008	5922	0	299.990000	500.000000
2008	5922	1	299.990000	549.950000
2008	5922	0	299.990000	300.000000
商品 #16 没有出售
2009	3263	1	249.990000	380.000000
2009	3263	1	249.990000	399.000000
2009	3263	1	249.990000	427.990000
2009	3263	0	249.990000	360.000000
商品 #5 没有出售
商品 #6 没有出售
2009	3263	1	249.990000	399.000000
2009	3263	1	249.990000	399.950000
2009	3263	1	249.990000	499.990000
商品 #10 没有出售
2009	3263	0	249.990000	399.950000
商品 #12 没有出售
2009	3263	1	249.990000	331.510000
shape(lgX)
(63, 4)
#print(lgX)
lgX1 = mat(ones((63,5)))
lgX1[:,1:5] = mat(lgX)
lgX[0]
[2006, 800, 0.0, 49.99]
lgX1[0]
matrix([[  1.00000000e+00,   2.00600000e+03,   8.00000000e+02,
           0.00000000e+00,   4.99900000e+01]])
ws = standRegres(lgX1,lgY)
ws
matrix([[  5.53199701e+04],
        [ -2.75928219e+01],
        [ -2.68392234e-02],
        [ -1.12208481e+01],
        [  2.57604055e+00]])
lgX1[0]*ws
matrix([[ 76.07418847]])
ws
matrix([[  5.53199701e+04],
        [ -2.75928219e+01],
        [ -2.68392234e-02],
        [ -1.12208481e+01],
        [  2.57604055e+00]])
lgX1[-1]*ws
matrix([[ 431.17797665]])
lgX1[43]*ws
matrix([[ 516.20733099]])

程序清单8-6 交叉验证测试岭回归


def crossValidation(xArr,yArr,numVal = 10):
    m = len(yArr)
    indexList = list(range(m))  #代码这里要修改
    #创建numVal*30的误差矩阵
    ##30的由来:ridgeTest()使用了30个不同的lambda值来创建不同的回归系数,即numTestPts = 30
    errorMat = zeros((numVal,30))
    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组ws向量
        for k in range(30):
            #用训练时的参数将测试数据标准化
            matTestX = mat(testX);
            matTrainX = mat(trainX)
            meanTrain = mean(matTrainX,0)
            varTrain = var(matTrainX,0)
            matTestX = (matTestX - meanTrain)/varTrain
            yEst = matTestX * mat(wMat[k,:]).T +mean(trainY)
            errorMat[i,k]=rssError(yEst.T.A,array(testY))
    #计算不同岭回归ws下errorMat的平均值,观察平均性能  
    #meanErrors:1*30矩阵
    meanErrors=mean(errorMat,0)
    minMean = float(min(meanErrors))
     #nonzero(meanErrors==minMean)返回的是误差最小的索引,因此bestWeights为误差最小的那个w向量
    bestWeights = wMat[nonzero(meanErrors == minMean)]
     #岭回归使用了数据标准化,而standRegres没有,为了比较可视化,因此需要将数据还原
    #标准化后 Xreg = (x-meanX)/var(x),预测y=Xreg*w+meanY
    #因此,利用未标准化的x来计算y= x*w/var(x) - meanX*w/var(x) +meanY
    #其中unReg=w/var
    xMat = mat(xArr)
    yMat = mat(yArr).T
    meanX = mean(xMat,0)
    varX = var(xMat,0)
    unReg = bestWeights / varX
    #数据还原
    print("the best model from Ridge Regression is:\n",unReg)
     #特别注意这里的sum函数,一定是np.sum,因为一般的sum只能对list求和,而这里的参数是matrix
    print("with constant term:",-1*sum(multiply(meanX,unReg))+mean(yMat))
          
crossValidation(lgX,lgY,10)
the best model from Ridge Regression is:
 [[ -3.34922409e+01   4.90836452e-04   1.90316935e+01   2.08853435e+00]]
with constant term: 67188.4053238
ridgeTest(lgX,lgY)
array([[ -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],
       [ -1.37402474e+02,   1.64217093e+03,   1.95840783e+00,
          3.44932120e+04],
       [ -1.24750588e+02,   1.44326171e+03,   7.62540167e+00,
          2.50647592e+04],
       [ -1.10234679e+02,   8.81842164e+02,   1.40617304e+01,
          1.43874420e+04],
       [ -9.96484167e+01,   4.17805568e+02,   1.87140361e+01,
          6.66770425e+03],
       [ -9.40345090e+01,   1.71289137e+02,   2.10844952e+01,
          2.71206176e+03],
       [ -9.11400659e+01,   6.57287394e+01,   2.20487105e+01,
          1.03800465e+03],
       [ -8.86246985e+01,   2.45452725e+01,   2.23181664e+01,
          3.87564774e+02],
       [ -8.41447674e+01,   9.05861459e+00,   2.21495534e+01,
          1.43313895e+02],
       [ -7.44804291e+01,   3.31863501e+00,   2.14607512e+01,
          5.27810178e+01],
       [ -5.68008473e+01,   1.20770663e+00,   2.00168153e+01,
          1.93999701e+01],
       [ -3.43546503e+01,   4.38238026e-01,   1.77836684e+01,
          7.12719906e+00],
       [ -1.62951276e+01,   1.59882766e-01,   1.48514658e+01,
          2.62234165e+00],
       [ -6.48291858e+00,   5.89025383e-02,   1.09847950e+01,
          9.67404902e-01],
       [ -2.35268585e+00,   2.18391027e-02,   6.61152257e+00,
          3.57478187e-01],
       [ -8.35001919e-01,   8.09519290e-03,   3.19552087e+00,
          1.32007993e-01],
       [ -2.99711902e-01,   2.99108326e-03,   1.33043325e+00,
          4.86659524e-02],
       [ -1.08982743e-01,   1.10249682e-03,   5.14449554e-01,
          1.79199150e-02],
       [ -3.99038878e-02,   4.05898142e-04,   1.92885670e-01,
          6.59479857e-03],
       [ -1.46534283e-02,   1.49365062e-04,   7.14631760e-02,
          2.42642878e-03],
       [ -5.38707897e-03,   5.49542829e-05,   2.63587872e-02,
          8.92679468e-04],
       [ -1.98130399e-03,   2.02173589e-05,   9.70622185e-03,
          3.28404700e-04],
       [ -7.28814363e-04,   7.43766021e-06,   3.57198872e-03,
          1.20814188e-04],
       [ -2.68106796e-04,   2.73617711e-06,   1.31423307e-03,
          4.44451712e-05],
       [ -9.86297565e-05,   1.00658531e-06,   4.83502591e-04,
          1.63504803e-05],
       [ -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]])

相关资讯

  • 那些我们不愿意承认的事

    很久没有见的老朋友,准确的说应该是很久没有见过的老师,一个比我大两岁的老师,我上初中的时候他从高中回来教我了一年。后来又回去上高中,我上高中的时候他上大学,现在我刚大学毕业他创办了公司。昨日一见依然如故,他还是热爱销售,而我却成了纯粹的技术人员。 看到他…

    2015/6/22 13:12:47

学习教程

共有访客发表了评论 网友评论

验证码: 看不清楚?
    -->