NN调参炼丹上分手册 - 神经网络调参trick和keras相关经验

常见调参技巧

  • Learning Rate
  • 优化器选择
  • Dropout
  • Batch Size
  • 激活函数
  • BN
  • …

问题和解决方法

  • 关于过拟合问题的讨论
  • Loss为NAN
  • Loss为负数
  • Loss不下降
  • 模型训练加速
  • OOM

keras相关经验

  1. 训练集，验证集和测试集
  2. 查看模型的评价指标
  3. 保存keras输出的loss，val
  4. 绘制精度和损失曲线
  5. 将整型 label 转换成 one-hot 形式
  6. 自制回调函数 callback
  7. 网格超参数搜索
  8. 编写自己的层
  9. keras保存和加载自定义损失模型
  10. PRF 值计算
  11. keras 获取中间层的输出
  12. categorical_crossentropy vs. sparse_categorical_crossentropy
  13. 通过生成器的方式训练模型，节省内存
  14. 多类别预测概率转换
  15. CNN+LSTM的思考
  16. 使用预训练模型的权重

    常见调参技巧

超参上，learning rate 最重要，推荐了解 cosine learning rate 和 cyclic learning rate，其次是 batchsize 和 weight decay。当你的模型还不错的时候，可以试着做数据增广和改损失函数锦上添花了。

Learning Rate

推荐一篇fastai首席设计师「Sylvain Gugger」的一篇博客：How Do You Find A Good Learning Rate[1]

以及相关的论文Cyclical Learning Rates for Training Neural Networks[2]。

一般来说，越大的batch-size使用越大的学习率（一般来说Batch Size变成原始几倍，学习率就增加几倍）。原理很简单，越大的batch-size意味着我们学习的时候，收敛方向的confidence越大，我们前进的方向更加坚定，而小的batch-size则显得比较杂乱，毫无规律性，因为相比批次大的时候，批次小的情况下无法照顾到更多的情况，所以需要小的学习率来保证不至于出错。

在显存足够的条件下，最好采用较大的batch-size进行训练，找到合适的学习率后，可以加快收敛速度。

另外，较大的batch-size可以避免batch normalization出现的一些小问题

  • 采用较小的学习率，则收敛缓慢，也有可能收敛到局部最优解，导致loss没变化；
  • 采用较大的学习率，会使得 loss 上下波动较大，导致loss爆炸=Nan或者无法收敛；

调参技巧：

优化器选择

“Optimization” refers to the process of adjusting a model to get the best performance possible on the training data (the “learning” in “machine learning”),

  • 优化方法使用
    • Adam，Adade，RMSprop结果都差不多，Nadam因为是adam的动量添加的版本，在收敛效果上会更出色。
    • 优化器公用参数 clipnorm 和 clipvalue
      • 参数一：clipnorm 对梯度进行裁剪，最大值为1
      • 参数二：clipvalue 对梯度范围进行裁剪，范围（-x，x）
    • 一般的起手式: Adam（推荐使用3e-4）
    • Keras 推薦 RNN 使用 RMSProp
      • 在訓練 RNN 需要注意 explosive gradient 的問題 => clip gradient 的暴力美學
      • opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
    • SGD+monmentum：
      1. sgd = SGD(lr=learning_rate, decay=learning_rate/nb_epoch, momentum=0.9, nesterov=True)

Dropout

随机丢弃，抑制过拟合，提高模型鲁棒性。

dropout是指在深度学习网络的训练过程中，对于神经网络单元，按照一定的概率将其暂时从网络中丢弃。注意是「暂时」，对于随机梯度下降来说，由于是随机丢弃，故而每一个mini-batch都在训练不同的网络。

通常我们在全连接层部分使用dropout，在卷积层则不使用。在全连接层部分，采用较大概率的dropout而在卷积层采用低概率或者不采用dropout。dropout对小数据防止过拟合有很好的效果,值一般设为0.2-0.5

Dropout作用

  • 一方面缓解过拟合，另一方面引入的随机性，可以平缓训练过程，加速训练过程，处理outliers
  • Dropout可以看做ensemble，特征采样，相当于bagging很多子网络；训练过程中动态扩展拥有类似variation的输入数据集。（在单层网络中，类似折中Naiive bayes(所有特征权重独立)和logistic regression(所有特征之间有关系)；
  • 一般对于越复杂的大规模网络，Dropout效果越好，是一个强regularizer！
  • 最好的防止over-fitting就是有大量不重复数据

