【Python人工智能】Python全栈体系（十二）

柠檬小帽

已于 2022-06-12 17:53:28 修改

阅读量137

点赞数

分类专栏： Python人工智能文章标签： python

于 2022-06-10 08:42:49 首次发布

本文链接：https://blog.csdn.net/sgsgkxkx/article/details/125213122

版权

Python人工智能专栏收录该内容

12 篇文章 6 订阅

订阅专栏

人工智能

第二章回归

一、线性模型

1. 概述

线性模型是自然界最简单的模型之一，它描述了一个（或多个）自变量对另一个因变量的影响是呈简单的比例、线性关系.例如：
- 住房每平米单价为1万元，100平米住房价格为100万元，120平米住房为120万元；
- 一台挖掘机每小时挖 $100m^3$ 沙土，工作4小时可以挖掘 $400m^3$ 沙土.
线性模型在二维空间内表现为一条直线，在三维空间内表现为一个平面，更高维度下的线性模型很难用几何图形来表示（称为超平面）.如下图所示：

二维空间下线性模型表现为一条直线

在这里插入图片描述

三维空间下线性模型表现为一个平面

线性回归是要根据一组输入值和输出值（称为样本），寻找一个线性模型，能最佳程度上拟合于给定的数值分布，从而再给定新的输入时预测输出.样本如下表所示：

输入(x)	输出(y)
0.5	5.0
0.6	5.5
0.8	6.0
1.1	6.8
1.4	6.8

根据样本拟合的线性模型如下图所示：

2. 线性模型定义

设给定一组属性 $x, x=(x_1;x_2;...;x_n)$ ，线性方程的一般表达形式为：
$y = w_1x_1 + w_2x_2 + w_3x_3 + ... + w_nx_n + b$
写成向量形式为：
$y = w^Tx + b$
其中， $w=(w_1;w_2;...;w_n), x=(x_1;x_2;...;x_n)$ ，w和b经过学习后，模型就可以确定. 当自变量数量为1时，上述线性模型即为平面下的直线方程：
$y = w x + b$
线性模型形式简单、易于建模，却蕴含着机器学习中一些重要的基本思想. 许多功能强大的非线性模型可以在线性模型基础上引入层级结构或高维映射而得. 此外，由于 $w$ 直观表达了各属性在预测中的重要性，因此线性模型具有很好的可解释性.例如，判断一个西瓜是否为好瓜，可以用如下表达式来判断：
$f_{好瓜}(x) = 0.2x_{色泽} + 0.5x_{根蒂} + 0.3x_{敲声} + 1$
上述公式可以解释为，一个西瓜是否为好瓜，可以通过色泽、根蒂、敲声等因素共同判断，其中根蒂最重要(权重最高)，其次是敲声和色泽.

3. 模型训练

在二维平面中，给定两点可以确定一条直线.但在实际工程中，可能有很多个样本点，无法找到一条直线精确穿过所有样本点，只能找到一条与样本”足够接近“或”距离足够小“的直线，近似拟合给定的样本.如下图所示：
如何确定直线到所有样本足够近呢？可以使用损失函数来进行度量.

3.1 损失函数

