线性回归
最小二乘法
回归系数存放在w向量中，则Xw=y，即线性方程组
所以预测数据向量w即可得到预测值
此还可写为行向量列向量，对其求导得：
求导后导数为0的点即为我们要的极值，我们要平方误差最小嘛
所以得到此时
此方法即为我们最熟悉的最小二乘法，也叫做OLS(ordinary least squares)(普通最小二乘法)
from numpy import *
def loadDataSet(fileName): #general function to parse tab -delimited floats
numFeat = len(open(fileName).readline().split('\t')) - 1 #get number of fields
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
xTx = xMat.T*xMat
if linalg.det(xTx) == 0.0:
print "This matrix is singular, cannot do inverse"
return
ws = xTx.I * (xMat.T*yMat)
return ws
第一个函数loadDataSet，即为最常见的文本处理，提取关键元素，获得训练集的特征矩阵。
第二个函数standRegres，即为最小二乘法的代码实现，他判断了一步xTx的行列式的值，毕竟若为0，则没有逆元，无法使用公式。
局部加权线性回归
局部加权线性回归(Locally Weighted Linear Regression,LWLR)，是在最小二乘法的基础上，对每一个点上加上权重,即在刚才的w上做一些改变。
而这个权重大小是根据核函数（在支持向量机中提及到过）
本次使用的最常见的高斯核
def lwlr(testPoint,xArr,yArr,k=1.0):
xMat = mat(xArr); yMat = mat(yArr).T
m = shape(xMat)[0]
weights = mat(eye((m)))
for j in range(m): #next 2 lines create weights matrix
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:
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): #loops over all the data points and applies lwlr to each one
m = shape(testArr)[0]
yHat = zeros(m)
for i in range(m):
yHat[i] = lwlr(testArr[i],xArr,yArr,k)
return yHat
第一个函数lwlr，第一个参数testpoint是要测试的目标特征向量。第一个函数会输出对testpoint的预测值。
而第二个函数lwlrtest会调用到lwlr，他的第一个函数是testArr，其为目标矩阵，输出目标矩阵对应的预测值的集合向量。
缩减系数
当数据的特征比样本点还多时，此时xTx定不是满秩方阵，那么其行列式的值一定为0，则无法求逆。
发现刚才每次都要对xTx求行列式值，现在要着手解决这种问题。
另外若xTx行列式很小，那么求逆后得到回归系数会极大，也将失去意义
以下为损失函数
J(β)=∑(y−Xβ) ^2
现在对其进行正则化
什么是正则化？
正则化就是在损失函数后加上一个正则化项（惩罚项），其实就是常说的结构风险最小化策略，即经验风险（损失函数）加上正则化。一般模型越复杂，正则化值越大。
上面的式子就是结构风险最小化策略的通用表达式，其中第2项（绿色标记的部分）就是本文要讲的正则化项，第1项就是损失函数。可能你会问，有第一项不就可以将训练数据拟合得很好嘛，模型的表现也会很棒吗？没错，但是在监督学习中，我们同时更加关注测试数据在模型上的表现，也就是模型的泛化能力。
监督机器学习问题归根结底就是“minimizeyour error while regularizing your parameters”，也就是说规则化参数的同时最小化误差。最小化误差是为了让我们的模型更好的拟合训练数据，而规则化参数是防止模型过分拟合我们的训练数据（overfiting）。多么简约的哲学啊！因为模型参数太多会导致模型复杂度上升，容易发生过拟合，也就是训练误差会很小。但我们的最终目标不仅是训练误差小，而且更关注模型的测试误差是否也很小，目的是能准确的预测新的样本。所以，我们需要保证模型“简单”的基础上最小化训练误差，这样得到的参数才有比较好的泛化性能，而要使得模型“简单”就是通过规则函数来实现，也就是正则化。
说了半天，其实总结就是一句话，正则化的目的就是防止过拟合！
常见正则化方式有两种：L1正则化和L2正则化
而这两个正则化方式催生出了两种回归方式。
岭回归
这是L2正则化，因为它在损失函数后加了L2范数。
def rssError(yArr,yHatArr): #yArr and yHatArr both need to be arrays
return ((yArr-yHatArr)**2).sum()
def ridgeRegres(xMat,yMat,lam=0.2):
xTx = xMat.T*xMat
denom = xTx + eye(shape(xMat)[1])*lam
if linalg.det(denom) == 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 #to eliminate X0 take mean off of Y
#regularize X's
xMeans = mean(xMat,0) #calc mean then subtract it off
xVar = var(xMat,0) #calc variance of Xi then divide by it
xMat = (xMat - xMeans)/xVar
numTestPts = 30
wMat = zeros((numTestPts,shape(xMat)[1]))
for i in range(numTestPts):
ws = ridgeRegres(xMat,yMat,exp(i-10))
wMat[i,:]=ws.T
return wMat
第一个函数rssError是用来算误差的
第二个函数ridgeRegres是根据lam来计算的回归系数
第三个函数ridgeTest中运用了ridgeRegres来计算其中的回归系数，而使用numTestPts=30来控制了lam的取值，把每一次迭代得到的lam所产生的回归系数求出来，然后放到了矩阵wMat中（注意：此时numTestPts的大小在后面交叉验证中有使用的）
lasso
L1正则化
岭回归无法剔除变量，而LASSO回归模型，将惩罚项由L2范数变为L1范数，可以将一些不重要的回归系数缩减为0，达到剔除变量的目的。
import pandas as pd
import numpy as np
from sklearn import model_selection
from sklearn.linear_model import Lasso,LassoCV
from sklearn.metrics import mean_squared_error
data=pd.read_excel(r'C:\Users\Administrator\Desktop\diabetes.xlsx')
data=data.drop(['AGE','SEX'],axis=1)
#拆分为训练集和测试集
predictors=data.columns[:-1]
x_train,x_test,y_train,y_test=model_selection.train_test_split(data[predictors],data.Y,
test_size=0.2,random_state=1234)
#构造不同的lambda值
Lambdas=np.logspace(-5,2,200)
#设置交叉验证的参数，使用均方误差评估
lasso_cv=LassoCV(alphas=Lambdas,normalize=True,cv=10,max_iter=10000)
lasso_cv.fit(x_train,y_train)
#基于最佳lambda值建模
lasso=Lasso(alpha=lasso_cv.alpha_,normalize=True,max_iter=10000)
lasso.fit(x_train,y_train)
#打印回归系数
print(pd.Series(index=['Intercept']+x_train.columns.tolist(),
data=[lasso.intercept_]+lasso.coef_.tolist()))
#模型评估
lasso_pred=lasso.predict(x_test)
#均方误差
MSE=mean_squared_error(y_test,lasso_pred)
print(MSE)
λ的选择
当λ过大，则偏离真实数据过多，影响结果。
但当λ过小，则无济于事还是会造成行列式的值无限趋于0，也失去了最初的效果。
首先可以使用sklearn内置包
import pandas as pd
import numpy as np
from sklearn import model_selection
from sklearn.linear_model import RidgeCV
data=pd.read_excel(r'C:\Users\Administrator\Desktop\diabetes.xlsx')
#拆分为训练集和测试集
predictors=data.columns[:-1]
x_train,x_test,y_train,y_test=model_selection.train_test_split(data[predictors],data.Y,
test_size=0.2,random_state=1234)
#构造不同的lambda值
Lambdas=np.logspace(-5,2,200)
#设置交叉验证的参数，使用均方误差评估
ridge_cv=RidgeCV(alphas=Lambdas,normalize=True,scoring='neg_mean_squared_error',cv=10)
ridge_cv.fit(x_train,y_train)
print(ridge_cv.alpha_)
还有就是交叉验证法，虽然上面也是交叉验证思想，但是借助了sklearn，我们现在人为用交叉验证测试岭回归。
def crossValidation(xArr,yArr,numVal=10):
m = len(yArr)
indexList = range(m)
errorMat = zeros((numVal,30))#create error mat 30columns numVal rows
for i in range(numVal):
trainX=[]; trainY=[]
testX = []; testY = []
random.shuffle(indexList)
for j in range(m):#create training set based on first 90% of values in indexList
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) #get 30 weight vectors from ridge
for k in range(30):#loop over all of the ridge estimates
matTestX = mat(testX); matTrainX=mat(trainX)
meanTrain = mean(matTrainX,0)
varTrain = var(matTrainX,0)
matTestX = (matTestX-meanTrain)/varTrain #regularize test with training params
yEst = matTestX * mat(wMat[k,:]).T + mean(trainY)#test ridge results and store
errorMat[i,k]=rssError(yEst.T.A,array(testY))
#print errorMat[i,k]
meanErrors = mean(errorMat,0)#calc avg performance of the different ridge weight vectors
minMean = float(min(meanErrors))
bestWeights = wMat[nonzero(meanErrors==minMean)]
#can unregularize to get model
#when we regularized we wrote Xreg = (x-meanX)/var(x)
#we can now write in terms of x not Xreg: x*w/var(x) - meanX/var(x) +meanY
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
print "with constant term: ",-1*sum(multiply(meanX,unReg)) + mean(yMat)
前两个参数是数据集的list形式，第三个参数为交叉验证的迭代次数。
用random.shuffle函数对其中元素进行混洗，90％为训练集，其余为测试集。在岭回归中ridgeTest中使用30个不同的λ来创建了30组不同的回归系数。现在在上面这个函数中对其进行排序，从而找到最好的那个λ。
前向逐步回归
数据标准化，使其分布满足0均值和单位方差
在每轮迭代过程中：
设置当前最小误差lowestError为正无穷
对每个特征：
增大或减小：
改变一个系数得到一个新的W
计算新W下的误差
如果误差Error小于当前最小误差lowestError：设置Wbest等于当前的W
将W设置为新的Wbest
def regularize(xMat):#regularize by columns
inMat = xMat.copy()
inMeans = mean(inMat,0) #calc mean then subtract it off
inVar = var(inMat,0) #calc variance of Xi then divide by it
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 #can also regularize ys but will get smaller coef
xMat = regularize(xMat)
m,n=shape(xMat)
returnMat = zeros((numIt,n)) #testing code remove
ws = zeros((n,1)); wsTest = ws.copy(); wsMax = ws.copy()
for i in range(numIt):#could change this to while loop
#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
扫一扫
2193
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
