机器学习训练算法十二(模型训练算法-Python实验)

已于 2024-07-25 15:19:00 修改
阅读量1k 收藏 21
点赞数 28
分类专栏： 机器学习 算法 python 文章标签： 机器学习 算法 python
于 2024-02-19 11:07:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013106652/article/details/136164644
版权
算法 同时被 3 个专栏收录
15 篇文章 7 订阅
订阅专栏
机器学习
14 篇文章 1 订阅
订阅专栏
python
4 篇文章 0 订阅
订阅专栏

目录


在机器学习中经常用梯度下降法、牛顿下降法、高斯牛顿法、列文伯格-马夸尔特法来训练模型，为了方便理解，本文严谨且详细的阐述了这几个算法的数学推导原理，并且用python程序加以实验验证。

1、测试数据

为了方便研究最小二乘法问题,现提供如下车辆时间和行驶距离的观测数据用于讨论和分析。
在这里插入图片描述

2、数学模型

令：车辆的初速度 v 0 v_0 v0​ 、加速度 a a a、时间 t t t、距离 y ^ \hat{y} y^​ ，第 i i i组观测值为 ( t i , y ^ i ) (t_i,\hat{y}_i ) (ti​,y^​i​)，时间 t t t与距离 y ^ \hat{y} y^​满足的数学模型如下：
y ^ = f ( v 0 , a , t ) = 1 2 a t 2 + v 0 t ( 公式 59 ) \hat{y}=f(v_0,a,t)=\frac{1}{2}at^2+v_0t \qquad (公式59) y^​=f(v0​,a,t)=21​at2+v0​t(公式59) min F ( a , v 0 ) = 1 2 ∑ i = 1 10 ( f ( v 0 , a , t i ) − y i ^ ) 2 ( 公式 60 ) \text{min}F(a,v_0)=\frac{1}{2}\sum_{i=1}^{10} (f(v_0,a,t_i)-\hat{y_i})^2 \qquad (公式60) minF(a,v0​)=21​i=1∑10​(f(v0​,a,ti​)−yi​^​)2(公式60)
观察公式 60 发现， y i ^ \hat{y_i} yi​^​ 和 t i t_i ti​ 是 常 数 , a a a 和 v 0 v_0 v0​ 是变量，可知该最小二乘问题是函数 F F F关于 a a a 和 v v v 的最小极值问题。

3、梯度下降法

3.1、数学原理推导

链接地址

3.2、Python程序

import numpy as np
import matplotlib.pyplot as plt

# 定义数学模型
def f(args, t):
    return 0.5 * args[0] * np.power(t, 2) + args[1] * t

# 定义残差函数
def l(args, t, y):
    return f(args, t) - y

# 定义目标函数
def o(lv):
    return 0.5 * np.power(lv, 2)

# 定义关于目标函数第一个参数的一阶偏导函数
def oj1(args, t, y):
    return (o(l(args + [delta, 0], t, y)) - o(l(args, t, y))) / delta

# 定义关于目标函数第二个参数的一阶偏导函数
def oj2(args, t, y):
    return (o(l(args + [0, delta], t, y)) - o(l(args, t, y))) / delta

# 初始数据
t = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])  # 加速度实验的观测值,时间(单位:秒)
y = np.array([0, 11.52, 26.2, 43.5, 64.12, 87.57, 114.12, 143.5, 176.3, 211.5, 250.12])  # 加速度实验的观测值,距离(单位:米)
x = np.array([1, 1])  # 初始化参数[args(1);args(2)]
goal = 0.0001  # 目标误差
epochs = 10000  # 训练次数
delta = 0.0001  # 偏导计算的增量
ov = 0  # 初始化目标值

