Resumo dos Métodos de Otimização do Modelo

A escolha do método de otimização do modelo está diretamente relacionada ao desempenho do modelo final. Às vezes, o efeito não é bom, não necessariamente um problema de recursos ou design do modelo, mas provavelmente um problema do algoritmo de otimização, e um bom algoritmo de otimização também pode ajudar a acelerar o treinamento do modelo.

O processo de desenvolvimento do modelo de aprendizado profundo:
SGD -> SGDM -> NAG -> AdaGrad -> AdaDelta -> Adam -> Nadam

1. Estrutura geral
Primeiro defina:
os parâmetros a serem otimizados $w$ , função objetivo:$f\left(w\right)$ , a taxa de aprendizado$\alpha$
por iteração:

Calcule o gradiente da função objetivo em relação aos parâmetros: $gt=▽f\left(wt\right)$
calcula o momento de primeira e segunda ordem dos gradientes históricos:
$mt=\varphi (g1,\_g2,\_...,gt),\_Vt\_=\psi (g1,\_g2,\_...,gt)\_$

Calcule o gradiente de descida no momento atual: $\eta t=uma\cdot m_{}/\sqrt{V_{}}$

Os parâmetros são atualizados de acordo com o gradiente de descida: $wt+1=wt-\eta t$

As etapas 3 e 4 são consistentes para cada algoritmo, e a principal diferença é refletida em 1 e 2.

1. Método de descida de gradiente SGD

O método de otimização mais básico, atualizando os parâmetros na direção do gradiente negativo, é implementado da seguinte forma:

# 梯度下降法
w += - learning_rate * dw

Dentre eles, learning_rate é um hiperparâmetro que representa a taxa de aprendizado, a variável atualizada é w, e seu gradiente é dw, gradient->position, que é fácil de entender.

deficiência:

• É possível cair em um mínimo local e é fácil ficar preso em um ponto de sela;
• É fácil gerar oscilações e não convergir, e eventualmente sempre flutuará em torno do valor mínimo, e não atingirá o valor mínimo e permanecerá aqui;
• A velocidade de declínio é lenta e o valor ótimo global não pode ser alcançado por muito tempo;
• É difícil escolher a taxa de aprendizado apropriada;
• Gradientes uniformemente dimensionados em todas as direções, não adequados para dados esparsos

2. Impulso

O método do momento é um tipo de método de otimização inspirado no momento da física. Pode ser entendido simplesmente como: quando rolamos uma pequena bola montanha abaixo, se não houver resistência, seu momento aumentará, mas se encontrarmos resistência, a velocidade será reduzido. A implementação é a seguinte:

# 动量法
w += beta * w - learning_rate * (1-beta) * dw  # 梯度影响速度

O valor inicial da variável v é definido como 0, e o hiperparâmetro mu é considerado como momento no processo de otimização, e seu significado físico pode ser considerado como o coeficiente de atrito. A adição deste item pode tornar a velocidade da dimensão inalterada na direção do gradiente mais rápido, atualizações mais lentas são feitas em dimensões onde a direção do gradiente mudou, o que resulta em convergência mais rápida e menos oscilação. A diferença de antes é que o gradiente não afeta diretamente a posição, gradiente->velocidade->posição.

Vantagens :

• maior estabilidade;
• convergência mais rápida;
• Há também uma certa capacidade de escapar de ótimos locais.

3. RMSprop

RMSprop (Root Mean Square prop) é um método de taxa de aprendizado adaptável que ainda atualiza a posição com base em gradientes. Para remover a oscilação na descida do gradiente, é adicionada uma média exponencialmente ponderada dos gradientes quadrados. A média exponencialmente ponderada com um gradiente grande é grande e a média exponencialmente ponderada com um gradiente pequeno é pequena, garantindo que os gradientes de cada dimensão estejam em uma boa oportunidade, reduzindo assim as oscilações.
Para uma compreensão popular da média exponencialmente ponderada, consulte https://zhuanlan.zhihu.com/p/29895933

# RMSprop
cache = decay_rate * cache + (1 - decay_rate) * dw**2 # 梯度平方的指数加权平均
w += - learning_rate * dw / (np.sqrt(cache) + eps) # 基于梯度更新

Entre eles, decay_rate e eps são hiperparâmetros , e o valor da variável cache em cada etapa é diferente, portanto pode ser considerado como um ajuste adaptativo à taxa de aprendizado.
Existem alguns outros otimizadores com melhores efeitos, já que esses pré-requisitos são suficientes para entender Adam, não vou apresentá-los muito aqui.

Adão

Adam pode ser visto como uma combinação de método de momento e RMSprop

# Adam
m = beta1*m + (1-beta1)*dx
v = beta2*v + (1-beta2)*(dx**2)
x += - learning_rate * m / (np.sqrt(v) + eps)

Para o processamento de m e v, também é utilizada uma média exponencialmente ponderada. Comparado com o RMSprop, o gradiente é substituído por um m suave e o processamento do cache permanece basicamente inalterado. Os valores iniciais dos hiperparâmetros beta1 e beta2 estão próximos de 1, então o termo de viés calculado está próximo de 0.

Adam W