Batch Size

  • 太小可能导致不收敛（梯度更新方向变化太大）
  • 太大可能收敛慢
  • 一般选择64

如果可以容忍训练时间过长，最好开始使用尽量小的batch size(16,8,1)。batch size=1是一个很不错的选择, 起码在某些task上,这也有可能是很多人无法复现alex graves实验结果的原因之一，因为他总是把batch size设成1。

激活函数

RELU用极简的方式实现非线性激活，缓解梯度消失

  • 尽量不要用sigmoid，可以用relu之类的激活函数.
  • 最后一层不要用relu，例如分类问题最后一层用softmax，回归问题可以不用。
  • PReLU是一个不错的选择

BatchNormalization

BatchNormalization可以加快收敛速度。

  • 有BN的全连接层没必要加Dropout
  • Batchnormalization层的放置问题 
    1. x = (x - x.mean()) / x.std()

    BN层针对数据分布进行优化，对于BN来说其不但可以防止过拟合，还可以防止梯度消失等问题，并且可以加快模型的收敛速度，但是加了BN，模型训练往往会变得慢些。具体放置位置试！

加深网络

都说深度网络精度更高，但深度不是盲目堆起来的，一定要在浅层网络有一定效果的基础上，增加深度。深度增加是为了增加模型的准确率，如果浅层都学不到东西，深了也没效果。开始一般用3-8层，当效果不错时，为了得到更高的准确率，再尝试加深网络

隐层神经元的数量

太多：训练慢，难去除噪声(over-fitting)

太少：拟合能力下降

一般：256-1024

调参技巧：

  • 分类任务：初始尝试5-10倍类别个数
  • 回归任务：初始尝试2-3倍输入/输出特征数
  • 这里直觉很重要
  • 最终影响其实不大，只是训练过程比较慢，多尝试

CNN的trick

  • pooling或卷积尺寸和步长不一样，增加数据多样性
  • data augumentation，避免过拟合，提高泛化，加噪声扰动
  • weight regularization
  • SGD使用decay的训练方法
  • 最后使用pooling（avgpooling）代替全连接，减少参数量
  • maxpooling代替avgpooling，避免avgpooling带来的模糊化效果
  • 2个3x3代替一个5x5等，减少参数，增加非线性映射，使CNN对特征学习能力强
  • 3x3,2x2窗口
  • 预训练方法等
  • 数据预处理后(PCA,ZCA)喂给模型
  • 输出结果窗口ensemble
  • 中间节点作为辅助输出节点，相当于模型融合，同时增加反向传播的梯度信号，提供了额外的正则化
  • 1x1卷积，夸通道组织信息，提高网络表达，可对输出降维，低成本，性价比高，增加非线性映射，符合Hebbian原理
  • NIN增加网络对不同尺度的适应性，类似Multi-Scale思想
  • Factorization into small convolution，7x7用1x7和7x1代替，节约参数，增加非线性映射
  • BN减少Internal Covariance Shift问题，提高学习速度，减少过拟合，可以取消dropout，增大学习率，减轻正则，减少光学畸变的数据增强
  • 模型遇到退化问题考虑shortcut结构，增加深度
  • 等等

RNN的trick

小的细节和其他很像，简单说两句个人感觉的其他方面吧，其实RNN也是shortcut结构

  • 一般用LSTM结构防止BPTT的梯度消失，GRU拥有更少的参数，可以优先考虑
  • 预处理细节，padding，序列长度设定，罕见词语处理等
  • 一般语言模型的数据量一定要非常大
  • Gradient Clipping
  • Seq2Seq结构考虑attention，前提数据量大
  • 序列模型考率性能优良的CNN+gate结构
  • 一般生成模型可以参考GAN，VAE，产生随机变量
  • RL的框架结合
  • 数据量少考虑简单的MLP
  • 预测采用层级结构降低训练复杂度
  • 设计采样方法，增加模型收敛速度
  • 增加多级shortcut结构

