随机优化

17 Mar 2025 | 6 分钟阅读

随机优化是一种强大的方法，通过使用随机选择的训练数据子集迭代更新模型参数来确定模型的最佳参数。与每次迭代都考虑整个数据集的标准优化方法不同，随机优化算法仅使用一小部分数据，使其更适用于大型数据集和非凸优化问题。

随机优化技术具有广泛的应用，包括机器学习、深度学习、计算机视觉、自然语言处理和大型数据集优化挑战。它们通常用于训练神经网络、优化超参数、选择特征并有效处理复杂的优化问题。

代码

现在我们将探讨一些常见的随机优化算法。

导入库

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.datasets import make_moons
from sklearn.datasets import make_circles

from sklearn.model_selection import train_test_split

读取数据集

datasets = {}

datasets['blobs'] = {}
datasets['moons'] = {}
datasets['circles'] = {}
# blobs
X, y = make_blobs(n_samples=100, centers=2, n_features=2)

datasets['blobs']['X'] = X
datasets['blobs']['y'] = y

# moons
X, y = make_moons(n_samples=5000, random_state=42, noise=0.1)

datasets['moons']['X'] = X
datasets['moons']['y'] = y

# circle
X, y = make_circles(n_samples=100, noise=0.05)

datasets['circles']['X'] = X
datasets['circles']['y'] = y

绘制数据集

现在，我们将绘制数据集。

for dkey in list(datasets.keys()):
    X = datasets[dkey]['X']
    y = datasets[dkey]['y']
    df = pd.DataFrame(dict(x=X[:,0], y=X[:,1], label=y))
    colors = {0:'red', 1:'blue', 2:'green'}
    fig, ax = plt.subplots()
    fig.suptitle(dkey, fontsize=20)
    grouped = df.groupby('label')
    for key, group in grouped:
        group.plot(ax=ax, kind='scatter', x='x', y='y', label=key, color=colors[key])
    plt.show()

输出

def shuffle(X, y):
    Z = np.column_stack((X, y))
    np.random.shuffle(Z)
    return Z[:, :-1], Z[:, -1]

模型实现

我们将构建模型，然后实现它。

n_feature = 2
n_class = 2


def make_network(n_hidden=100):
    model = dict(
        W1=np.random.randn(n_feature, n_hidden),
        W2=np.random.randn(n_hidden, n_class)
    )

    return model

# Activation Function
def softmax(x):
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum()

# Forward- Backward Propagation
def forward(x, model):
    h = x @ model['W1']
    h[h < 0] = 0

    prob = softmax(h @ model['W2'])

    return h, prob


def backward(model, xs, hs, errs):
    dW2 = hs.T @ errs

    dh = errs @ model['W2'].T
    dh[hs < 0] = 0
    dW1 = xs.T @ dh

    return dict(W1=dW1, W2=dW2)

def get_minibatch_grad(model, X_train, y_train):
    xs, hs, errs = [], [], []

    for x, cls_idx in zip(X_train, y_train):
        h, y_pred = forward(x, model)

        y_true = np.zeros(n_class)
        y_true[int(cls_idx)] = 1.
        err = y_true - y_pred

        xs.append(x)
        hs.append(h)
        errs.append(err)

    return backward(model, np.array(xs), np.array(hs), np.array(errs))


def get_minibatch(X, y, minibatch_size):
    minibatches = []

    X, y = shuffle(X, y)

    for i in range(0, X.shape[0], minibatch_size):
        X_mini = X[i:i + minibatch_size]
        y_mini = y[i:i + minibatch_size]

        minibatches.append((X_mini, y_mini))

    return minibatches

优化器

这是我们将要查看随机优化算法的部分。

1. 随机梯度

随机梯度下降（SGD）是一种用于优化具有适当平滑特性（例如，可微分或可次微分）的目标函数的迭代方法。它是梯度下降优化的一种随机近似，因为它将真实梯度（源自整个数据集）替换为估计值（根据随机选择的数据部分计算）。这最大限度地降低了高维优化问题中的计算成本，从而实现更快的迭代但更低的收敛速度。下降（SGD）。

