5-7,优化器optimizers

    拿来药材（数据），架起八卦炉（模型），点着六味真火（优化算法），就摇着蒲扇等着丹药出炉了。

    不过，当过厨子的都知道，同样的食材，同样的菜谱，但火候不一样了，这出来的口味可是千差万别。火小了夹生，火大了易糊，火不匀则半生半糊。

    机器学习也是一样，模型优化算法的选择直接关系到最终模型的性能。有时候效果不好，未必是特征的问题或者模型设计的问题，很可能就是优化算法的问题。

    深度学习优化算法大概经历了 SGD -> SGDM -> NAG ->Adagrad -> Adadelta(RMSprop) -> Adam -> Nadam 这样的发展历程。

    详见《一个框架看懂优化算法之异同 SGD/AdaGrad/Adam》

    https://zhuanlan.zhihu.com/p/32230623

    对于一般新手炼丹师，优化器直接使用Adam，并使用其默认参数就OK了。

    此外目前也有一些前沿的优化算法，据称效果比Adam更好，例如LazyAdam, Look-ahead, RAdam, Ranger等.

    优化器主要使用apply_gradients方法传入变量和对应梯度从而来对给定变量进行迭代，或者直接使用minimize方法对目标函数进行迭代优化。

    当然，更常见的使用是在编译时将优化器传入keras的Model,通过调用model.fit实现对Loss的的迭代优化。

    初始化优化器时会创建一个变量optimier.iterations用于记录迭代的次数。因此优化器和tf.Variable一样，一般需要在@tf.function外创建。

    2. import numpy as np 
    4. #打印时间分割线
    5. @tf.function
    6. def printbar():
    7.     ts = tf.timestamp()
    8.     today_ts = ts%(24*60*60)
    10.     hour = tf.cast(today_ts//3600+8,tf.int32)%tf.constant(24)
    11.     minite = tf.cast((today_ts%3600)//60,tf.int32)
    12.     second = tf.cast(tf.floor(today_ts%60),tf.int32)
    14.     def timeformat(m):
    15.         if tf.strings.length(tf.strings.format("{}",m))==1:
    16.             return(tf.strings.format("0{}",m))
    17.         else:
    18.             return(tf.strings.format("{}",m))
    20.     timestring = tf.strings.join([timeformat(hour),timeformat(minite),
    21.                 timeformat(second)],separator = ":")
    22.     tf.print("=========="*8,end = "")
    23.     tf.print(timestring)
    1. # 求f(x) = a*x**2 + b*x + c的最小值
    3. # 使用optimizer.apply_gradients
    5. x = tf.Variable(0.0,name = "x",dtype = tf.float32)
    6. optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)
    8. @tf.function
    9. def minimizef():
    10.     a = tf.constant(1.0)
    11.     c = tf.constant(1.0)
    13.     while tf.constant(True): 
    14.         with tf.GradientTape() as tape:
    15.             y = a*tf.pow(x,2) + b*x + c
    16.         dy_dx = tape.gradient(y,x)
    17.         optimizer.apply_gradients(grads_and_vars=[(dy_dx,x)])
    19.         #迭代终止条件
    20.         if tf.abs(dy_dx)<tf.constant(0.00001):
    21.             break
    23.         if tf.math.mod(optimizer.iterations,100)==0:
    24.             printbar()
    25.             tf.print("step = ",optimizer.iterations)
    26.             tf.print("x = ", x)
    27.             tf.print("")
    29.     y = a*tf.pow(x,2) + b*x + c
    30.     return y
    32. tf.print("y =",minimizef())
    33. tf.print("x =",x)
    1. # 求f(x) = a*x**2 + b*x + c的最小值
    2. # 使用model.fit
    4. tf.keras.backend.clear_session()
    7.     def __init__(self,a,b,c):
    8.         super(FakeModel,self).__init__()
    9.         self.b = b
    10.         self.c = c
    12.     def build(self):
    13.         self.x = tf.Variable(0.0,name = "x")
    14.         self.built = True
    16.     def call(self,features):
    17.         loss  = self.a*(self.x)**2+self.b*(self.x)+self.c
    18.         return(tf.ones_like(features)*loss)
    20. def myloss(y_true,y_pred):
    21.     return tf.reduce_mean(y_pred)
    23. model = FakeModel(tf.constant(1.0),tf.constant(-2.0),tf.constant(1.0))
    25. model.build()
    26. model.summary()
    28. model.compile(optimizer = 
    29.               tf.keras.optimizers.SGD(learning_rate=0.01),loss = myloss)
    30. history = model.fit(tf.zeros((100,2)),
    31.                     tf.ones(100),batch_size = 1,epochs = 10)  #迭代1000次
    1. tf.print("x=",model.x)
    2. tf.print("loss=",model(tf.constant(0.0)))

    二，内置优化器

    深度学习优化算法大概经历了 SGD -> SGDM -> NAG ->Adagrad -> Adadelta(RMSprop) -> Adam -> Nadam 这样的发展历程。

    在keras.optimizers子模块中，它们基本上都有对应的类的实现。

    • SGD, 默认参数为纯SGD, 设置momentum参数不为0实际上变成SGDM, 考虑了一阶动量, 设置 nesterov为True后变成NAG，即 Nesterov Accelerated Gradient，在计算梯度时计算的是向前走一步所在位置的梯度。

    • RMSprop, 考虑了二阶动量，对于不同的参数有不同的学习率，即自适应学习率，对Adagrad进行了优化，通过指数平滑只考虑一定窗口内的二阶动量。

    • Adadelta, 考虑了二阶动量，与RMSprop类似，但是更加复杂一些，自适应性更强。

    • Adam, 同时考虑了一阶动量和二阶动量，可以看成RMSprop上进一步考虑了一阶动量。

    • Nadam, 在Adam基础上进一步考虑了 Nesterov Acceleration。

    如果对本书内容理解上有需要进一步和作者交流的地方，欢迎在公众号”Python与算法之美”下留言。作者时间和精力有限，会酌情予以回复。

    也可以在公众号后台回复关键字：加群，加入读者交流群和大家讨论。