【机器学习】numpy实现Adam优化器

💥 项目专栏：【Python实现经典机器学习算法】附代码+原理介绍

文章目录

• 前言
• 一、Adam优化原理
• 二、更新规则
• 三、迭代过程
• 四、代码实践

前言

• 👑 最近粉丝群中很多朋友私信咨询一些决策树、逻辑回归等机器学习相关的编程问题，为了能更清晰的说明，所以建立了本专栏 专门记录基于原生Python实现一些入门必学的机器学习算法，帮助广大零基础用户达到轻松入门，为了更深刻算法的基本原理，本专栏没有采用第三方库来实现（sklearn），而是采用原生Python自己复现相关算法，从而帮助新手理解算法的内部细节。
• 👑 本专栏适用人群：🚨🚨🚨 机器学习初学者， 刚刚接触sklearn的用户群体，专栏将具体讲解如何基于原生Python来实现一些经典机器学习算法， 快速让新手小白能够对机器学习算法有更深刻的理解。
• 👑 本专栏内包含基于原生Python从零实现经典机器学习算法，通过自复现帮助新手小白对算法有更深刻的认识，理论与实践相结合，每一篇文章都附带有 完整的代码+原理讲解。

🚨 我的项目环境：

• 平台：Windows11
• 语言环境：Python 3.7
• 编译器：Jupyter Lab
• Pandas：1.3.5
• Numpy：1.19.3
• Scipy：1.7.3
• Matplotlib：3.1.3

💥 项目专栏：【Python实现经典机器学习算法】附代码+原理介绍

一、Adam优化原理

自适应矩估计（Adam）是计算每个参数的自适应学习率的另一种方法。除了存储过去平方梯度（如Adadelta和RMSprop）的指数衰减平均值外，Adam还保持过去梯度的指数衰减平均值，类似于动量：
m t = β 1 m t − 1 + ( 1 − β 1 ) g t v t = β 2 v t − 1 + ( 1 − β 2 ) g t 2 m_t=\beta_1m_{t-1}+(1-\beta_1)g_t\ v_t=\beta_2v_{t-1}+(1-\beta_2)g_t^2 m t ​=β1 ​m t −1 ​+(1 −β1 ​)g t ​v t ​=β2 ​v t −1 ​+(1 −β2 ​)g t 2 ​
它们通过计算偏差修正的第一和第二矩估计值来抵消这些偏差：
m t ^ = m t 1 − β 1 t v t ^ = v t 1 − β 2 t \hat {m_t}=\frac{m_t}{1-\beta_1^t}\ \hat {v_t}=\frac{v_t}{1-\beta_2^t}m t ​^​=1 −β1 t ​m t ​​v t ​^​=1 −β2 t ​v t ​​
然后，他们使用这些来更新参数，正如我们在Adadelta和RMSprop中看到的那样，这产生了Adam更新规则：
θ t + 1 = θ t − η v t ^ + ϵ m t ^ \theta_{t+1}=\theta_t-\frac{\eta}{\sqrt{\hat {v_t}}+\epsilon}\hat {m_t}θt +1 ​=θt ​−v t ​^​​+ϵη​m t ​^​
作者建议的默认值是 β 1 = 0.9 \beta_1=0.9 β1 ​=0.9， β 2 = 0.999 \beta_2=0.999 β2 ​=0.999，他们的经验表明，Adam在实践中运行良好，并优于其他自适应学习方法算法。

二、更新规则

Adam (Adaptive Moment Estimation) 是一种自适应学习率的优化算法，结合了 Momentum 和 RMSprop 的优点，能够更快地收敛并且具有较好的泛化性能。

Adam 的更新规则如下：

m t = β 1 m t − 1 + ( 1 − β 1 ) g t m_t = \beta_1 m_{t-1} + (1-\beta_1) g_t m t ​=β1 ​m t −1 ​+(1 −β1 ​)g t ​
v t = β 2 v t − 1 + ( 1 − β 2 ) g t 2 v_t = \beta_2 v_{t-1} + (1-\beta_2) g_t^2 v t ​=β2 ​v t −1 ​+(1 −β2 ​)g t 2 ​
m ^ t = m t 1 − β 1 t \hat{m}_t = \frac{m_t}{1-\beta_1^t}m ^t ​=1 −β1 t ​m t ​​
v ^ t = v t 1 − β 2 t \hat{v}t = \frac{v_t}{1-\beta_2^t}v ^t =1 −β2 t ​v t ​​
θ t + 1 = θ t − η v ^ t + ϵ m ^ t \theta{t+1} = \theta_t – \frac{\eta}{\sqrt{\hat{v}_t}+\epsilon} \hat{m}_t θt +1 =θt ​−v ^t ​​+ϵη​m ^t ​

