Оптимізатори нейромереж
Розглядаємо оптимізатори нейромереж, такі як SGD+Momentum та Adaptive Moment Estimation (Adam).
Код і результати
Опублікована версія після Merge. Результати збережені автором; код на цій сторінці не запускається.
Python · 1
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import numpy as npPython · 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)Результат, збережений автором у 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, 1Python · 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, dldwPython · 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, lossPython · 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)Результат, збережений автором у Colab
np.float64(0.9888888888888889)
Python · 9
plt.plot(loss);Результат, збережений автором у Colab
Python · 10
plt.plot(step_l2_storage);Результат, збережений автором у Colab
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, lossPython · 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()Результат, збережений автором у Colab
Точність на валідації: 0.9777777777777777
Рев’ю спільноти
Гарна робота. Approve.