损失函数用来度量真实值（由样本中给出）和预测值（由模型算出）之间的差异.损失函数值越小，表明模型预测值和真实值之间差异越小，模型性能越好；损失函数值越大，模型预测值和真实值之间差异越大，模型性能越差.在回归问题中，均方差是常用的损失函数，其表达式如下所示：
$\frac{1}{2}\sum_{i=1}^{n}{(y - y')^2}$
其中，y为模型预测值，y’为真实值. 均方差具有非常好的几何意义，对应着常用的欧几里得距离（简称欧式距离）. 线性回归的任务是要寻找最优线性模型，是的损失函数值最小，即：
$(w^*, b^*) = arg min \frac{1}{2}\sum_{i=1}^{n}{(y - y')^2} \\ = arg min \frac{1}{2}\sum_{i=1}^{n}{(y' - wx_i - b)^2}$
基于均方误差最小化来进行模型求解的方法称为“最小二乘法”. 线性回归中，最小二乘法就是试图找到一条直线，是所有样本到直线的欧式距离之和最小. 可以将损失函数对w和b分别求导，得到损失函数的导函数，并令导函数为0即可得到w和b的最优解.

3.2 梯度下降法

3.2.1 为什么使用梯度下降

在实际计算中，通过最小二乘法求解最优参数有一定的问题：

（1）最小二乘法需要计算逆矩阵，有可能逆矩阵不存在；

（2）当样本特征数量较多时，计算逆矩阵非常耗时甚至不可行.
所以，在实际计算中，通常采用梯度下降法来求解损失函数的极小值，从而找到模型的最优参数.

3.2.2 什么是梯度下降

梯度（gradient）是一个向量（矢量，有方向），表示某一函数在该点处的方向导数沿着该方向取得最大值，即函数在该点处沿着该方向（此梯度的方向）变化最快，变化率最大.损失函数沿梯度相反方向收敛最快（即能最快找到极值点）.当梯度向量为零（或接近于零），说明到达一个极值点，这也是梯度下降算法迭代计算的终止条件.
这种按照负梯度不停地调整函数权值的过程就叫作“梯度下降法”.通过这样的方法，改变权重让损失函数的值下降得更快，进而将值收敛到损失函数的某个极小值.
通过损失函数，我们将“寻找最优参数”问题，转换为了“寻找损失函数最小值”问题.梯度下降法算法描述如下：

（1）损失是否足够小？如果不是，计算损失函数的梯度.
（2）按梯度的反方向走一小步，以缩小损失.
（3）循环到（1）.
梯度下降法中通过沿着梯度负方向不断调整参数，从而逐步接近损失函数极小值所在点. 如下图所示：

3.2.3 参数更新法则

在直线方程中，有两个参数需要学习， $w_0$ 和 $w_1$ ，梯度下降过程中，分别对这两个参数单独进行调整，调整法则如下：
$w_0 = w_0 + \Delta w_0\\ w_1 = w_1 + \Delta w_1$
$\Delta w_0$ 和 $\Delta w_1$ 可表示为：
$\Delta w_0 = -\eta \frac{\Delta loss}{\Delta w_0}\\ \Delta w_1 = -\eta \frac{\Delta loss}{\Delta w_1}\\$
其中， $\eta$ 称为学习率， $\frac{\Delta loss}{\Delta w_i}$ 为梯度（即损失函数关于参数 $w_i$ 的偏导数）. 损失函数表达式为：
$=\frac{1}{2}\sum(y - y')^2 = \frac{1}{2}\sum((y-(w_0+w_1x))^2)$
对损失函数求导，可得 $w_0, w_1$ 的偏导数为：
$\frac{\Delta loss}{\Delta w_0} = \sum((y - y')(-1)) = -\sum(y - y')\\ \frac{\Delta loss}{\Delta w_1} = \sum((y - y')(-x)) = -\sum(x(y - y'))$

在这里插入图片描述

4. 实现线性回归

所谓线性回归，即是使用线性数学模型解决生活中回归预测问题。即找到一个最优秀的线性模型y=f(x)表达样本数据特征之间的规律，从而传入未知输出的输入x，求出预测的输出y。
例如：根据工作经验预测薪资水平。

4.1 自己编码实现

以下是实现线性回归的代码：

# 线性回归示例
import numpy as np
import matplotlib.pyplot as mp
from mpl_toolkits.mplot3d import axes3d
import sklearn.preprocessing as sp

# 训练数据集
train_x = np.array([0.5, 0.6, 0.8, 1.1, 1.4])  # 输入集
train_y = np.array([5.0, 5.5, 6.0, 6.8, 7.0])  # 输出集

n_epochs = 1000  # 迭代次数
lrate = 0.01  # 学习率
epochs = []  # 记录迭代次数
losses = []  # 记录损失值

w0, w1 = [1], [1]  # 模型初始值

for i in range(1, n_epochs + 1):
    epochs.append(i)  # 记录第几次迭代

    y = w0[-1] + w1[-1] * train_x  # 取出最新的w0,w1计算线性方程输出
    # 损失函数(均方差)
    loss = (((train_y - y) ** 2).sum()) / 2
    losses.append(loss)  # 记录每次迭代的损失值

    print("%d: w0=%f, w1=%f, loss=%f" % (i, w0[-1], w1[-1], loss))

    # 计算w0,w1的偏导数
    d0 = -(train_y - y).sum()
    d1 = -(train_x * (train_y - y)).sum()

    # 更新w0,w1
    w0.append(w0[-1] - (d0 * lrate))
    w1.append(w1[-1] - (d1 * lrate))

程序执行结果：

1 w0=1.00000000 w1=1.00000000 loss=44.17500000
2 w0=1.20900000 w1=1.19060000 loss=36.53882794
3 w0=1.39916360 w1=1.36357948 loss=30.23168666
4 w0=1.57220792 w1=1.52054607 loss=25.02222743
5 w0=1.72969350 w1=1.66296078 loss=20.71937337
......
996 w0=4.06506160 w1=2.26409126 loss=0.08743506
997 w0=4.06518850 w1=2.26395572 loss=0.08743162
998 w0=4.06531502 w1=2.26382058 loss=0.08742820
999 w0=4.06544117 w1=2.26368585 loss=0.08742480
1000 w0=4.06556693 w1=2.26355153 loss=0.08742142

可以给数据加上可视化，让结果更直观.添加如下代码：

###################### 训练过程可视化 ######################
# 训练过程可视化
## 损失函数收敛过程
w0 = np.array(w0[:-1])
w1 = np.array(w1[:-1])

mp.figure("Losses", facecolor="lightgray")  # 创建一个窗体
mp.title("epoch", fontsize=20)
mp.ylabel("loss", fontsize=14)
mp.grid(linestyle=":")  # 网格线：虚线
mp.plot(epochs, losses, c="blue", label="loss")
mp.legend()  # 图例
mp.tight_layout()  # 紧凑格式

## 显示模型直线
pred_y = w0[-1] + w1[-1] * train_x  # 根据x预测y
mp.figure("Linear Regression", facecolor="lightgray")
mp.title("Linear Regression", fontsize=20)
mp.xlabel("x", fontsize=14)
mp.ylabel("y", fontsize=14)
mp.grid(linestyle=":")
mp.scatter(train_x, train_y, c="blue", label="Traing")  # 绘制样本散点图
mp.plot(train_x, pred_y, c="red", label="Regression")
mp.legend()

# 显示梯度下降过程(复制粘贴即可，不需要编写)
# 计算损失函数曲面上的点 loss = f(w0, w1)
arr1 = np.linspace(0, 10, 500)  # 0~9间产生500个元素的均匀列表
arr2 = np.linspace(0, 3.5, 500)  # 0~3.5间产生500个元素的均匀列表

grid_w0, grid_w1 = np.meshgrid(arr1, arr2)  # 产生二维矩阵

flat_w0, flat_w1 = grid_w0.ravel(), grid_w1.ravel()  # 二维矩阵扁平化
loss_metrix = train_y.reshape(-1, 1)  # 生成误差矩阵（-1,1）表示自动计算维度
outer = np.outer(train_x, flat_w1)  # 求外积（train_x和flat_w1元素两两相乘的新矩阵）
# 计算损失：((w0 + w1*x - y)**2)/2
flat_loss = (((flat_w0 + outer - loss_metrix) ** 2).sum(axis=0)) / 2
grid_loss = flat_loss.reshape(grid_w0.shape)

mp.figure('Loss Function')
ax = mp.gca(projection='3d')
mp.title('Loss Function', fontsize=14)
ax.set_xlabel('w0', fontsize=14)
ax.set_ylabel('w1', fontsize=14)
ax.set_zlabel('loss', fontsize=14)
ax.plot_surface(grid_w0, grid_w1, grid_loss, rstride=10, cstride=10, cmap='jet')
ax.plot(w0, w1, losses, 'o-', c='orangered', label='BGD', zorder=5)
mp.legend(loc='lower left')

mp.show()

数据可视化结果如下图所示：

回归得到的线性模型

在这里插入图片描述

损失函数收敛过程

在这里插入图片描述

梯度下降过程

4.2 实例

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

x = np.array([0.5,0.6,0.8,1.1,1.4])
y = np.array([5.0,5.5,6.0,6.8,7.0])
plt.grid(linestyle=':')
plt.scatter(x,y, s=60, color='dodgerblue', label='Samples')

请添加图片描述

# 基于梯度下降算法，不断更新w0与w1，从而找到最佳的模型参数
w0, w1, lrate= 1, 1, 0.01
times = 1000
w0s, w1s, losses, epoches = [], [], [], []
for i in range(times):
    # 输出每一轮运算过程中，w0、w1、loss的变化过程：
    loss = ((w0 + w1*x - y)**2).sum() / 2
    print('{:4},w0:{:.8f},w1:{:.8f},loss:{:.8f}'.format(i+1,w0,w1,loss))
    # 把变量存入各个列表中
    epoches.append(i+1)
    w0s.append(w0)
    w1s.append(w1)
    losses.append(loss)
    
    # 计算w0与w1方向上的偏导数，代入模型参数的更新公式
    d0 = (w0 + w1*x - y).sum()
    d1 = (x * (w0 + w1*x - y)).sum()
    # 更新w0与w1
    w0 = w0 - lrate * d0
    w1 = w1 - lrate * d1

w0, w1
"""
   1,w0:1.00000000,w1:1.00000000,loss:44.17500000
   2,w0:1.20900000,w1:1.19060000,loss:36.53882794
   3,w0:1.39916360,w1:1.36357948,loss:30.23168666
   4,w0:1.57220792,w1:1.52054607,loss:25.02222743
   5,w0:1.72969350,w1:1.66296078,loss:20.71937337
   6,w0:1.87303855,w1:1.79215140,loss:17.16530917
   7,w0:2.00353196,w1:1.90932461,loss:14.22969110
   8,w0:2.12234508,w1:2.01557706,loss:11.80486494
   9,w0:2.23054244,w1:2.11190537,loss:9.80191627
  10,w0:2.32909148,w1:2.19921529,loss:8.14740839
  11,w0:2.41887143,w1:2.27832995,loss:6.78068803
  12,w0:2.50068134,w1:2.34999742,loss:5.65166010
  13,w0:2.57524739,w1:2.41489755,loss:4.71894976
  14,w0:2.64322953,w1:2.47364820,loss:3.94838447
  15,w0:2.70522753,w1:2.52681085,loss:3.31174023
  16,w0:2.76178648,w1:2.57489580,loss:2.78570611
  17,w0:2.81340174,w1:2.61836680,loss:2.35102901
  18,w0:2.86052351,w1:2.65764531,loss:1.99180729
  19,w0:2.90356094,w1:2.69311435,loss:1.69490738
"""

# 绘制样本点
plt.grid(linestyle=':')
plt.scatter(x,y, s=60, color='dodgerblue', label='Samples')
# 绘制回归线
pred_y = w0 + w1 * x
plt.plot(x, pred_y, color='orangered', linewidth=2, label='Regression Line')

请添加图片描述

# 超参数可视化
plt.subplot(3,1,1)
plt.grid(linestyle=':')
plt.ylabel('w0')
plt.plot(epoches,w0s,color='dodgerblue', label='w0')
plt.xticks([])
plt.legend()

plt.subplot(3,1,2)
plt.grid(linestyle=':')
plt.ylabel('w1')
plt.plot(epoches,w1s,color='dodgerblue', label='w1')
plt.xticks([])
plt.legend()

plt.subplot(3,1,3)
plt.grid(linestyle=':')
plt.ylabel('loss')
plt.plot(epoches,losses,color='orangered', label='loss')
plt.legend()

请添加图片描述

4.3 通过sklearn API实现

sklearn 提供了线性回归相关 API：

import sklearn.linear_model as lm
# 创建模型
model = lm.LinearRegression()
# 训练模型
# 输入为一个二维数组表示的样本矩阵
# 输出为每个样本最终的结果
model.fit(输入,输出)	# 通过梯度下降法计算模型参数
# 预测输出
# 输入array是一个二维数组，每一行是一个样本，每一列是一个特征
result = model.predict(array)

# 利用LinearRegression实现线性回归
import numpy as np
import sklearn.linear_model as lm  # 线性模型# 线性模型
import sklearn.metrics as sm  # 模型性能评价模块
import matplotlib.pyplot as mp

train_x = np.array([[0.5], [0.6], [0.8], [1.1], [1.4]])  # 输入集
train_y = np.array([5.0, 5.5, 6.0, 6.8, 7.0])  # 输出集

# 创建线性回归器
model = lm.LinearRegression()
# 用已知输入、输出数据集训练回归器
model.fit(train_x, train_y)
# 根据训练模型预测输出
pred_y = model.predict(train_x)

print("coef_:", model.coef_)  # 系数
print("intercept_:", model.intercept_)  # 截距

# 可视化回归曲线
mp.figure('Linear Regression', facecolor='lightgray')
mp.title('Linear Regression', fontsize=20)
mp.xlabel('x', fontsize=14)
mp.ylabel('y', fontsize=14)
mp.tick_params(labelsize=10)
mp.grid(linestyle=':')

# 绘制样本点
mp.scatter(train_x, train_y, c='blue', alpha=0.8, s=60, label='Sample')

# 绘制拟合直线
mp.plot(train_x,  # x坐标数据
        pred_y,  # y坐标数据
        c='orangered', label='Regression')

mp.legend()
mp.show()

5. 案例：根据工作经验预测薪资

加载数据文件
整理样本数据输入集与输出集
训练线性回归模型
预测薪资

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 加载数据集
data = pd.read_csv('Salary_Data.csv')
x,y = data['YearsExperience'],data['Salary']
plt.grid(linestyle=':')
plt.scatter(x,y, s=60, color='dodgerblue', label='Samples')

请添加图片描述

# 基于sklearn提供的API，训练线性回归模型
import sklearn.linear_model as lm
train_x, train_y = pd.DataFrame(x),y
model = lm.LinearRegression()
model.fit(train_x, train_y)
# 针对所有训练样本，执行预测操作，绘制回归线
pred_train_y = model.predict(train_x)

# 可视化
plt.grid(linestyle=':')
plt.scatter(x,y, s=60, color='dodgerblue', label='Samples')
plt.plot(x, pred_train_y, color='orangered', label='Regression Line')
plt.legend()

请添加图片描述

6. 回归模型的评估指标

线性回归模型训练完毕后，可以利用测试集评估训练结果误差。sklearn.metrics 提供了计算模型误差的几个常用算法：

（1）平均绝对误差（Mean Absolute Deviation）：单个观测值与算术平均值的偏差的绝对值的平均；

（2）均方误差：单个样本到平均值差值的平方平均值；

（3）MAD(中位数绝对偏差)：与数据中值绝对偏差的中值；
在这里插入图片描述
（4）R2决定系数：趋向于1，模型越好；趋向于0，模型越差.

import sklearn.metrics as sm

# 平均绝对值误差：1/m∑|实际输出-预测输出|
sm.mean_absolute_error(y, pred_y)
# 平均平方误差：SQRT(1/m∑(实际输出-预测输出)^2)
sm.mean_squared_error(y, pred_y)
# 中位绝对值误差：MEDIAN(|实际输出-预测输出|)
sm.median_absolute_error(y, pred_y)
# R2得分，(0,1]区间的分值。分数越高，误差越小。
sm.r2_score(y, pred_y)

7. 模型的保存和加载

模型训练是一个耗时的过程，一个优秀的机器学习是非常宝贵的。可以把模型保存到磁盘中，也可以在需要使用的时候从磁盘中重新加载模型即可。不需要重新训练。

# 将训练好的模型对象保存到磁盘文件中
with open('../../data/linear.pk1', 'wb') as f:
	pickle.dump(model, f)

# 从磁盘文件中加载模型对象
with open('../../data/linear.pk1', 'rb') as f:
	model = pickle.load(f)

# 根据输入预测输出
pred_y = model.predict(x)

可以使用Python提供的功能对模型对象进行保存.使用方法如下：

import pickle
# 保存模型
pickle.dump(模型对象, 文件对象)   
# 加载模型
model_obj = pickle.load(文件对象)

保存训练模型应该在训练完成或评估完成之后，完整代码如下：

# 模型保存示例
import numpy as np
import sklearn.linear_model as lm # 线性模型
import pickle

x = np.array([[0.5], [0.6], [0.8], [1.1], [1.4]])  # 输入集
y = np.array([5.0, 5.5, 6.0, 6.8, 7.0])  # 输出集

# 创建线性回归器
model = lm.LinearRegression()
# 用已知输入、输出数据集训练回归器
model.fit(x, y)

print("训练完成.")

# 保存训练后的模型
with open('linear_model.pkl', 'wb') as f:
    pickle.dump(model, f)
    print("保存模型完成.")

执行完成后，可以看到与源码相同目录下多了一个名称为linear_model.pkl的文件，这就是保存的训练模型.使用该模型代码：

# 模型加载示例
import numpy as np
import sklearn.linear_model as lm  # 线性模型
import sklearn.metrics as sm  # 模型性能评价模块
import matplotlib.pyplot as mp
import pickle

x = np.array([[0.5], [0.6], [0.8], [1.1], [1.4]])  # 输入集
y = np.array([5.0, 5.5, 6.0, 6.8, 7.0])  # 输出集

# 加载模型
with open('linear_model.pkl', 'rb') as f:
    model = pickle.load(f)
    print("加载模型完成.")

# 根据加载的模型预测输出
pred_y = model.predict(x)

# 可视化回归曲线
mp.figure('Linear Regression', facecolor='lightgray')
mp.title('Linear Regression', fontsize=20)
mp.xlabel('x', fontsize=14)
mp.ylabel('y', fontsize=14)
mp.tick_params(labelsize=10)
mp.grid(linestyle=':')
mp.scatter(x, y, c='blue', alpha=0.8, s=60, label='Sample')

mp.plot(x, pred_y, c='orangered', label='Regression')

mp.legend()
mp.show()

执行结果和训练模型预测结果一样.

7.1 模型的保存

import pickle
with open('model.pickle', 'wb') as f:
    pickle.dump(model, f)
print('dump success.')

"""
dump.success
"""

7.2 模型的加载

with open('model.pickle', 'rb') as f:
    model = pickle.load(f)
model.predict([[15.6],[16.4]])

"""
array([173211.61241337, 180771.58227053])
"""

7.3 实例

import numpy as np
import pandas as pd
import pickle

# 声明一个薪资预测类型，封装预测逻辑

class SalaryPredictionModel():
    
    def __init__(self):
        with open('model.pickle', 'rb') as f:
            self.model = pickle.load(f)
    
    def predict(self, exps):
        """
        exps: 工作年限数组（一维数组）
        """
        exps = np.array(exps).reshape(-1, 1) # 可以把(4,)一维数组变维：(4, 1)
        return self.model.predict(exps)

model = SalaryPredictionModel()
model.predict([3.4, 5.5, 6, 8])
"""
array([ 57922.07209162,  77766.99296667,  82491.9741274 , 101391.89877031])
"""