for k in range(epochs):
    # 误差计算
    tl = l(x, t, y)  # 计算残差值
    tmp_ov = np.sum(o(tl))  # 计算最新目标值
    tmp_error = np.abs(tmp_ov - ov)  # 目标值的变化
    print(f'{k}->目标值: [{tmp_ov}], 误差: [{tmp_error}]')
    ov = tmp_ov  # 更新目标值

    if tmp_error < goal:
        print(f'训练次数: {k+1}次...')
        break

    # 执行训练
    J = np.array([np.sum(oj1(x, t, y)),
                  np.sum(oj2(x, t, y))])  # 雅克比矩阵

    # 更新参数
    x = x - 0.0001 * J

# 打印训练结果
print(f'训练后的参数: {x}')
plt.plot(t, y, 'o', np.arange(min(t), max(t), 0.001), f(x, np.arange(min(t), max(t), 0.001)), '-')
plt.show()

3.3、执行日志

2301->目标值: [0.06649798204087369], 误差: [0.00010499914693314072]
2302->目标值: [0.06639346785247356], 误差: [0.00010451418840012883]
2303->目标值: [0.06628943641358499], 误差: [0.0001040314388885688]
2304->目标值: [0.06618588552519271], 误差: [0.00010355088839228421]
2305->目标值: [0.06608281299820142], 误差: [0.00010307252699129354]
2306->目标值: [0.06598021665344106], 误差: [0.00010259634476035562]
2307->目标值: [0.06587809432158329], 误差: [0.00010212233185777353]
2308->目标值: [0.0657764438431518], 误差: [0.00010165047843148367]
2309->目标值: [0.06567526306842077], 误差: [0.0001011807747310356]
2310->目标值: [0.0655745498573545], 误差: [0.00010071321106626396]
2311->目标值: [0.06547430207969993], 误差: [0.00010024777765457737]
2312->目标值: [0.06537451761472354], 误差: [9.978446497638238e-05]
训练次数: 2313次...
训练后的参数: [3.00520621 9.99137523]

3.4、训练结果

在这里插入图片描述

4、牛顿下降法

4.1、数学原理推导

链接地址

4.2、Python程序

import numpy as np
import matplotlib.pyplot as plt

# 定义数学模型
def f(args, t):
    return 0.5 * args[0] * np.power(t, 2) + args[1] * t

# 定义残差函数
def l(args, t, y):
    return f(args, t) - y

# 定义目标函数
def o(lv):
    return 0.5 * np.power(lv, 2)

# 定义关于目标函数第一个参数的一阶偏导函数
def oj1(args, t, y):
    return (o(l(args + [delta, 0], t, y)) - o(l(args, t, y))) / delta

# 定义关于目标函数第二个参数的一阶偏导函数
def oj2(args, t, y):
    return (o(l(args + [0, delta], t, y)) - o(l(args, t, y))) / delta

# 定义关于目标函数的(第一个参数,第一个参数)的二阶偏导函数
def oh00(args, t, y):
    return (oj1(args + [delta, 0], t, y) - oj1(args, t, y)) / delta

# 定义关于目标函数的(第一个参数,第二个参数)的二阶偏导函数
def oh01(args, t, y):
    return (oj1(args + [0, delta], t, y) - oj1(args, t, y)) / delta

# 定义关于目标函数的(第二个参数,第一个参数)的二阶偏导函数
def oh10(args, t, y):
    return (oj2(args + [delta, 0], t, y) - oj2(args, t, y)) / delta

# 定义关于目标函数的(第二个参数,第二个参数)的二阶偏导函数
def oh11(args, t, y):
    return (oj2(args + [0, delta], t, y) - oj2(args, t, y)) / delta

# 初始数据
t = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])  # 加速度实验的观测值,时间(单位:秒)
y = np.array([0, 11.52, 26.2, 43.5, 64.12, 87.57, 114.12, 143.5, 176.3, 211.5, 250.12])  # 加速度实验的观测值,距离(单位:米)
x = np.array([1, 1])  # 初始化参数[args(1);args(2)]
goal = 0.0001  # 目标误差
epochs = 10000  # 训练次数
delta = 0.0001  # 偏导计算的增量
ov = 0  # 初始化目标值

