标签：实战 01 xArr 笔记 学习 yArr ws 2007 xMat
回归的一般方法
（1）收集数据：可以使用任何方法收集数据
（2）准备数据：回归需要数值型数据，标称型数据将被转换成二值型数据
（3）分析数据： 绘出数据的可视化二维图将有助于对数据做出理解和分析，在采用缩减法求得新回归系数之后，可以将新拟合线绘再图上作为对比
（4）训练算法：找到回归系数
（5）测试算法：使用R2 或者预测值和数据的拟合度，来分析模型的效果
（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的形式如下：
ω^=（XTWX）−1XTWy
LWLR 使用“核”（与支持向量机中的核类似）来对附近点赋予更高的权重。最常用高斯核，对用权重如下：
ω(i,i)=exp⎝⎛−2k2∣∣∣x(i)−x∣∣∣⎠⎞
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
岭回归使用了单位矩阵乘以常量λ,其中单位矩阵I，可以看到值1贯穿整个对角线，其余元素全是0，形象地在0构成的平面上有一天1组成的岭，回归系数计算公式
ω^=（XTX+λI）−1XTy
岭回归最先用来处理特征数多于样本的情况，现在也用于再估计总加入偏差，从而得到更好的估计，这里通过引入λ来限制所有ω之和，通过引入惩罚项，能够减少不重要的参数，这个技术在统计学中也叫做缩减（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]])
标签：实战,01,xArr,笔记,学习,yArr,ws,2007,xMat 来源： https://blog.csdn.net/liuxf570/article/details/97124703
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。