def sgd(model, X_train, y_train, minibatch_size):
    minibatches = get_minibatch(X_train, y_train, minibatch_size)

    for iter in range(1, n_iter + 1):
        idx = np.random.randint(0, len(minibatches))
        X_mini, y_mini = minibatches[idx]

        grad = get_minibatch_grad(model, X_mini, y_mini)

        for layer in grad:
            model[layer] += alpha * grad[layer]

    return model

2. 动量

带有动量的随机梯度下降保留每次迭代的更新 Δw，并将下一次更新推导为梯度和前一次更新的线性组合。

def momentum(model, X_train, y_train, minibatch_size):
    velocity = {k: np.zeros_like(v) for k, v in model.items()}
    gamma = .9

    minibatches = get_minibatch(X_train, y_train, minibatch_size)

    for iter in range(1, n_iter + 1):
        idx = np.random.randint(0, len(minibatches))
        X_mini, y_mini = minibatches[idx]

        grad = get_minibatch_grad(model, X_mini, y_mini)

        for layer in grad:
            velocity[layer] = gamma * velocity[layer] + alpha * grad[layer]
            model[layer] += velocity[layer]

    return model

3. Nesterov 动量

Nesterov 动量，或 Nesterov 加速梯度（NAG），是随机梯度下降动量的一种略微修改形式，为凸函数提供更好的理论收敛保证。在实践中，它比传统动量产生了稍好的结果。

def nesterov(model, X_train, y_train, minibatch_size):
    velocity = {k: np.zeros_like(v) for k, v in model.items()}
    gamma = .9

    minibatches = get_minibatch(X_train, y_train, minibatch_size)

    for iter in range(1, n_iter + 1):
        idx = np.random.randint(0, len(minibatches))
        X_mini, y_mini = minibatches[idx]

        model_ahead = {k: v + gamma * velocity[k] for k, v in model.items()}
        grad = get_minibatch_grad(model, X_mini, y_mini)

        for layer in grad:
            velocity[layer] = gamma * velocity[layer] + alpha * grad[layer]
            model[layer] += velocity[layer]

    return model

4. AdaGrad

AdaGrad（自适应梯度算法）是一种修改后的随机梯度下降技术，它使用每个参数的学习率。它最初于 2011 年描述。非正式地，这提高了稀疏参数的学习率，同时降低了不那么稀疏的参数的学习率。在数据稀疏且稀疏参数信息量更大的情况下，该技术通常优于传统的随机梯度下降。

def adagrad(model, X_train, y_train, minibatch_size):
    cache = {k: np.zeros_like(v) for k, v in model.items()}

    minibatches = get_minibatch(X_train, y_train, minibatch_size)

    for iter in range(1, n_iter + 1):
        idx = np.random.randint(0, len(minibatches))
        X_mini, y_mini = minibatches[idx]

        grad = get_minibatch_grad(model, X_mini, y_mini)

        for k in grad:
            cache[k] += grad[k]**2
            model[k] += alpha * grad[k] / (np.sqrt(cache[k]) + eps)

    return model

5. RMSProp

RMSProp（Root Mean Square Propagation 的缩写）是另一种为每个参数调整学习率的方法。这个概念是将权重的学习率除以其最近梯度的幅度的运行平均值。首先，运行平均值以均方值确定。

def rmsprop(model, X_train, y_train, minibatch_size):
    cache = {k: np.zeros_like(v) for k, v in model.items()}
    gamma = .9

    minibatches = get_minibatch(X_train, y_train, minibatch_size)

    for iter in range(1, n_iter + 1):
        idx = np.random.randint(0, len(minibatches))
        X_mini, y_mini = minibatches[idx]

        grad = get_minibatch_grad(model, X_mini, y_mini)

        for k in grad:
            cache[k] = gamma * cache[k] + (1 - gamma) * (grad[k]**2)
            model[k] += alpha * grad[k] / (np.sqrt(cache[k]) + eps)

    return model