for k in range(epochs):
    # 误差计算
    tl = l(x, t, y)  # 计算残差值
    tmp_ov = np.sum(o(tl))  # 计算最新目标值
    tmp_error = np.abs(tmp_ov - ov)  # 目标值的变化
    print(f'{k}->目标值: [{tmp_ov}], 误差: [{tmp_error}]')
    ov = tmp_ov  # 更新目标值

    if tmp_error < goal:
        print(f'训练次数: {k+1}次...')
        break

    # 执行训练
    H = np.array([[np.sum(oh00(x, t, y)), np.sum(oh01(x, t, y))],
                  [np.sum(oh10(x, t, y)), np.sum(oh11(x, t, y))]])  # 黑塞矩阵
    J = np.array([np.sum(oj1(x, t, y)),
                  np.sum(oj2(x, t, y))])  # 雅克比矩阵

    # 更新参数
    x = x - np.linalg.inv(H) @ J

# 打印训练结果
print(f'训练后的参数: {x}')
plt.plot(t, y, 'o', np.arange(min(t), max(t), 0.001), f(x, np.arange(min(t), max(t), 0.001)), '-')
plt.show()

4.3、执行日志

0->目标值: [55574.229250000004], 误差: [55574.229250000004]
1->目标值: [0.04454421541289134], 误差: [55574.18470578459]
2->目标值: [0.04452996893422017], 误差: [1.4246478671167684e-05]
训练次数: 3次...
训练后的参数: [ 2.99458661 10.0356844 ]

4.4、训练结果

在这里插入图片描述

5、高斯牛顿法

5.1、数学原理推导

链接地址

5.2、Python程序

import numpy as np
import matplotlib.pyplot as plt

# 定义数学模型
def f(args, t):
    return 0.5 * args[0] * np.power(t, 2) + args[1] * t

# 定义残差函数
def l(args, t, y):
    return f(args, t) - y

# 定义目标函数
def o(lv):
    return 0.5 * np.power(lv, 2)

# 定义关于残差函数第一个参数的一阶偏导函数
def j1(args, t, y):
    return (l(args + [delta, 0], t, y) - l(args, t, y)) / delta

# 定义关于残差函数第二个参数的一阶偏导函数
def j2(args, t, y):
    return (l(args + [0, delta], t, y) - l(args, t, y)) / delta

# 初始数据
t = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])  # 加速度实验的观测值,时间(单位:秒)
y = np.array([0, 11.52, 26.2, 43.5, 64.12, 87.57, 114.12, 143.5, 176.3, 211.5, 250.12])  # 加速度实验的观测值,距离(单位:米)
x = np.array([1, 1])  # 初始化参数[args(1);args(2)]
goal = 0.0001  # 目标误差
epochs = 10000  # 训练次数
delta = 0.0001  # 偏导计算的增量
ov = 0  # 初始化目标值

for k in range(epochs):
    # 误差计算
    tl = l(x, t, y)  # 计算残差值
    tmp_ov = np.sum(o(tl))  # 计算最新目标值
    tmp_error = np.abs(tmp_ov - ov)  # 目标值的变化
    print(f'{k}->目标值: [{tmp_ov}], 误差: [{tmp_error}]')
    ov = tmp_ov  # 更新目标值

    if tmp_error < goal:
        print(f'训练次数: {k+1}次...')
        break

    # 执行训练
    tmp_j1 = j1(x, t, y)  # 关于第一个参数的一阶偏导函数的值
    tmp_j2 = j2(x, t, y)  # 关于第二个参数的一阶偏导函数的值
    H = np.array([[np.sum(tmp_j1 * tmp_j1), np.sum(tmp_j1 * tmp_j2)],
                  [np.sum(tmp_j2 * tmp_j1), np.sum(tmp_j2 * tmp_j2)]])  # 近似黑塞矩阵
    J = np.array([np.sum(tl * tmp_j1),
                  np.sum(tl * tmp_j2)])  # 近似雅克比矩阵

    # 更新参数
    x = x - np.linalg.inv(H) @ J

