机器学习笔记之线性回归

2020年11月12日 56点热度 2人点赞 0条评论

本文的CSDN

写在前面的:

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

线性回归

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

实现线性回归的步骤:
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)

luoluo

我爱吃螺蛳粉

文章评论