6. Adam

Adam（自适应矩估计）是 RMSProp 优化器的升级。这种优化方法使用梯度及其二阶矩的运行平均值。

def adam(model, X_train, y_train, minibatch_size):
    M = {k: np.zeros_like(v) for k, v in model.items()}
    R = {k: np.zeros_like(v) for k, v in model.items()}
    beta1 = .9
    beta2 = .999

    minibatches = get_minibatch(X_train, y_train, minibatch_size)

    for iter in range(1, n_iter + 1):
        t = iter
        idx = np.random.randint(0, len(minibatches))
        X_mini, y_mini = minibatches[idx]

        grad = get_minibatch_grad(model, X_mini, y_mini)

        for k in grad:
            M[k] = beta1 * M[k] + (1. - beta1) * grad[k]
            R[k] = beta2 * R[k] + (1. - beta2) * grad[k]**2

            m_k_hat = M[k] / (1. - beta1**(t))
            r_k_hat = R[k] / (1. - beta2**(t))

            model[k] += alpha * m_k_hat / (np.sqrt(r_k_hat) + eps)

    return model

训练

## Parameters
n_iter = 100
eps = 1e-8
alpha = 1e-2
minibatch_size = 100
n_experiment = 3


optimizers = dict(
    sgd=sgd,
    momentum=momentum,
    nesterov=nesterov,
    adagrad=adagrad,
    rmsprop=rmsprop,
    adam=adam
)

for dkey in list(datasets.keys()):
    X = datasets[dkey]['X']
    y = datasets[dkey]['y']
    
    print('Dataset:', dkey)
    print('-' * 50)
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
    
    algo_accs = {k: np.zeros(n_experiment) for k in optimizers}

    for algo_name, algo in optimizers.items():

        for k in range(n_experiment):
            model = make_network()
            model = algo(model, X_train, y_train, minibatch_size)

            y_pred = np.zeros_like(y_test)

            for i, x in enumerate(X_test):
                _, prob = forward(x, model)
                y = np.argmax(prob)
                y_pred[i] = y

            algo_accs[algo_name][k] = np.mean(y_pred == y_test)

    print()

    for k, v in algo_accs.items():
        print('{0:10s} => mean accuracy: {1:.5f}, std: {2:.5f}'.format(k, v.mean(), v.std()))
        
    print()
    print('-' * 50)

输出

从以上结果我们可以看出

对于 blobs 数据集，所有优化技术都表现出色，获得了完全的准确性。
SGD、AdaGrad、RMSprop 和 Adam 在 moons 数据集上表现良好，但动量和 Nesterov 的准确性较差且变异性较大。
SGD 在 circles 数据集上表现最佳，其次是 AdaGrad、RMSprop 和 Adam。动量和 Nesterov 的得分很差，这表明它们可能难以处理数据集的非线性。
总的来说，SGD、AdaGrad、RMSprop 和 Adam 在数据集上都表现出有希望的性能，其中 SGD 最稳定。然而，所使用的算法可能取决于数据集的特定属性和优化目标。

下一主题机器学习中的元学习

随机优化

导入库

读取数据集

绘制数据集

模型实现

优化器

1. 随机梯度

2. 动量

3. Nesterov 动量

4. AdaGrad

5. RMSProp

6. Adam

训练

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

机器学习

监督式学习

分类

杂项

相关教程

面试题

随机优化

导入库

读取数据集

绘制数据集

模型实现

优化器

1. 随机梯度

2. 动量

3. Nesterov 动量

4. AdaGrad

5. RMSProp

6. Adam

训练

相关帖子

使用 Python 中的 XGBoost 进行分类

独立成分分析

上下文多臂老虎机简介

机器学习中的遗传算法

分类与回归

张量处理单元

函数导数简介

10 个生成对抗网络 (GAN) 项目创意

机器学习中的作物产量预测

微调大型语言模型

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器