其中，m t m_t m t ​ 和 v t v_t v t ​ 分别表示梯度和梯度平方的指数加权移动平均，β 1 \beta_1 β1 ​ 和 β 2 \beta_2 β2 ​ 是衰减率，用于控制移动平均的权重，一般取值为 0.9 和 0.999，m ^ t \hat{m}_t m ^t ​ 和 v ^ t \hat{v}_t v ^t ​ 分别表示偏差校正后的一阶和二阶矩估计，η \eta η 表示学习率，ϵ \epsilon ϵ 是一个非常小的常数，用于保证数值稳定性。

Adam 通过计算梯度的一阶和二阶矩估计来调整每个参数的学习率。一阶矩估计 m t m_t m t ​ 表示梯度的指数加权移动平均，可以看做是对梯度的历史信息的一种估计。二阶矩估计 v t v_t v t ​ 表示梯度平方的指数加权移动平均，可以看做是对梯度平方的历史信息的一种估计。通过对梯度的一阶和二阶矩估计进行归一化，Adam 能够自适应调整每个参数的学习率，从而更快地收敛并且具有较好的泛化性能。

Adam 的优点是可以自适应调整学习率，并且相比于其他优化算法，具有较快的收敛速度和较好的泛化性能。此外，Adam 也易于实现和调整，是一种非常有效的优化算法。

三、迭代过程

; 四、代码实践

import numpy as np
import matplotlib.pyplot as plt

class Optimizer:
    def __init__(self,
                 epsilon = 1e-10,
                 iters = 100000,
                 lamb = 0.01,
                 gamma = 0.9,
                 theta = 1e-8,
                 beta1 = 0.9,
                 beta2 = 0.999):
        self.epsilon = epsilon
        self.iters = iters
        self.lamb = lamb
        self.gamma = gamma
        self.theta = theta
        self.beta1 = beta1
        self.beta2 = beta2

    def adam(self, x_0 = 0.5, y_0 = 0.5):
        f1, f2 = self.fn(x_0, y_0), 0
        w = np.array([x_0, y_0])
        k = 0
        m_t = 0.0
        v_t = 0.0

        while True:
            if abs(f1 - f2)  self.epsilon or k > self.iters:
                break

            f1 = self.fn(x_0, y_0)

            g = np.array([self.dx(x_0, y_0), self.dy(x_0, y_0)])

            m_t = self.beta1 * m_t + (1 - self.beta1) * g
            v_t = self.beta2 * v_t + (1 - self.beta2) * np.dot(g, g)

            m_hat = m_t / (1 - self.beta1)
            v_hat = v_t / (1 - self.beta2)

            x_0, y_0 = np.array([x_0, y_0]) - self.lamb / (self.theta + np.sqrt(v_hat)) * m_hat

            f2 = self.fn(x_0, y_0)

            w = np.vstack((w, (x_0, y_0)))
            k += 1

        self.print_info(k, x_0, y_0, f2)
        self.draw_process(w)

    def print_info(self, k, x_0, y_0, f2):
        print('迭代次数：{}'.format(k))
        print('极值点：【x_0】：{} 【y_0】：{}'.format(x_0, y_0))
        print('函数的极值：{}'.format(f2))

    def draw_process(self, w):
        X = np.arange(0, 1.5, 0.01)
        Y = np.arange(-1, 1, 0.01)
        [x, y] = np.meshgrid(X, Y)
        f = x**3 - y**3 + 3 * x**2 + 3 * y**2 - 9 * x
        plt.contour(x, y, f, 20)
        plt.plot(w[:, 0],w[:, 1], 'g*', w[:, 0], w[:, 1])
        plt.show()

    def fn(self, x, y):
        return x**3 - y**3 + 3 * x**2 + 3 * y**2 - 9 * x

    def dx(self, x, y):
        return 3 * x**2 + 6 * x - 9

    def dy(self, x, y):
        return - 3 * y**2 + 6 * y

"""
    函数: f(x) = x**3 - y**3 + 3 * x**2 + 3 * y**2 - 9 * x
    最优解: x = 1, y = 0
    极小值: f(x,y) = -5
"""
optimizer = Optimizer()
optimizer.adam()

Original: https://blog.csdn.net/m0_47256162/article/details/121577461
Author: Bi 8 Bo
Title: 【机器学习】numpy实现Adam优化器