机器学习笔记之线性回归

本文的CSDN

写在前面的：

学习了大半学期的机器学习，通过这一次线性回归的学习过程，理一理思路，进行一个小总结，主要思路是先梳理一下老师给的两份代码，然后再进行梯度下降的实现。

线性回归

线性回归是一种x和y之间的关系为线性关系的回归分析。

实现线性回归的步骤：
1. 提取特征和标签
2. 建立训练数据和测试数据
3. 使用训练数据训练模型

方法一：使用sklearn包装

参考老师给的代码 testLinearRegAndTrainTest.py

1.建立有序的二维数据结构

#第一个参数为特征，第二个参数为标签
examDict={
    '学习时间':[0.50,0.75,1.00,1.25,1.50,1.75,1.75,2.00,2.25,
            2.50,2.75,3.00,3.25,3.50,4.00,4.25,4.50,4.75,5.00,5.50],
    '分数':    [10,  22,  13,  43,  20,  22,  33,  50,  62,
              48,  55,  75,  62,  73,  81,  76,  64,  82,  90,  93]
}
examOrderDict=OrderedDict(examDict)
exam=pd.DataFrame(examOrderDict)

因为字典本身是无序的，所以我们可以使用OrderDict使得其变得有序，同时使用Pandas的DataFrame可以将数据集转成二维数据结构进行处理。

2.提取出特征和标签

#从dataframe中把标签和特征导出来
exam_X = exam['学习时间']
exam_Y = exam['分数']

在这里第一个参数为特征，第二个参数为标签；特征就是数据的属性，标签是对数据的预测结果；例如：一件衣服，颜色和款式是特征，我喜不喜欢就是标签；一个水果，色泽和大小是特征，好不好吃就是标签。

3.建立训练数据和测试数据

#绘制散点图，得出结果后记得注释掉以下4行代码
plt.scatter(exam_X, exam_Y, color = 'green')
#设定X,Y轴标签和title
plt.ylabel('Scores')
plt.xlabel('Times(h)')
plt.title('Exam Data')
plt.show()

#划分训练集与测试集。
#比例为7：3
X_train, X_test, Y_train, Y_test = train_test_split(exam_X,exam_Y, train_size = 0.7)
#导入线性回归
#sklearn 要求输入的特征为二维数组类型。
#数据集只有1个特征，需要用array.reshape(-1, 1)来改变数组的形状

#改变一下数组的形状
X_train = X_train.values.reshape(-1, 1)
X_test = X_test.values.reshape(-1, 1)

首先需要从样本中随机的按比例选取训练数据（train）和测试数据（test），在这里比例是7:3；我们需要使用使用交叉验证中的(sklearn.model_selection)中的train_test_split。

(x_train、x_test、y_train、y_test 各分配到一定比例的数据）

train_test_split三个参数：
参数1：所要划分的样本特征
参数2：所要划分的标签特征
参数3：train_size= 小数（训练数据的占比)；整数（样本的数量）

4.使用训练数据训练模型

#创建一个模型
model = LinearRegression()
#训练一下
model.fit(X_train, Y_train)

#因为线性回归一般方程为y = a+bx
#b为斜率，a为截距
#截距用intercept_
#斜率用model.coef_
a = model.intercept_
b = model.coef_
a = float(a)
b = float(b)
print('该模型的简单线性回归方程为y = {} + {} * x'.format(a, b))

#绘制散点图
plt.scatter(exam_X, exam_Y, color = 'green', label = 'train data')
#设定X,Y轴标签和title
plt.ylabel('Scores')
plt.xlabel('Times(h)')

#绘制最佳拟合曲线
Y_train_pred = model.predict(X_train)
plt.plot(X_train, Y_train_pred, color = 'black', label = 'best line')

创建模型使用使用sklearn.linear_model中的LinearRegression导入线性回归并创建训练模型，使用fit函数训练模型。

5.使用测试数据进行模型评估

##测试
jingdu = model.score(X_test, Y_test)
print('error %f' % jingdu)

使用score函数，评估模型准确度决定系数R平方。

方法二：使用方程

参考老师给的代码 linearReg.py

1.标准回归函数和数据导入函数

import matplotlib.pyplot as plt
import numpy as np

#loadDataSet()函数打开一个用tab键分隔的文本文件，这里默认文件每行的最后一个值是目标值。
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

#standRegres()函数用于计算最佳拟合直线。
#该函数首先读入x和y并将它们保存到矩阵中，然后计算xTx，然后判断它的行列式是否为0。
#如果行列式为0，那么计算逆矩阵的时候将出现错误。
def standRegres(xArr,yArr):
    xMat = np.mat(xArr); yMat = np.mat(yArr).T
    xTx = xMat.T*xMat
    if np.linalg.det(xTx) == 0.0:
        print ("This matrix is singular, cannot do inverse")
        return
    ws = xTx.I * (xMat.T*yMat)
    return ws

2.使用loadDataSet()函数将从数据中得到两个数组，分别存放在x和y中。与分类算法中的类别标签类似。(这里的y是目标值)