问题和解决方法

关于过拟合问题的讨论

当数据集较小而模型较大时会出现过拟合现象，作者指出了为避免过拟合的经验规律，也即当我们将模型大小扩大8倍时需要将数据集大小扩大5倍。

  • 防止过拟合的方法
    • 第一种就是添加dropout层，dropout可以放在很多类层的后面，用来抑制过拟合现象，常见的可以直接放在Dense层后面，一般在Dropout设置0.5。Dropout相当于Ensemble，dropout过大相当于多个模型的结合，一些差模型会拉低训练集的精度。
      • 通常只加在 hidden layer，不會加在 output layer，因為影響太大了，除非 output layer 的 dimension 很大。
      • Dropout 會讓 training performance 變差
      • 參數少時，regularization
    • 第二种是使用参数正则化，也就是在一些层的声明中加入L1或L2正则化系数，在一定程度上提升了模型的泛化能力。kernel_regularizer=regularizers.l2(0.001)
    • Reducing the network’s size： The simplest way to prevent overfitting is to reduce the size of the model, i.e. the number of learnable parameters in the model
    • Early Stopping
      • 希望在 Model overfitting 之前就停止 training
      • Early Stopping in Keras
        • from keras.callbacks import EarlyStopping
        • early_stopping=EarlyStopping(monitor='val_loss', patience=3)

loss的值为NAN

  • 学习率太高: loss爆炸, 或者nan
  • 学习率太小: 半天loss没反映
  • relu作为激活函数?
  • training sample中出现了脏数据&异常值(nan, inf等)！措施：重整你的数据集
  • 如果是自己定义的损失函数，这时候可能是你设计的损失函数有问题
  • https://zhuanlan.zhihu.com/p/89588946

loss为负数

  • 如果出现loss为负，是因为之前多分类的标签哪些设置不对，现在是5分类的，写成了2分类之后导致了Loss为负数
  • 也可能是损失函数选择错误导致

Loss不下降

  • train loss 不断下降，test loss不断下降，说明网络仍在学习;
  • train loss 不断下降，test loss趋于不变，说明网络过拟合;
  • train loss 趋于不变，test loss不断下降，说明数据集100%有问题;
  • train loss 趋于不变，test loss趋于不变，说明学习遇到瓶颈，需要减小学习率或批量数目;
  • train loss 不断上升，test loss不断上升，说明网络结构设计或超参数设置不当，数据集经过清洗等问题。
  • train loss下降一点后不再下降，学习率过大过小都不收敛

Loss维持在0.69附近（二分类）

loss下降到0.69附近就不下降了，一直停在那里，acc在0.5左右？

  • 0.69是个什么数？
    一般采用的都是cross entropy loss value,定义如下：

2020-04-24-调参炼丹手册 - 图1

  1. 发现就是网络预测给出的二类概率向量为[0.5,0.5]，即a和1-a都是0.5，不管y取值0/1，整个的平均loss就是-ln(0.5)=0.69. **也就是训练过程中，无论如何调节网络都不收敛。**
  • 为啥预测的a老是为0.5呢？
    a的值是softmax的输出，在二分类的情况下为0.5，表明输入softmax的值x是(近似)相等的。

2020-04-24-调参炼丹手册 - 图2

  1. 进一步观察发现，x几乎都很小，随着训练的进行，还有进一步变小的趋势，可怕！
  • 解决办法
    1. 调整初始化和激活函数无法间接保证与调节数据分布，那就强上BN层
      • 即在网络的每一层都加上Batch Normalization层操作，归一化强力保证其分布，果然彻底解决了0.69问题。
    2. 改了Dense层的初始化方式× 
      1. x = Dense(1,kernel_initializer='he_normal',activation='sigmoid',kernel_regularizer=l2(0.00001))(x)
  1. 可能是激活层的激活方式与损失函数不匹配。
    一般使用sigmoid，损失函数使用binary_crossentropy ；使用softmax，损失函数使用categorical_crossentropy
    • 改为softmax loss + sparse_categorical_crossentropy！×
    • contrastive_loss ×
    • 取消relu激活 ×
  2. 训练数据需要打乱，要检查每此batch是否都是一个类别，如果是，则没有办法优化；×
  3. 检查网络是不是没有回传梯度，而是只做了前向运算；×
  4. 二分类问题中 0.5 的 acc 接近随机猜测的值，可以检查下标签是否标错；×
  5. 尝试不同的 Learning Rate (1e-6、2e-5、3e-4)；×
  6. 检查是否在 logit 那层加了激活函数，导致 logits 有问题，例如全为 0，经过 softmax 后就是 0.5了
    • 修改欧式距离为cos距离×
    • 改为差和乘积的拼接；×
  7. 过拟合？尝试Dropout(0.5)×
  8. BERT模型无法共享参数使用？
  9. 数据集本身的问题
    1. 数据本身以及label是否有异常
    2. 数据是否过于脏乱，没有经过清洗
    3. 数据输入是否有问题，比如图片与label是否一致
    4. 数据经过预处理后，是否丢失特征或者因预处理而出现别的问题
    5. 数据量是否过少，网络出现过拟合的现象

