11.8. RMSProp¶ Open the notebook in SageMaker Studio Lab
Um dos principais problemas em Section 11.7 é que a taxa de aprendizagem diminui em um cronograma predefinido de \(\mathcal{O}(t^{-\frac{1}{2}})\). Embora geralmente seja apropriado para problemas convexos, pode não ser ideal para problemas não convexos, como os encontrados no aprendizado profundo. No entanto, a adaptabilidade coordenada do Adagrad é altamente desejável como um pré-condicionador.
[Tieleman & Hinton, 2012] propôs o algoritmo RMSProp como uma solução simples para desacoplar o escalonamento de taxas das taxas de aprendizagem adaptativa por coordenadas. O problema é que Adagrad acumula os quadrados do gradiente \(\mathbf{g}_t\) em um vetor de estado \(\mathbf{s}_t = \mathbf{s}_{t-1} + \mathbf{g}_t^2\). Como resultado, \(\mathbf{s}_t\) continua crescendo sem limites devido à falta de normalização, essencialmente linearmente conforme o algoritmo converge.
Uma maneira de corrigir esse problema seria usar \(\mathbf{s}_t / t\). Para distribuições razoáveis de \(\mathbf{g}_t\), isso convergirá. Infelizmente, pode levar muito tempo até que o comportamento do limite comece a importar, pois o procedimento lembra a trajetória completa dos valores. Uma alternativa é usar uma média de vazamento da mesma forma que usamos no método de momentum, ou seja, \(\mathbf{s}_t \leftarrow \gamma \mathbf{s}_{t-1} + (1-\gamma) \mathbf{g}_t^2\) para algum parâmetro \(\gamma > 0\). Manter todas as outras partes inalteradas resulta em RMSProp.
11.8.1. O Algoritmo¶
Vamos escrever as equações em detalhes.
A constante \(\epsilon > 0\) é normalmente definida como \(10^{-6}\) para garantir que não soframos divisão por zero ou tamanhos de passos excessivamente grandes. Dada essa expansão, agora estamos livres para controlar a taxa de aprendizado \(\eta\) independentemente da escala que é aplicada por coordenada. Em termos de médias vazadas, podemos aplicar o mesmo raciocínio aplicado anteriormente no caso do método do momento. Expandindo a definição de \(\mathbf{s}_t\) yields
Como antes em Section 11.6 usamos \(1 + \gamma + \gamma^2 + \ldots, = \frac{1}{1-\gamma}\). Portanto, a soma dos pesos é normalizada para \(1\) com um tempo de meia-vida de uma observação de \(\gamma^{-1}\). Vamos visualizar os pesos das últimas 40 etapas de tempo para várias opções de \(\gamma\).
%matplotlib inline
import math
from mxnet import np, npx
from d2l import mxnet as d2l
npx.set_np()
d2l.set_figsize()
gammas = [0.95, 0.9, 0.8, 0.7]
for gamma in gammas:
x = np.arange(40).asnumpy()
d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')
d2l.plt.xlabel('time');
import math
import torch
from d2l import torch as d2l
d2l.set_figsize()
gammas = [0.95, 0.9, 0.8, 0.7]
for gamma in gammas:
x = torch.arange(40).detach().numpy()
d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')
d2l.plt.xlabel('time');
import math
import tensorflow as tf
from d2l import tensorflow as d2l
d2l.set_figsize()
gammas = [0.95, 0.9, 0.8, 0.7]
for gamma in gammas:
x = tf.range(40).numpy()
d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')
d2l.plt.xlabel('time');
11.8.2. Implementação do zero¶
Como antes, usamos a função quadrática \(f(\mathbf{x})=0.1x_1^2+2x_2^2\) para observar a trajetória de RMSProp. Lembre-se de que em Section 11.7, quando usamos o Adagrad com uma taxa de aprendizado de 0,4, as variáveis se moviam apenas muito lentamente nos estágios posteriores do algoritmo, pois a taxa de aprendizado diminuía muito rapidamente. Como \(\eta\) é controlado separadamente, isso não acontece com RMSProp.
def rmsprop_2d(x1, x2, s1, s2):
g1, g2, eps = 0.2 * x1, 4 * x2, 1e-6
s1 = gamma * s1 + (1 - gamma) * g1 ** 2
s2 = gamma * s2 + (1 - gamma) * g2 ** 2
x1 -= eta / math.sqrt(s1 + eps) * g1
x2 -= eta / math.sqrt(s2 + eps) * g2
return x1, x2, s1, s2
def f_2d(x1, x2):
return 0.1 * x1 ** 2 + 2 * x2 ** 2
eta, gamma = 0.4, 0.9
d2l.show_trace_2d(f_2d, d2l.train_2d(rmsprop_2d))
def rmsprop_2d(x1, x2, s1, s2):
g1, g2, eps = 0.2 * x1, 4 * x2, 1e-6
s1 = gamma * s1 + (1 - gamma) * g1 ** 2
s2 = gamma * s2 + (1 - gamma) * g2 ** 2
x1 -= eta / math.sqrt(s1 + eps) * g1
x2 -= eta / math.sqrt(s2 + eps) * g2
return x1, x2, s1, s2
def f_2d(x1, x2):
return 0.1 * x1 ** 2 + 2 * x2 ** 2
eta, gamma = 0.4, 0.9
d2l.show_trace_2d(f_2d, d2l.train_2d(rmsprop_2d))
def rmsprop_2d(x1, x2, s1, s2):
g1, g2, eps = 0.2 * x1, 4 * x2, 1e-6
s1 = gamma * s1 + (1 - gamma) * g1 ** 2
s2 = gamma * s2 + (1 - gamma) * g2 ** 2
x1 -= eta / math.sqrt(s1 + eps) * g1
x2 -= eta / math.sqrt(s2 + eps) * g2
return x1, x2, s1, s2
def f_2d(x1, x2):
return 0.1 * x1 ** 2 + 2 * x2 ** 2
eta, gamma = 0.4, 0.9
d2l.show_trace_2d(f_2d, d2l.train_2d(rmsprop_2d))
Em seguida, implementamos RMSProp para ser usado em uma rede profunda. Isso é igualmente simples.
def init_rmsprop_states(feature_dim):
s_w = np.zeros((feature_dim, 1))
s_b = np.zeros(1)
return (s_w, s_b)
def rmsprop(params, states, hyperparams):
gamma, eps = hyperparams['gamma'], 1e-6
for p, s in zip(params, states):
s[:] = gamma * s + (1 - gamma) * np.square(p.grad)
p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)
def init_rmsprop_states(feature_dim):
s_w = torch.zeros((feature_dim, 1))
s_b = torch.zeros(1)
return (s_w, s_b)
def rmsprop(params, states, hyperparams):
gamma, eps = hyperparams['gamma'], 1e-6
for p, s in zip(params, states):
with torch.no_grad():
s[:] = gamma * s + (1 - gamma) * torch.square(p.grad)
p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)
p.grad.data.zero_()
def init_rmsprop_states(feature_dim):
s_w = tf.Variable(tf.zeros((feature_dim, 1)))
s_b = tf.Variable(tf.zeros(1))
return (s_w, s_b)
def rmsprop(params, grads, states, hyperparams):
gamma, eps = hyperparams['gamma'], 1e-6
for p, s, g in zip(params, states, grads):
s[:].assign(gamma * s + (1 - gamma) * tf.math.square(g))
p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))
Definimos a taxa de aprendizado inicial como 0,01 e o termo de ponderação \(\gamma\) como 0,9. Ou seja, \(\mathbf{s}\) agrega em média nas últimas \(1/(1-\gamma) = 10\) observações do gradiente quadrado.
data_iter, feature_dim = d2l.get_data_ch11(batch_size=10)
d2l.train_ch11(rmsprop, init_rmsprop_states(feature_dim),
{'lr': 0.01, 'gamma': 0.9}, data_iter, feature_dim);
loss: 0.243, 0.739 sec/epoch
data_iter, feature_dim = d2l.get_data_ch11(batch_size=10)
d2l.train_ch11(rmsprop, init_rmsprop_states(feature_dim),
{'lr': 0.01, 'gamma': 0.9}, data_iter, feature_dim);
loss: 0.243, 0.014 sec/epoch
data_iter, feature_dim = d2l.get_data_ch11(batch_size=10)
d2l.train_ch11(rmsprop, init_rmsprop_states(feature_dim),
{'lr': 0.01, 'gamma': 0.9}, data_iter, feature_dim);
loss: 0.245, 0.082 sec/epoch
11.8.3. Implementação concisa¶
Como RMSProp é um algoritmo bastante popular, ele também está disponível
na instância Trainer. Tudo o que precisamos fazer é instanciá-lo
usando um algoritmo chamado rmsprop, atribuindo \(\gamma\) ao
parâmetro gamma1.
d2l.train_concise_ch11('rmsprop', {'learning_rate': 0.01, 'gamma1': 0.9},
data_iter)
loss: 0.242, 0.657 sec/epoch
trainer = torch.optim.RMSprop
d2l.train_concise_ch11(trainer, {'lr': 0.01, 'alpha': 0.9},
data_iter)
loss: 0.243, 0.013 sec/epoch
trainer = tf.keras.optimizers.RMSprop
d2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9},
data_iter)
loss: 0.246, 0.103 sec/epoch
11.8.4. Sumário¶
RMSProp é muito semelhante ao Adagrad na medida em que ambos usam o quadrado do gradiente para dimensionar os coeficientes.
RMSProp compartilha com momentum a média que vaza. No entanto, RMSProp usa a técnica para ajustar o pré-condicionador do coeficiente.
A taxa de aprendizagem precisa ser programada pelo experimentador na prática.
O coeficiente \(\gamma\) determina quanto tempo o histórico é ao ajustar a escala por coordenada.
11.8.5. Exercícios¶
O que acontece experimentalmente se definirmos \(\gamma = 1\)? Por quê?
Gire o problema de otimização para minimizar \(f(\mathbf{x}) = 0.1 (x_1 + x_2)^2 + 2 (x_1 - x_2)^2\). O que acontece com a convergência?
Experimente o que acontece com o RMSProp em um problema real de aprendizado de máquina, como o treinamento em Fashion-MNIST. Experimente diferentes opções para ajustar a taxa de aprendizagem.
Você gostaria de ajustar \(\gamma\) conforme a otimização progride? Quão sensível é o RMSProp a isso?