keras 循环神经网络,keras Python

　　本文主要介绍python神经网络Keras常用学习速率的衰减总结。有需要的朋友可以借鉴一下，希望能有所帮助。祝大家进步很大，早日升职加薪。

　　00-1010前言为什么要调控学习率下降？总结1，分级下降2，指数下降3，余弦退火衰减4，余弦退火衰减更新版。

前言

　　在深度学习中，学习速率的调整非常重要。

　　学习率有以下优点：

　　1.加快学习速度。

　　2.有助于跳出局部最优。

　　但是有以下缺点：

　　1.模型训练不收敛。

　　2.只使用大的学习率很容易导致模型不准确。

　　低学习率有以下优点：

　　1.它有助于模型收敛和改进。

　　2.提高模型精度。

　　但是有以下缺点：

　　1.无法跳出局部最优值。

　　2.收敛慢。

　　高学习率和低学习率的作用几乎相反。因此，我们可以通过适当调整学习率来最大程度地提高训练成绩。

为什么要调控学习率

下降方式汇总

　　在Keras中，ReduceLROnPlateau函数常用来实现层次化约简。性下降意味着学习率会突然变成原来的1/2或者1/10。

　　使用ReduceLROnPlateau，可以指定在某个指标没有继续降低后，学习率会突然降低到原来的1/2或者1/10，比如验证集的丢失，训练集的丢失。

　　ReduceLROnPlateau的主要参数有：

　　1.因子：某一指标不再继续降低后，学习率降低的速率。

　　2.耐心：某个指标几次不继续下降后，学习率开始下降。

　　# Import ReduceLROnPlateau

　　从keras.callbacks导入ReduceLROnPlateau

　　#定义ReduceLROnPlateau

　　reduce _ lr=ReduceLROnPlateau(monitor= val _ loss ，factor=0.5，patience=2，verbose=1)

　　#使用ReduceLROnPlateau

　　model.fit(X_train，Y_train，callbacks=[reduce_lr])

1、阶层性下降

　　在Keras中，我没有找到一个特别好的回调来直接实现指数下降，所以我用回调类实现了一个。

　　指数下降是指学习率会随着指数函数下降。

　　具体公式如下：

　　1.learning_rate指的是当前的学习速率。

　　2.learning_rate_base指的是基础学习率。

　　3.decay_rate指的是衰减系数。

　　效果如图所示：

　　实现方式如下，通过回调实现，类似于ReduceLROnPlateau的普通调用方式：

　　将numpy作为np导入

　　将matplotlib.pyplot作为plt导入

　　导入keras

　　从keras导入后端作为K

　　从keras.layers导入Flatten、Conv2D、Dropout、Input、Dense、MaxPooling2D

　　从keras.models导入模型

　　定义指数(global_epoch，

　　学习率基础，

　　衰变率，

　　min_learn_rate=0

　　学习率=学习率基础*采购订单

　　w(decay_rate, global_epoch)

　　 learning_rate = max(learning_rate,min_learn_rate)

　　 return learning_rate

　　class ExponentDecayScheduler(keras.callbacks.Callback):

　　 """

　　继承Callback，实现对学习率的调度

　　 """

　　 def __init__(self,

　　 learning_rate_base,

　　 decay_rate,

　　 global_epoch_init=0,

　　 min_learn_rate=0,

　　 verbose=0):

　　 super(ExponentDecayScheduler, self).__init__()

　　 # 基础的学习率

　　 self.learning_rate_base = learning_rate_base

　　 # 全局初始化epoch

　　 self.global_epoch = global_epoch_init

　　 self.decay_rate = decay_rate

　　 # 参数显示

　　 self.verbose = verbose

　　 # learning_rates用于记录每次更新后的学习率，方便图形化观察

　　 self.min_learn_rate = min_learn_rate

　　 self.learning_rates = []

　　 def on_epoch_end(self, epochs ,logs=None):

　　 self.global_epoch = self.global_epoch + 1

　　 lr = K.get_value(self.model.optimizer.lr)

　　 self.learning_rates.append(lr)

　　 #更新学习率

　　 def on_epoch_begin(self, batch, logs=None):

　　 lr = exponent(global_epoch=self.global_epoch,

　　 learning_rate_base=self.learning_rate_base,

　　 decay_rate = self.decay_rate,

　　 min_learn_rate = self.min_learn_rate)

　　 K.set_value(self.model.optimizer.lr, lr)

　　 if self.verbose > 0:

　　 print(nBatch %05d: setting learning

　　 rate to %s. % (self.global_epoch + 1, lr))

　　# 载入Mnist手写数据集

　　mnist = keras.datasets.mnist

　　(x_train, y_train), (x_test, y_test) = mnist.load_data()

　　x_train, x_test = x_train / 255.0, x_test / 255.0

　　x_train = np.expand_dims(x_train,-1)

　　x_test = np.expand_dims(x_test,-1)

　　#-----------------------------#

　　# 创建模型

　　#-----------------------------#

　　inputs = Input([28,28,1])

　　x = Conv2D(32, kernel_size= 5,padding = same,activation="relu")(inputs)

　　x = MaxPooling2D(pool_size = 2, strides = 2, padding = same,)(x)

　　x = Conv2D(64, kernel_size= 5,padding = same,activation="relu")(x)

　　x = MaxPooling2D(pool_size = 2, strides = 2, padding = same,)(x)

　　x = Flatten()(x)

　　x = Dense(1024)(x)

　　x = Dense(256)(x)

　　out = Dense(10, activation=softmax)(x)

　　model = Model(inputs,out)

　　# 设定优化器，loss，计算准确率

　　model.compile(optimizer=adam,

　　 loss=sparse_categorical_crossentropy,

　　 metrics=[accuracy])

　　# 设置训练参数

　　epochs = 10

　　init_epoch = 0

　　# 每一次训练使用多少个Batch

　　batch_size = 31

　　# 最大学习率

　　learning_rate_base = 1e-3

　　sample_count = len(x_train)

　　# 学习率

　　exponent_lr = ExponentDecayScheduler(learning_rate_base = learning_rate_base,

　　 global_epoch_init = init_epoch,

　　 decay_rate = 0.9,

　　 min_learn_rate = 1e-6

　　 )

　　# 利用fit进行训练

　　model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size,

　　 verbose=1, callbacks=[exponent_lr])

　　plt.plot(exponent_lr.learning_rates)

　　plt.xlabel(Step, fontsize=20)

　　plt.ylabel(lr, fontsize=20)

　　plt.axis([0, epochs, 0, learning_rate_base*1.1])

　　plt.xticks(np.arange(0, epochs, 1))

　　plt.grid()

　　plt.title(lr decay with exponent, fontsize=20)

　　plt.show()

3、余弦退火衰减

　　余弦退火衰减法，学习率会先上升再下降，这是退火优化法的思想。（关于什么是退火算法可以百度。）

　　上升的时候使用线性上升，下降的时候模拟cos函数下降。

　　效果如图所示：

　　余弦退火衰减有几个比较必要的参数：

　　1、learning_rate_base：学习率最高值。

　　2、warmup_learning_rate：最开始的学习率。

　　3、warmup_steps：多少步长后到达顶峰值。

　　实现方式如下，利用Callback实现，与普通的ReduceLROnPlateau调用方式类似：

import numpy as np

4、余弦退火衰减更新版

　　论文当中的余弦退火衰减并非只上升下降一次，因此我重新写了一段代码用于实现多次上升下降：