xArr,yArr = loadDataSet('/路径/ex0.txt')

3.standRegres()函数的执行效果

ws = standRegres(xArr,yArr)

变量ws存放的就是回归系数。在用内积来预测y的时候，第一维将乘以前面的常数x0，第二维将乘以输入变量x1。因为前面假设了x0=1，所以最终会得到y=ws[0]+ws[1]*x1。

4.使用新的ws值计算yHat

xMat = np.mat(xArr)
yMat = np.mat(yArr)
yHat = xMat*ws

5.绘出数据集散点图和最佳拟合直线图

fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(xMat[:,1].flatten().A[0],yMat.T[:,0].flatten().A[0])
xCopy = xMat.copy()
xCopy.sort(0)
yHat = xCopy*ws
ax.plot(xCopy[:,1],yHat)
plt.show()

Task:梯度下降的实现

梯度下降是一种非常通用的优化算法，能够为大范围的问题找到最优解。梯度下降的中心思想就是迭代地调整参数从而使成本函数最小化。

根据老师的讲解，我们的主要思路是将下图的两个公式以代码的形式表达出来。

思路：

y=ax+b+ε
y为应变量
x 为自变量
a为斜率
b为截距
\epsilon为误差

线性回归的目标是找到一组a、b使得\epsilon最小

即\hat{y}=ax+b

\epsilon=y-\hat{y}

\hat{y}表示估计值，对应下文的y_hat (markdown写法也是\hat{y}）

1.建立模型：y=ax+b

def model(a,b,x):
    return a*x+b

2.损失函数

在有了损失函数的情况下，我们才能进行后续的迭代遍历，根据最开始的公式，这里的损失函数相当于0.5倍的方差平均值（线性回归中，方差可以作为损失函数，最终目的也是为了找方差的最小值。）

def cost_function(a,b,x,y):
    y_hat = a*x+b
    n = len(x)
    return 0.5/(n*(np.square(y-y_hat)).sum())

3.优化

第二步我们找到了损失函数，那么我们还需要找到损失函数的最小值，也就是这里的优化方法，也就是计算损失的方向（正负），假设a变大，损失变小，那么我们就可以继续这个方向，损失函数的变化量，我们需要使用到偏微分

这一部分可以用如下代码实现：

import sympy

a = sympy.Symbol("a")
b = sympy.Symbol("b")
x = sympy.Symbol("x")
y = sympy.Symbol("y")

f_cost = 1.0/2 * (y - a*x - b)**2

print(f_cost)
#0.5*(-a*x - b + y)**2
print(sympy.diff(f_cost,a))
#-1.0*x*(-a*x - b + y)
print(sympy.diff(f_cost,b))
#1.0*a*x + 1.0*b - 1.0*y

优化部分代码：

def optimize(a,b,x,y):
    n = len(x)
    alpha = 1e-1
    y_hat = model(a,b,x)
    da = (1.0/n) * ((y_hat-y)*x).sum()
    db = (1.0/n) * ((y_hat-y).sum())
    a = a - alpha*da
    b = b - alpha*db
    return a, b

4.进行更新

首先初始化

a = 0
b = 0

进行遍历，通过模型我们可以计算出y_hat，继而可以去更新参数

def iterate(a,b,x,y,times):
    for i in range(times):
        a,b = optimize(a,b,x,y)

    y_hat=model(a,b,x)
    cost = cost_function(a, b, x, y)
    print(a,b,cost)
    plt.scatter(x,y)
    plt.plot(x,y_hat)
    return a,b

a,b = iterate(a,b,exam_X,exam_Y,50)

5.完整代码

from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
examDict={
    '学习时间':[0.50,0.75,1.00,1.25,1.50,1.75,1.75,2.00,2.25,
            2.50,2.75,3.00,3.25,3.50,4.00,4.25,4.50,4.75,5.00,5.50],
    '分数':    [10,  22,  13,  43,  20,  22,  33,  50,  62,
              48,  55,  75,  62,  73,  81,  76,  64,  82,  90,  93]
}
exam=pd.DataFrame(examDict)
#从dataframe中把标签和特征导出来
exam_X = exam['学习时间']
exam_Y = exam['分数']
def model(a,b,x):
    return a*x+b
def cost_function(a,b,x,y):
    y_hat = a*x+b
    n = len(x)
    return 0.5/(n*(np.square(y-y_hat)).sum())
def optimize(a,b,x,y):
    n = len(x)
    alpha = 1e-1
    y_hat = model(a,b,x)
    da = (1.0/n) * ((y_hat-y)*x).sum()
    db = (1.0/n) * ((y_hat-y).sum())
    a = a - alpha*da
    b = b - alpha*db
    return a, b
a = 0
b = 0
def iterate(a,b,x,y,times):
    for i in range(times):
        a,b = optimize(a,b,x,y)
    y_hat=model(a,b,x)
    cost = cost_function(a, b, x, y)
    print(a,b,cost)
    plt.scatter(x,y)
    plt.plot(x,y_hat)
    return a,b
a,b = iterate(a,b,exam_X,exam_Y,50)