3-4 优化器和学习率

主目录点这里

优化器是机器学习和深度学习模型训练过程中用于调整模型参数的方法。它的主要目标是通过最小化损失函数来找到模型参数的最优值，从而提升模型的性能。

在深度学习中，优化器使用反向传播算法计算损失函数相对于模型参数的梯度，并根据这些梯度来更新模型参数。不同的优化器方法在更新参数时使用了不同的策略和技巧。

以下是几种常见的优化器以及它们的实现代码示例：

1. 梯度下降（Gradient Descent）

梯度下降是最基本的优化算法。它通过计算损失函数相对于模型参数的梯度，然后按一个学习率（步长）更新参数。

import numpy as np

# 假设我们有一个简单的二次函数：f(x) = x^2
# 其导数是：f'(x) = 2x
def gradient_descent(learning_rate, iterations):
    x = 10  # 初始化值
    for i in range(iterations):
        gradient = 2 * x  # 计算梯度
        x = x - learning_rate * gradient  # 更新参数
        print(f"Iteration {i+1}: x = {x}, f(x) = {x**2}")

# 运行梯度下降
gradient_descent(learning_rate=0.1, iterations=10)

2. 随机梯度下降（Stochastic Gradient Descent, SGD）

SGD 是一种变体，它在每次更新时使用单个样本（或小批量样本）来计算梯度，而不是整个数据集。这种方法可以使优化过程更快，更适用于大规模数据集。

import numpy as np

# 假设我们有一个数据集和一个简单的线性模型
X = np.array([1, 2, 3, 4])
y = np.array([2, 4, 6, 8])
weights = 0.0
bias = 0.0

def stochastic_gradient_descent(X, y, learning_rate, iterations):
    global weights, bias
    for i in range(iterations):
        for j in range(len(X)):
            prediction = weights * X[j] + bias
            error = prediction - y[j]
            weights = weights - learning_rate * error * X[j]
            bias = bias - learning_rate * error
            print(f"Iteration {i+1}, Sample {j+1}: weights = {weights}, bias = {bias}")

# 运行随机梯度下降
stochastic_gradient_descent(X, y, learning_rate=0.01, iterations=10)

3. 动量梯度下降（Momentum）

动量方法在梯度更新过程中加入了前几次更新的方向，避免陷入局部最小值，提升收敛速度。

def momentum_gradient_descent(learning_rate, iterations, momentum=0.9):
    x = 10  # 初始化值
    v = 0  # 初始速度
    for i in range(iterations):
        gradient = 2 * x  # 计算梯度
        v = momentum * v - learning_rate * gradient  # 更新速度
        x = x + v  # 更新参数
        print(f"Iteration {i+1}: x = {x}, f(x) = {x**2}")

# 运行动量梯度下降
momentum_gradient_descent(learning_rate=0.1, iterations=10)

4. AdaGrad

AdaGrad 通过对梯度的平方和进行调整，使得参数的学习率随着训练的进行而自动减小。这对于稀疏数据特别有用。

def adagrad(learning_rate, iterations):
    x = 10  # 初始化值
    cache = 0  # 累积的平方梯度
    epsilon = 1e-8  # 防止除零
    for i in range(iterations):
        gradient = 2 * x  # 计算梯度
        cache += gradient**2  # 累积平方梯度
        x = x - (learning_rate / (np.sqrt(cache) + epsilon)) * gradient  # 更新参数
        print(f"Iteration {i+1}: x = {x}, f(x) = {x**2}")

# 运行 AdaGrad
adagrad(learning_rate=1.0, iterations=10)

5. RMSProp

RMSProp 是 AdaGrad 的改进版，它使用滑动平均值来计算平方梯度的加权平均，以避免学习率衰减过快。

def rmsprop(learning_rate, iterations, decay_rate=0.9):
    x = 10  # 初始化值
    cache = 0  # 累积的平方梯度
    epsilon = 1e-8  # 防止除零
    for i in range(iterations):
        gradient = 2 * x  # 计算梯度
        cache = decay_rate * cache + (1 - decay_rate) * gradient**2  # 计算加权平均
        x = x - (learning_rate / (np.sqrt(cache) + epsilon)) * gradient  # 更新参数
        print(f"Iteration {i+1}: x = {x}, f(x) = {x**2}")

# 运行 RMSProp
rmsprop(learning_rate=0.1, iterations=10)

6. Adam

Adam（Adaptive Moment Estimation）结合了动量和 RMSProp 的优点，计算出每个参数的自适应学习率。

def adam(learning_rate, iterations, beta1=0.9, beta2=0.999):
    x = 10  # 初始化值
    m, v = 0, 0  # 初始化一阶和二阶动量
    epsilon = 1e-8  # 防止除零
    for i in range(iterations):
        gradient = 2 * x  # 计算梯度
        m = beta1 * m + (1 - beta1) * gradient  # 更新一阶动量
        v = beta2 * v + (1 - beta2) * gradient**2  # 更新二阶动量
        m_hat = m / (1 - beta1**(i + 1))  # 计算偏差修正后的一阶动量
        v_hat = v / (1 - beta2**(i + 1))  # 计算偏差修正后的二阶动量
        x = x - (learning_rate / (np.sqrt(v_hat) + epsilon)) * m_hat  # 更新参数
        print(f"Iteration {i+1}: x = {x}, f(x) = {x**2}")

# 运行 Adam
adam(learning_rate=0.1, iterations=10)