TelegramOpen channel
Oleg Maris
Merged · Machine Learning

Оптимізатори нейромереж

Розглядаємо оптимізатори нейромереж, такі як SGD+Momentum та Adaptive Moment Estimation (Adam).

Code and results

Published version after Merge. Results were saved by the author; code does not run on this page.

Python · 1
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import numpy as np
Python · 2
digits = load_digits(n_class=2)
X = digits["data"]
y = digits["target"]
X = X / 16.0
y = y.reshape(-1, 1)
X = X.astype(np.float32)
y = y.astype(np.float32)

X_train, X_valid, y_train, y_valid = train_test_split(X, y, stratify=digits["target"])

display(X_train.shape, y_train.shape, X_valid.shape, y_valid.shape)
Results saved by the author in Colab
(270, 64)
(270, 1)
(90, 64)
(90, 1)
Python · 3
# Ініціалізуємо ваги.
np.random.seed(1)

weights = (np.random.randn(X.shape[1], 1) * 0.01).astype(np.float32) # 64, 1
bias    = np.zeros((1, 1), dtype=np.float32) # 1, 1
Python · 4
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_deriv(x):
    return sigmoid(x) * (1 - sigmoid(x))

def forward_pass(X, weights, bias):
  a = X @ weights
  z = a + bias
  σ = sigmoid(z)
  return σ, z, a

def backward_pass(X, σ, z, y):
  dldsigm = 2 * (σ - y)
  dldz = dldsigm * sigmoid_deriv(z)
  dlda = dldz * 1

  # Будемо рахувати градієнти по батчу.
  N = X.shape[0]

  dldb = dlda * 1
  # Агрегуємо градієнт по зміщенню (bias) по батчу
  dldb = np.mean(dldb, axis=0, keepdims=True)

  # Агрегуємо градієнт по вагам (weights) по батчу
  dldw = (X.T @ dlda) / N

  return dldb, dldw
Python · 5
def train_adam(
    X, # Навчальні дані (картинки)
    y, # Класи (0, 1)
    weights, # Ваги
    bias, # Зміщення
    eta,
    num_iter    = 50,
    beta1      = 0.9,
    beta2      = 0.999,
    epsilon     = 1e-8,
    batch_size  = 8
    ):

  loss            = []
  step_l2_storage  = []

  # Перший момент. Аналог v у SGD.
  # Запобігає різким скачкам градієнта - контролює напрямок градієнта.
  # Якщо у нас кілька раз поспіль градієнт був позитивний,
  # а потім на одному кроці став негативний, то підсумковий m1 все ще
  # залишиться зі знаком "+".
  # Зберігає історію минулих градієнтів.
  m1_w = np.zeros_like(weights)
  m2_w = np.zeros_like(weights)
  # Другий момент. Контролює масштаб оновлень градієнта.
  # Якщо трапляються різкі (аномальні) стрибки, він їх згладжує.
  m1_b = np.zeros_like(bias)
  m2_b = np.zeros_like(bias)

  for step in range(1, num_iter + 1):
    idx = np.random.randint(0, X.shape[0], size=(batch_size, ))
    Xb = X[idx]
    yb = y[idx]

    σ, z, a = forward_pass(Xb, weights, bias)
    L = (yb - σ) ** 2

    grad_b, grad_w = backward_pass(Xb, σ, z, yb)

    # Оновлення першого момента для вагів.
    m1_w = beta1 * m1_w + (1 - beta1) * grad_w
    # Оновлення другого момента для вагів.
    m2_w = beta2 * m2_w + (1 - beta2) * grad_w ** 2

    # Аналогічно зробимо для bias.
    m1_b = beta1 * m1_b + (1 - beta1) * grad_b
    m2_b = beta2 * m2_b + (1 - beta2) * grad_b ** 2


    # m1_w = 0.1
    # grad_w = 0.9

    # step = 1
    # m1_hat_w = 0.1 / (1 - 0.9 ** 1) = 1.0

    # step = 300
    # m1_hat_w = 0.1 / (1 - 0.9 ** 300) = 0.1

    # Коррекція моментів.
    # Мета - посилити напрямок і масштаб кроку
    # у перших ітераціях.
    m1_hat_w = m1_w / (1 - beta1 ** step)
    m2_hat_w = m2_w / (1 - beta2 ** step)

    m1_hat_b = m1_b / (1 - beta1 ** step)
    m2_hat_b = m2_b / (1 - beta2 ** step)

    # Оновлюємо ваги.
    step_w = eta * m1_hat_w / (np.sqrt(m2_hat_w) + epsilon)
    step_b = eta * m1_hat_b / (np.sqrt(m2_hat_b) + epsilon)

    weights -= step_w
    bias -= step_b

    step_l2_storage.append(np.linalg.norm(step_w))

    loss.append(np.mean(L))

  return weights, bias, step_l2_storage, loss