AdamW é um algoritmo melhorado baseado na regularização Adam+L2.
Usar Adam para otimizar a perda com regularização L2 não é eficiente. Se o termo regular L2 for introduzido, o resultado do gradiente do termo regular será adicionado ao calcular o gradiente. Então, se os gradientes correspondentes a alguns dos pesos que são relativamente grandes também forem relativamente grandes, já que os itens subtraídos na etapa de cálculo de Adam serão divididos pelo acúmulo do quadrado do gradiente, os itens subtraídos serão pequenos. É senso comum que pesos maiores devem penalizar maiores, mas esse não é o caso de Adão. O decaimento de peso usa o mesmo coeficiente para atualizar todos os pesos e quanto maior o peso, maior a penalidade. Apenas a regularização L2 é fornecida em bibliotecas comuns de aprendizado profundo e não há implementação de redução de peso.

Adam+L2 VS AdamW

O vermelho na imagem é o método tradicional de regularização Adam+L2, e o verde é o método Adam+weightdecay. Pode-se observar que a diferença entre os dois métodos está apenas na posição do "coeficiente multiplicado pelo valor do parâmetro da etapa anterior". Vamos dar uma olhada na implementação específica de AdamW em combinação com o código.

O código a seguir é da função apply_gradients em AdamWeightDecayOptimizer em https://github.com/macanv/BERT-BiLSTM-CRF-NER/blob/master/bert_base/bert/optimization.py , o otimizador no BERT usa esse método. Alguns comentários também são feitos no código para corresponder à versão simplificada da fórmula de Adam dada anteriormente, que é fácil de entender. Pode-se observar que a sentença update += self.weight_decay_rate * param não está em Adam, ou seja, o código correspondente à parte verde em Adam. A etapa de weightdecay ocorre após o cálculo de atualização do parâmetro que precisa ser atualizado em Adam, e em Adam Esta é exatamente a mesma ordem do pseudocódigo na imagem antes de multiplicar por learning_rate. Resumindo, se você usar weightdecay, não precisará mais usar a regularização L2.

      # m = beta1*m + (1-beta1)*dx
      next_m = (tf.multiply(self.beta_1, m) + tf.multiply(1.0 - self.beta_1, grad))
      # v = beta2*v + (1-beta2)*(dx**2)
      next_v = (tf.multiply(self.beta_2, v) + tf.multiply(1.0 - self.beta_2, tf.square(grad)))
      # m / (np.sqrt(v) + eps)
      update = next_m / (tf.sqrt(next_v) + self.epsilon)
      # Just adding the square of the weights to the loss function is *not*
      # the correct way of using L2 regularization/weight decay with Adam,
      # since that will interact with the m and v parameters in strange ways.
      #
      # Instead we want ot decay the weights in a manner that doesn't interact
      # with the m/v parameters. This is equivalent to adding the square
      # of the weights to the loss with plain (non-momentum) SGD.
      if self._do_use_weight_decay(param_name):
        update += self.weight_decay_rate * param
      update_with_lr = self.learning_rate * update
      # x += - learning_rate * m / (np.sqrt(v) + eps)
      next_param = param - update_with_lr

O comentário original em inglês também explicou a diferença entre Adam e a regularização Adam+L2 tradicional.Bem, você deve ser capaz de entender Adam aqui, e você também pode entender a melhoria de AdamW em Adam.

Olhando para o futuro, RAdam?

Lookahead e RAdam são otimizadores relativamente novos, e os princípios específicos não são apresentados aqui. Mas eu tenho perguntas que Deus precisa responder.
Existe tal comentário no código fonte do otimizador introduzido no BERT

  # It is recommended that you use this optimizer for fine tuning, since this
  # is how the model was trained (note that the Adam m/v variables are NOT
  # loaded from init_checkpoint.)

Ou seja, é altamente recomendável usar o otimizador AdamW ao ajustar o BERT. Usando BERT de 6 camadas em meu próprio conjunto de dados NER, AdamW pode obter cerca de 98% do valor F1. Tentei usar RAdam, Lookahead+RAdam, Lookahead+AdamW e Ranger, e os resultados foram muito ruins. O valor F1 de 0 , ou cerca de 30%, parece não ter nenhum efeito.

Código fonte de referência do projeto : https://github.com/macanv/BERT-BiLSTM-CRF-NER
RAdam,Lookahead : https://github.com/lifeiteng/Optimizers
https://github.com/michaelrzhang/lookahead
Range r : https://github.com/jyhengcoder/Ranger_tensorflow

LazyAdam

É uma variante do otimizador Adam que lida com atualizações esparsas com mais eficiência.

O algoritmo Adam original mantém dois acumuladores de média móvel para cada variável tranável; esse acumulador é atualizado a cada etapa. Esta classe fornece um mecanismo de manipulação mais lento para atualizações de gradiente de variáveis ​​esparsas. Ele atualiza apenas o acúmulo de média móvel para índices de variáveis ​​esparsas que estão presentes no lote atual, não para todos os índices. Comparado ao otimizador Adam original, ele pode fornecer uma grande melhoria na taxa de transferência de treinamento do modelo para alguns aplicativos. No entanto, ele tem uma semântica diferente do algoritmo Adam original, o que pode levar a resultados esperados diferentes.

Observe que amsgrad atualmente não é suportado, este parâmetro só pode ser False.

Referências

https://www.zhihu.com/question/323747423/answer/790457991
https://www.cnblogs.com/guoyaohua/p/8542554.html
https://zhuanlan.zhihu.com/p/63982470
https:// /zhuanlan.zhihu.com/p/38945390

https://www.jianshu.com/p/e17622b7ffee

https://blog.csdn.net/yinyu19950811/article/details/90476956

https://ruder.io/optimizing-gradient-descent/index.html

https://mooc.study.163.com/learn/2001281003?tid=2403023002& trace_c_p_k2 =a20d455215c44c419594a999c46400ee#/learn/content