Bad Gradient(Dead Neurons)

使用ReLU激活函数，由于其在小于零范围梯度为0，可能会影响模型性能，甚至模型不会在更新
当发现模型随着epoch进行，训练error不变化，可能所以神经元都“死”了。这时尝试更换激活函数如leaky ReLU，ELU，再看训练error变化

  • 使用ReLU时需要给参数加一点噪声，打破完全对称避免0梯度，甚至给biases加噪声
  • 相对而言对于sigmoid，因为其在0值附近最敏感，梯度最大，初始化全为0就可以啦
  • 任何关于梯度的操作，比如clipping, rounding, max/min都可能产生类似的问题
  • ReLU相对Sigmoid优点：单侧抑制；宽阔的兴奋边界；稀疏激活性；解决梯度消失

模型训练加速

关于模型训练加速，论文提到了2点，一是使用更大的Batch Size，二是使用低精度(如FP16)进行训练（也是我们常说的混合精度训练）。关于使用更大的Batch Size进行训练加速，作者指出一般只增加Batch Size的话，效果不会太理想，需要结合如下调参方案：

  • 增大学习率。因为更大的Batch Size意味着每个Batch数据计算得到的梯度更加贴近整个数据集，从数学上来说就是方差更小，因此当更新方向更加准确之后，迈的步子也可以更大，一般来说Batch Size变成原始几倍，学习率就增加几倍。
  • Warm up。Warm up指的是用一个小的学习率先训练几个epoch，这是因为网络的参数是随机初始化的，假如一开始就采用较大的学习率容易出现数值不稳定，这也是为什么要使用Warm up。然后等到训练过程基本上稳定了就可以使用原始的初始学习率进行训练了。作者在使用Warm up的过程中使用线性增加的策略。举个例子假如Warm up阶段的初始学习率是0，warmup阶段共需要训练m个batch的数据（论文实现中m个batch共5个epoch），假设训练阶段的初始学习率是L，那么在第2020-04-24-调参炼丹手册 - 图3个batch的学习率就设置为2020-04-24-调参炼丹手册 - 图4。
  • 每一个残差块后的最后一个BN层的2020-04-24-调参炼丹手册 - 图5参数初始化为0。我们知道BN层的2020-04-24-调参炼丹手册 - 图6，2020-04-24-调参炼丹手册 - 图7参数是用来对标注化后的数据做线性变换的，公式表示为：2020-04-24-调参炼丹手册 - 图8，其中我们一般会把2020-04-24-调参炼丹手册 - 图9设为1，而这篇论文提出初始化为2020-04-24-调参炼丹手册 - 图10则更容易训练。
  • 不对Bias参数做权重惩罚。但是对权重还是要做的。。

ResourceExhaustedError: OOM

  • 意思就是GPU的内存不够了
  • 解决：检查下是否有其他程序占用，不行就重启下IDE，或kill 进程ID

Keras相关经验

1. 训练集，验证集和测试集

  • 验证集是从训练集中抽取出来用于调参的，在validation_split中设置
    • 用 Keras 的 validation_split 之前要記得把資料先弄亂，因為它會從資料的最尾端開始取，如果沒有弄亂的話切出來的資料 bias 會很大。可以使用 np.shuffle 來弄亂
  • 测试集是和训练集无交集的，用于测试所选参数用于该模型的效果的。在evaluate函数里设置
  • 尽量对数据做shuffle