Python · 6
# Коєфіцієнт першого моменту. Аналог gamma у SGD.
beta_1 = 0.9
# Коєфіцієнт другого моменту.
beta_2 = 0.999
learning_rate = 1e-3
n_iter = 250
batch_size = 8
epsilon = 1e-8

w, b, step_l2_storage, loss = train_adam(
    X, y,
    weights,
    bias,
    learning_rate,
    n_iter,
    beta_1,
    beta_2,
    epsilon,
    batch_size
    )
Python · 7
# Перевіримо якість навченного нейрону на валідації
def validate_neuron(X, y, weights, bias):
  σ, _, _ = forward_pass(X, weights, bias)
  y_pred  = (σ >= 0.5).astype(np.float32)
  return (y_pred == y).mean()
Python · 8
validate_neuron(X_valid, y_valid, w, b)
Results saved by the author in Colab
np.float64(0.9888888888888889)
Python · 9
plt.plot(loss);
Results saved by the author in ColabCell 9 output
Python · 10
plt.plot(step_l2_storage);
Results saved by the author in ColabCell 10 output
Python · 11
# Оптимізатор: AdamW
def train_adamw(
    X,
    y,
    weights,
    bias,
    eta,
    num_iter=250,
    beta1=0.9,          # Коефіцієнт 1 моменту
    beta2=0.999,        # Коефіцієнт 2 моменту
    weight_decay=0.01,  # Коефіцієнт затухання ваг
    epsilon=1e-8,       # Мале число для уникнення ділення на 0
    batch_size=8
):
    loss = []
    step_l2_storage = []

    # Перший момент (напрямок градієнта)
    m1_w = np.zeros_like(weights)
    m1_b = np.zeros_like(bias)

    # Другий момент (масштаб оновлень / згладжування стрибків)
    m2_w = np.zeros_like(weights)
    m2_b = np.zeros_like(bias)

    for step in range(1, num_iter + 1):
        idx = np.random.randint(0, X.shape[0], size=(batch_size, ))
        Xb = X[idx]
        yb = y[idx]

        σ, z, a = forward_pass(Xb, weights, bias)
        L = (yb - σ) ** 2

        grad_b, grad_w = backward_pass(Xb, σ, z, yb)

        # 1. Оновлення моментів
        m1_w = beta1 * m1_w + (1 - beta1) * grad_w
        m2_w = beta2 * m2_w + (1 - beta2) * grad_w ** 2

        m1_b = beta1 * m1_b + (1 - beta1) * grad_b
        m2_b = beta2 * m2_b + (1 - beta2) * grad_b ** 2

        # 2. Коррекція моментів (Bias correction)
        m1_hat_w = m1_w / (1 - beta1 ** step)
        m2_hat_w = m2_w / (1 - beta2 ** step)

        m1_hat_b = m1_b / (1 - beta1 ** step)
        m2_hat_b = m2_b / (1 - beta2 ** step)

        # 3. Оновлення ваг з урахуванням weight decay (AdamW)
        weights -= eta * (m1_hat_w / (np.sqrt(m2_hat_w) + epsilon) + weight_decay * weights)
        bias    -= eta * (m1_hat_b / (np.sqrt(m2_hat_b) + epsilon))

        step_l2 = np.linalg.norm(eta * m1_hat_w / (np.sqrt(m2_hat_w) + epsilon))
        step_l2_storage.append(step_l2)

        loss.append(np.mean(L))

    return weights, bias, step_l2_storage, loss
Python · 12
num_iter      = 250
learning_rate = 1e-3
beta_1        = 0.9
beta_2        = 0.999
weight_decay  = 0.01
batch_size    = 8
epsilon       = 1e-8

# Переініціалізуємо ваги для чистоти експерименту
np.random.seed(1)
weights = (np.random.randn(X.shape[1], 1) * 0.01).astype(np.float32)
bias    = np.zeros((1, 1), dtype=np.float32)

w, b, step_storage, loss_history = train_adamw(
    X_train, y_train,
    weights, bias,
    learning_rate,
    num_iter,
    beta_1, beta_2,
    weight_decay,
    epsilon,
    batch_size
)

print("Точність на валідації:", validate_neuron(X_valid, y_valid, w, b))

plt.figure(figsize=(10, 4))
plt.subplot(1, 2, 1)
plt.plot(loss_history)
plt.title("Loss (AdamW)")

plt.subplot(1, 2, 2)
plt.plot(step_storage)
plt.title("Step L2 Norm (AdamW)")
plt.show()
Results saved by the author in Colab
Точність на валідації: 0.9777777777777777
Cell 12 output

Community reviews