《机器学习实战》笔记——regression

本章介绍了不同场景下使用的线性回归方法

一般情况：简单的线性回归

欠拟合：局部加权线性回归

特征数大于样本数：岭回归 或 lasso法

最后引出交叉验证，用来定量地找到最佳参数值

# _*_ coding:utf-8_*_

# 8-1 标准回归函数和数据导入函数
from numpy import *
# 将数据格式化
def loadDataSet(fileName):
    numFeat = len(open(fileName).readlines()[0].split('	')) - 1
    dataMat = []
    labelMat = []
    fr = open(fileName)
    for line in fr.readlines():
        lineArr = []
        curLine = line.strip().split('	')
        for i in range(numFeat):    # float()不能将整个list中的元素进行类型转换，所以用一个循环，一个元素一个元素地转换
            lineArr.append(float(curLine[i]))
        dataMat.append(lineArr)
        labelMat.append(float(curLine[-1]))
    return dataMat, labelMat

# 计算系数向量w的最佳估计，其中要求xTx的逆，所以先要判断它是否为满秩矩阵（行列式不为0），
# 若否，则不能进一步计算。这里并没有提供伪逆矩阵的做法
def standRegres(xArr, yArr):    # 矩阵相乘要把结构改成matrix,否则array的*只能对元素进项相乘
    xMat = mat(xArr)
    yMat = mat(yArr).T
    xTx = xMat.T * xMat
    if linalg.det(xTx) == 0.0:  # numpy提供了一个线性代数库linalg(linear algebra),
                                # 其中包含计算行列式（determinant）的方法det(),
                                # 为什么可以用==比较浮点数？？？？？？？？？？？？？
        print "This matrix is singular, cannot do inverse"
        return
    ws = xTx.I * (xMat.T * yMat)
    return ws

# 效果

xArr,yArr = loadDataSet('ex0.txt')
print xArr[0:2]

ws = standRegres(xArr,yArr)

xMat=mat(xArr)
yMat=mat(yArr)
yHat=xMat*ws    #y的预测值

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(xMat[:,1].flatten().A[0],yMat.T[:,0].flatten().A[0],10)    # flatten()方法能将matrix的元素变成一维的，
                                    # .A能使matrix变成array  .A[0]能少一个[] 虽然我不明白到底什么意思，以后注意一下
                                    # 另外，为什么前两个参数需要转变成array？明明matrix也能画出来
print (corrcoef(yHat.T, yMat))

xCopy = xMat.copy()
xCopy.sort(0)
yHat = xCopy *ws
ax.plot(xCopy[:,1],yHat,'red')


plt.show()


# 8-2 局部加权线性回归函数
def lwlr(testPoint, xArr, yArr, k=1.0): # 参数k控制衰减速度; testPoint为输入，函数返回根据加权线性回归得出的预测值
    xMat = mat(xArr)
    yMat = mat(yArr).T
    m = shape(xMat)[0]
    weights = mat(eye(m))
    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:
        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

xArr,yArr = loadDataSet('ex0.txt')
yHat = lwlrTest(xArr, xArr, yArr, 0.01)
xMat = mat(xArr)
srtInd = xMat[:,1].argsort(0)   # argsort()方法返回的是排序后个元素排序前的下标
xSort = xMat[srtInd][:,0,:] # 这个功能看懂了 但是语法没搞懂？？？？？？？

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()


# 8-3 岭回归(xTx肯定不是满秩矩阵，加上一个lam*I使其变为满秩的，I是单位矩阵)

def ridgeRegres(xMat, yMat, lam=0.2):
    xTx = xMat.T * xMat
    denom = xTx+lam*eye(len(xTx[0]))
    if linalg.det(denom) == 0.0:
        print "this matrix is not 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下调用ridgeRegres()函数
    wMat = zeros((numTestPts, shape(xMat)[1]))
    for i in range(numTestPts):
        ws = ridgeRegres(xMat, yMat, exp(i-10)) # lambda以指数级变化，这样能看出lambda在去非常小的值时和取非常大的值时对结果造成的影响
        wMat[i,:]=ws.T
    return wMat

# 8-4 前向逐步线性回归

# 标准化特征（书上漏了这部分）
def regularize(xMat):
    inMat = xMat.copy()
    inMeans = mean(inMat,0)
    inVar = var(inMat,0)
    inMat = (inMat - inMeans)/inVar
    return inMat

def rssError(yArr, yHatArr):
    return ((yArr-yHatArr)**2).sum()

# 对每个特征，将他的系数从一个初始值开始以特定步长增大或减少，一旦误差变小就用lowestError来记录最小误差，用wsMax来记录最优权重。
def stageWise(xArr, yArr, eps=0.01, numIt=100): # eps表示每次迭代需要调整的步长
    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