# 打印训练结果
print(f'训练后的参数: {x}')
plt.plot(t, y, 'o', np.arange(min(t), max(t), 0.001), f(x, np.arange(min(t), max(t), 0.001)), '-')
plt.show()

5.3、执行日志

0->目标值: [55574.229250000004], 误差: [55574.229250000004]
1->目标值: [0.04445524644031092], 误差: [55574.184794753564]
2->目标值: [0.044455246440310965], 误差: [4.85722573273506e-17]
训练次数: 3次...
训练后的参数: [ 2.99520263 10.03331435]

5.4、训练结果

在这里插入图片描述

6、列文伯格-马夸尔特法(LM 法)

6.1、数学原理推导

链接地址

6.2、Python程序

import numpy as np
import matplotlib.pyplot as plt

# 定义数学模型
def f(args, t):
    return 0.5 * args[0] * np.power(t, 2) + args[1] * t

# 定义残差函数
def l(args, t, y):
    return f(args, t) - y

# 定义目标函数
def o(lv):
    return 0.5 * np.power(lv, 2)

# 偏导函数
delta = 0.0001

def j1(args, t, y):
    return (l(args + [delta, 0], t, y) - l(args, t, y)) / delta

def j2(args, t, y):
    return (l(args + [0, delta], t, y) - l(args, t, y)) / delta

# 初始数据
t = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])  # 加速度实验的观测值,时间(单位:秒)
y = np.array([0, 11.52, 26.2, 43.5, 64.12, 87.57, 114.12, 143.5, 176.3, 211.5, 250.12])  # 加速度实验的观测值,距离(单位:米)
x = np.array([1, 1])  # 初始化参数[args(1);args(2)]
goal = 0.0001  # 目标误差
epochs = 10000  # 训练次数
delta = 0.0001  # 偏导计算的增量
ov = 0  # 初始化目标值

for k in range(epochs):
     # 误差计算
    tl = l(x, t, y)  # 计算残差值
    tmp_ov = np.sum(o(tl))  # 计算最新目标值
    tmp_error = np.abs(tmp_ov - ov)  # 目标值的变化
    print(f'{k}->目标值: [{tmp_ov}], 误差: [{tmp_error}]')
    ov = tmp_ov  # 更新目标值

    if tmp_error < goal:
        print(f'训练次数: {k+1}次...')
        break

    # 执行训练
    tmp_j1 = j1(x, t, y)  # 关于第一个参数的一阶偏导函数的值
    tmp_j2 = j2(x, t, y)  # 关于第二个参数的一阶偏导函数的值
    H = np.array([[np.sum(tmp_j1 * tmp_j1), np.sum(tmp_j1 * tmp_j2)],
                  [np.sum(tmp_j2 * tmp_j1), np.sum(tmp_j2 * tmp_j2)]])  # 近似黑塞矩阵
    J = np.array([np.sum(tl * tmp_j1),
                  np.sum(tl * tmp_j2)])  # 近似雅克比矩阵

    # 计算值λ
    if k == 0:
        lambda_val = 0.000001 * np.max(np.diag(H))
        v = 2
    else:
        tmp_delta = delta * np.ones(J.shape)
        beta = (tmp_ov - np.sum(o(l(x + tmp_delta, t, y)))) / (tmp_ov - (tmp_ov + J.T.dot(tmp_delta) + 0.5 * tmp_delta.T.dot(H).dot(tmp_delta)))

        if beta > 0:
            lambda_val = lambda_val * max([1/3, 1 - np.power(2 * beta - 1, 3)])
            v = 2
        else:
            lambda_val = lambda_val * v
            v = 2 * v

    print('-->值λ: ' + str(lambda_val))

    # 更新参数
    x = x - np.linalg.inv(H + lambda_val * np.eye(H.shape[0])).dot(J)