2. 查看模型的评价指标

  1. history_dict = history.history
  2. history_dict.keys()
  3. dict_keys(['val_acc', 'acc', 'val_loss', 'loss’])

3. 保存keras输出的loss，val

  1. hist=model.fit(train_set_x,train_set_y,batch_size=256,shuffle=True,nb_epoch=nb_epoch,validation_split=0.1)
  2. with open('log_sgd_big_32.txt','w') as f:
  3.     f.write(str(hist.history))

4. 绘制精度和损失曲线

  1. import matplotlib.pyplot as plt
  3. def plot(history):
  4.    plt.figure(figsize=(16,7))
  5.    plt.subplot(121)
  6.    plt.xlabel('epoch')
  7.    plt.ylabel('acc')
  8.    plt.plot(history.epoch, history.history['acc'], 'b', label="acc")
  9.    plt.plot(history.epoch, history.history['val_acc'], 'r', label="val_acc")
  10.    plt.scatter(history.epoch, history.history['acc'], marker='*')
  11.    plt.scatter(history.epoch, history.history['val_acc'])
  12.    plt.legend(loc='lower right')
  14.    plt.subplot(122)
  15.    plt.xlabel('epoch')
  16.    plt.ylabel('loss')
  17.    plt.plot(history.epoch, history.history['loss'], 'b', label="loss")
  18.    plt.plot(history.epoch, history.history['val_loss'], 'r', label="val_loss")
  19.    plt.scatter(history.epoch, history.history['loss'], marker='*')
  20.    plt.scatter(history.epoch, history.history['val_loss'], marker='*')
  21.    plt.legend(loc='lower right')
  22.    plt.show()
  24. # 或者
  25. history.loss_plot('epoch')

5. 将整型 label 转换成 one-hot 形式

  1. def to_one_hot(labels, dimension=46):
  2.     results = np.zeros((len(labels), dimension))
  3.     for i, label in enumerate(labels):
  4.         results[i, label] = 1.
  5.     return results

6. 自制回调函数 callback

  1. # 该回调函数将在每个epoch后保存概率文件
  2. from keras.callbacks import Callback
  3. class WritePRF(Callback):
  4.    def __init__(self, data):
  5.       super(WritePRF, self).__init__()
  6.       self.data = data
  7.    def on_epoch_end(self, epoch, logs=None):
  9. # 该回调函数将在每个迭代后保存的最好模型
  10. from keras.callbacks import ModelCheckpoint  
  12. checkpoint = ModelCheckpoint(  
  13.     'model.h5',  
  14.     monitor = 'val_loss',  
  15.     verbose = 1,  
  16.     save_best_only = True,  
  17.     mode = 'min',  
  18. )

7. 网格超参数搜索

Keras/Python深度学习中的网格搜索超参数调优（附源码）

先grid search，再random search（由粗到细）

  1. def create_model():
  2.     # create model
  3.     model = Sequential()
  4.     model.add(Dense(12, input_dim=8, activation='relu'))
  5.     model.add(Dense(1, activation='sigmoid'))
  6.     # Compile model
  7.     model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
  8.     return model
  10. # create model
  11. model = KerasClassifier(build_fn=create_model, verbose=0)
  12. # define the grid search parameters
  13. batch_size = [10, 20, 40, 60, 80, 100]
  14. epochs = [10, 50, 100]
  15. # define the grid search parameters
  16. optimizer = ['SGD', 'RMSprop', 'Adagrad', 'Adadelta', 'Adam', 'Adamax', 'Nadam']
  17. # define the grid search parameters
  18. learn_rate = [0.001, 0.01, 0.1, 0.2, 0.3]
  19. dropout_rate = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
  20. neurons = [1, 5, 10, 15, 20, 25, 30]
  22. param_grid = dict(batch_size=batch_size, epochs=epochs, optimizer=optimizer)
  23. grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=1)
  24. grid_result = grid.fit(X, Y)
  25. # summarize results
  26. print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
  27. means = grid_result.cv_results_['mean_test_score']
  28. stds = grid_result.cv_results_['std_test_score']
  29. params = grid_result.cv_results_['params']
  30. for mean, stdev, param in zip(means, stds, params):
  31.     print("%f (%f) with: %r" % (mean, stdev, param))

8. 编写自己的层

对于简单的定制操作，我们或许可以通过使用layers.core.Lambda层来完成。要定制自己的层，你需要实现下面三个方法:

  • build(input_shape)：这是定义权重的方法
  • call(x)：这是定义层功能的方法，除非你希望你写的层支持masking，否则你只需要关心call的第一个参数：输入张量
  • compute_output_shape(input_shape)：如果你的层修改了输入数据的shape，你应该在这里指定shape变化的方法，这个函数使得Keras可以做自动shape推断
  1. from keras import backend as K
  2. from keras.engine.topology import Layer
  3. import numpy as np
  5. class MyLayer(Layer):
  7.     def __init__(self, output_dim, **kwargs):
  8.         self.output_dim = output_dim
  9.         super(MyLayer, self).__init__(**kwargs)
  11.     def build(self, input_shape):
  12.         # Create a trainable weight variable for this layer.
  13.         self.kernel = self.add_weight(name='kernel', 
  14.                                       shape=(input_shape[1], self.output_dim),
  15.                                       initializer='uniform',
  16.                                       trainable=True)
  17.         super(MyLayer, self).build(input_shape)  # Be sure to call this somewhere!
  19.     def call(self, x):
  20.         return K.dot(x, self.kernel)
  22.     def compute_output_shape(self, input_shape):
  23.         return (input_shape[0], self.output_dim)

9. keras保存和加载自定义损失模型

如果使用了自定义的loss函数， 则需要在加载模型的时候，指定load_model函数提供的一个custom_objects参数：在custom_objects参数词典里加入keras的未知参数，如：

  1. custom_objects={'ChainCRF': ClassWrapper, 'loss': loss, 'sparse_loss': sparse_loss}
  2. model = load_model('model/tmpModel.h5', custom_objects=create_custom_objects())

10. PRF 值计算

  1. from __future__ import print_function
  2. import numpy as np
  4. def calculate(predictions, test_label, RESULT_FILE):
  5.    num = len(predictions)
  6.    with open(RESULT_FILE, 'w') as f:
  7.       for i in range(num):
  8.          if predictions[i][1] > predictions[i][0]:
  9.             predict = +1
  10.          else:
  11.             predict = -1
  12.          f.write(str(predictions[i][0]) + ' ' + str(predictions[i][1]) + '\n')
  13.       # f.write(str(predict) + str(predictions[i]) + '\n')
  15.    TP = len([1 for i in range(num) if
  16.            predictions[i][1] > predictions[i][0] and (test_label[i] == np.asarray([0, 1])).all()])
  17.    FP = len([1 for i in range(num) if
  18.            predictions[i][1] > predictions[i][0] and (test_label[i] == np.asarray([1, 0])).all()])
  19.    FN = len([1 for i in range(num) if
  20.            predictions[i][1] < predictions[i][0] and (test_label[i] == np.asarray([0, 1])).all()])
  21.    TN = len([1 for i in range(num) if
  22.            predictions[i][1] < predictions[i][0] and (test_label[i] == np.asarray([1, 0])).all()])
  24.    precision = recall = Fscore = 0, 0, 0
  25.    try:
  26.       precision = TP / (float)(TP + FP)  # ZeroDivisionError: float division by zero
  27.       recall = TP / (float)(TP + FN)
  28.       Fscore = (2 * precision * recall) / (precision + recall)
  29.    except ZeroDivisionError as exc:
  30.       print(exc.message)
  32.    print(">> Report the result ...")
  33.    print("-1 --> ", len([1 for i in range(num) if predictions[i][1] < predictions[i][0]]))
  34.    print("+1 --> ", len([1 for i in range(num) if predictions[i][1] > predictions[i][0]]))
  35.    print("TP=", TP, "  FP=", FP, " FN=", FN, " TN=", TN)
  36.    print('\n')
  37.    print("precision= ", precision)
  38.    print("recall= ", recall)
  39.    print("Fscore= ", Fscore)

11. keras 获取中间层的输出

  1. # 加载权重到当前模型
  2. model = load_model(model_path)
  4. '''获取中间层的输出'''
  5. layer_name = 'my_layer'
  6. intermediate_layer_model = Model(input=model.input,
  7.                          output=model.get_layer(layer_name).output)
  9. intermediate_output = intermediate_layer_model.predict(X_test)
  10. print(type(intermediate_output))
  12. with open('intermediate_output.txt', 'w') as f:
  13.    for i in intermediate_output:
  14.       f.write(i)

12. keras指定显卡且限制显存用量

keras在使用GPU的时候有个特点，就是默认全部占满显存。需要修改后端代码：

  1. # 方法1:显存占用会随着epoch的增长而增长
  2. # 也就是后面的epoch会去申请新的显存,前面已完成的并不会释放,为了防止碎片化
  4. config = tf.ConfigProto()
  5. config.gpu_options.allow_growth = True  # 按需求增长
  6. sess = tf.Session(config=config)
  7. set_session(sess)
  1. # # 方法2:只允许使用x%的显存,其余的放着不动
  3. config = tf.ConfigProto()
  4. config.gpu_options.per_process_gpu_memory_fraction = 0.5    # 按比例
  5. sess = tf.Session(config=config)

PS: 需要注意的是，虽然代码或配置层面设置了对显存占用百分比阈值，但在实际运行中如果达到了这个阈值，程序有需要的话还是会突破这个阈值。换而言之如果跑在一个大数据集上还是会用到更多的显存。以上的显存限制仅仅为了在跑小数据集时避免对显存的浪费而已。

13. Keras 切换后端（Theano和TensorFlow）

  1. vi ~/.keras/keras.json
  3. {
  4.     "image_dim_ordering": "tf", 
  5.     "epsilon": 1e-07, 
  6.     "floatx": "float32", 
  7.     "backend": "tensorflow"
  8. }

14. categorical_crossentropy vs. sparse_categorical_crossentropy

There are two ways to handle labels in multi-class classification: Encoding the labels via “categorical encoding” (also known as “one-hot encoding”) and using categorical_crossentropy as your loss function. Encoding the labels as integers and using the sparse_categorical_crossentropy loss function.

15. 通过生成器的方式训练模型，节省内存

  1. #从节省内存的角度，通过生成器的方式来训练
  2.     def data_generator(data, chars, targets, data_a, chars_a, targets_a, batch_size): 
  3.         idx = np.arange(len(data))
  4.         np.random.shuffle(idx)
  5.         batches = [idx[range(batch_size*i, min(len(data), batch_size*(i+1)))] for i in range(len(data)//batch_size)]
  6.         while True:
  7.             for i in batches:
  8.                 xx, yy = np.array(data[i]), np.array(targets[i])
  9.                 char = np.array(chars[i])
  10.                 xx_a, yy_a = np.array(data_a[i]), np.array(targets_a[i])
  11.                 char_a = np.array(chars_a[i])
  12.                 yield ([xx, char, xx_a, char_a], [yy, yy_a])
  14.     print('Build model...')
  15.     model = buildModel(max_word)
  17.     generator = data_generator(train_x, train_char, train_y, aux_train_x, aux_train_char, aux_train_y, batch_size)
  18.     samples_per_epoch = len(train_x)
  19.     steps_per_epoch = samples_per_epoch // batch_size
  20.     # StopIteration: dataset fully readed before fit end
  21.     history = model.fit_generator(generator, steps_per_epoch=steps_per_epoch, epochs=epochs)

16. CNN+LSTM的思考

Because RNNs are extremely expensive for processing very long sequences, but 1D convnets are cheap, it can be a good idea to use a 1D convnet as a preprocessing step before a RNN, shortening the sequence and extracting useful representations for the RNN to process.

17. 使用预训练模型的权重

  1. WEIGHTS_PATH = 'bottleneck_fc_model.h5'
  2. model1.save_weights(WEIGHTS_PATH)
  3. model2.load_weights(WEIGHTS_PATH)
  4. # layer.trainable = False
  5. model2.fit()

参考

【神经网络训练】trick总结

深度学习调参tricks总结！

大道至简：算法工程师炼丹Trick手册