# 打印训练结果
print('训练后的参数: ' + str(x))
plt.plot(t, y, 'o', np.arange(min(t), max(t), 0.001), f(x, np.arange(min(t), max(t), 0.001)), '-')
plt.show()

6.3、执行日志

0->目标值: [55574.229250000004], 误差: [55574.229250000004]
-->值λ: 0.006333249999994566
1->目标值: [0.04451695772021884], 误差: [55574.18473304228]
-->值λ: 0.002111083333331522
2->目标值: [0.04445524644085119], 误差: [6.171127936764609e-05]
训练次数: 3次...
训练后的参数: [ 2.99520268 10.03331413]

6.4、训练结果

在这里插入图片描述

7、方法比较

在这里插入图片描述

黎明鱼儿
关注
专栏目录
机器学习基本模型与算法在线实验闯关
Junds0的博客
10-19 5634
在发电场中电力输出（PE）与AT（温度）、V（压力）、AP（湿度）、RH（压强）有关，相关测试数据见“发电场数据.xlsx”文件，请完成以下任务：1）利用线性回归分析命令，求出PE与AT、V、AP、RH之间的线性回归关系式系数向量（包括常数项）和拟合优度（判定系数），并在命令窗口输出；本关任务：基于关卡6的数据集，构建支持向量机回归模型，输出其拟合优度，并针对测试数据AT=28.4、V=50.6、AP=1011.9、RH=80.54，预测其PE值。I1：西红柿、排骨、鸡蛋、毛巾、水果刀、苹果。
《机器学习算法竞赛实战》整理 | 五、模型训练
qq_37039382的博客
05-02 2580
目录 5.1 线性模型 5.1.1Lasso回归 5.1.2 Ridge回归 5.2 树模型 5.3 神经网络 5.4 实战案例 5.1 线性模型 5.1.1Lasso回归 Lasso回归，是对普通的线性回归采用L1正则化进行优化，通过乘法或限制估计值的绝对值之和，可以使某些系数为零，从而达到特征稀疏化和特征选择的效果。 当我们需要一些自动的特征、变量选择，或者处理高度相关的预测因素时，很方便。 代码实现： from sklearn.linear_model impor..
值得收藏的25道Python练手题（附详细答案）
lsxxx2011的专栏
03-06 4909
来源丨吾爱破解题目 1：水仙花数水仙花数（Narcissistic number）也被称为超完全数字不变数（pluperfect digital invariant, PPDI）、自恋数、自幂数、阿姆斯壮数或阿姆斯特朗数（Armstrong number）水仙花数是指一个 3 位数，它的每个位上的数字的 3 次幂之和等于它本身。例如：1^3 + 5^3+ 3^3 = 153。foriinra...
机器学习训练算法十一(模型训练算法-Matlab实验)
黎明鱼儿
01-09 4113
本文详细介绍了在机器学习中用于模型训练的四种优化算法：梯度下降法、牛顿下降法、高斯牛顿法和列文伯格-马夸尔特法（LM法）。文章首先给出了一个车辆运动模型的最小二乘问题，然后分别对每种算法进行了数学原理推导，并提供了相应的Matlab程序实现。最后，展示了每种算法的执行日志和训练结果，并对这些方法进行了比较。
Intel 公布开源版 Nauta，可开展深度学习模型训练实验
weixin_33691700的博客
01-25 83
百度智能云 云生态狂欢季 热门云产品1折起>>> Intel 近日公布了 Nauta 的开源版本，这...
手把手教你使用Python实现机器学习算法.pdf
06-16
本文“手把手教你使用Python实现机器学习算法”将引导初学者逐步掌握如何利用Python进行机器学习实践。 首先，我们关注的库是`scikit-learn`（简称sklearn），这是一个强大的机器学习库，提供了各种预处理、模型...
机器学习之朴素贝叶斯算法-----python实现垃圾邮件分类
07-12
简单的朴素贝叶斯垃圾邮件分类算法（python实现），另外上传的有垃圾邮件训练数据集，供大家下载。
Python-各种机器学习模型和算法的Python实现
08-11
各种机器学习模型和算法的Python实现，头开始学习
GMM模型，用MATlab编写的。可以用来训练
03-15
混合高斯模型，用在模式识别上面的混合高斯模型，用在模式识别上面的混合高斯模型，用在模式识别上面的混合高斯模型，用在模式识别上面的混合高斯模型，用在模式识别上面的混合高斯模型，用在模式识别上面的混合高斯模型，用在模式识别上面的混合高斯模型，用在模式识别上面的混合高斯模型，用在模式识别上面的
基于MATLAB的CNN模型训练部分
07-13
基于MATLAB的CNN模型训练部分代码实现基于MATLAB的CNN模型训练部分代码实现
【机器学习项目实战】python实现GA(遗传算法)对SVM分类模型参数的优化.zip
08-16
Python实现GA(遗传算法)对SVM分类模型参数的优化资料说明：包括数据集+源代码+Word文档说明。 资料内容包括： 1)需求分析； 2)数据采集； 3)数据预处理； 4)探索性数据分析； 5)特征工程； 6)机器建模； 7)模型评估...
Python机器学习基础算法教程：课件+数据+代码
最新发布
04-15
Python机器学习基础算法教程：课件+数据+代码 一、课件PPT 二、代码 9 -聚类算法实验分析 3-模型评估方法 8-Kmeans代码实现 14-集成算法实 验分析 7-聚类算法-Kmeans&Dbscan原理 6-逻辑回归实验分析 5- 逻辑回归代码...
【创新实训】推荐系统模型训练实验
_Mogician的博客
06-18 561
Experiments douban_imdb 原数据集来自movieLens-25M，为显示反馈，以评分大于等于3作为隐式反馈。 筛选出可以映射为douban_id的（最后应当筛选能映射为最终融合id的），去掉user、item频数小于5的，sess长度小于2的，按8：2划分数据集，train 152142条，test 36791条，item 10576个。 NARM 源码 session_NARM pytorch版本 Neural-Attentive-Session-Based-Recommendati
NVIDIA-TLT训练行人检测模型（一）----算法模型的训练(finetuning)
weixin_38106878的博客
10-10 2625
前言 在博客阅读前需要说明，本博文为系列文章，通过阅读文章，您将会学习到如下内容： 使用NVIDIA Transfer Learning Toolkit 工具训练(finetuning)出一个行人检测算法模型； 将训练好的算法模型部署到NVIDIA Jetson TX2上，结合deepstream sdk实现模型对多路rtsp视频流进行实时的行人检测； 思路的简介（目录） 在我们做一件事之前，需要思考；做事的思路，做事的方式，这样我们才能顺利、高效的完成这件事； Docker-ce的安装 Nvidia
模型训练 —— AI算法初识
初心不忘产学研的博客
02-17 1692
AI算法中模型训练的主要目的是为了让机器学习算法从给定的标注数据中学习规律、特征和模式，并通过调整模型内部参数，使模型能够对未见过的数据进行准确预测或决策。具体来说：1. **拟合数据**：模型通过训练来识别输入数据（如图像、文本、声音等）与输出结果之间的关系，以最小化预测值与真实值之间的差异（即误差）。2. **泛化能力**：训练过程中不仅要求模型在训练集上表现良好，更要确保模型能对未知的新数据样本产生良好的预测效果，这就是模型的泛化能力。
Python机器学习实践：k-近邻与决策树算法探索
"这是一个关于Python机器学习的...这些实验不仅加深了对机器学习算法的理解，还提供了实践经验，帮助学生掌握如何在实际问题中应用这些算法。通过这种方式，学生可以更好地理解和评估不同算法在解决特定问题时的性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值