python - 贝叶斯优化可能不适用于 CNN 的原因有哪些

Question

我尝试将贝叶斯优化应用于 MNIST 手写数字数据集的简单 CNN，但几乎没有迹象表明它有效。我尝试过进行 k 倍验证来消除噪声，但似乎优化仍然没有在收敛到最佳参数方面取得任何进展。一般来说，贝叶斯优化可能失败的主要原因有哪些？在我的具体情况下？

其余部分只是上下文和代码片段。

模型定义:

def define_model(learning_rate, momentum):
    model = Sequential()
    model.add(Conv2D(32, (3,3), activation = 'relu', kernel_initializer = 'he_uniform', input_shape=(28,28,1)))
    model.add(MaxPooling2D((2,2)))
    model.add(Flatten())
    model.add(Dense(100, activation='relu', kernel_initializer='he_uniform'))
    model.add(Dense(10, activation='softmax'))
    opt = SGD(lr=learning_rate, momentum=momentum)
    model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy'])
    return model

一次训练运行，超参数:batch_size = 32，学习率 = 1e-2，动量 = 0.9，10 epoch。 (蓝色=训练，黄色=验证)。

5 折交叉验证准确性的箱线图，具有与上述相同的超参数(以了解分布情况)

网格搜索将batch_size保持为32，并保持10个纪元。我在单次评估而不是 5 倍评估中进行了此操作，因为差值不足以破坏结果。

贝叶斯优化。如上，batch_size=32 和 10 epoch。在相同范围内搜索。但这次使用 5 倍交叉验证来平滑噪声。它应该进行 100 次迭代，但距离还需要 20 个小时。

space = {'lr': hp.loguniform('lr', np.log(np.sqrt(10)*1e-4), np.log(1e-1)), 'momentum': 1 - hp.loguniform('momentum', np.log(np.sqrt(10)*1e-3), np.log(np.sqrt(10)*1e-1))}
tpe_best = fmin(fn=objective, space=space, algo=tpe.suggest, trials=Trials(), max_evals=100)

尝试的学习率

尝试的动力

从第 27 次迭代到第 49 次迭代，它看起来不错，但随后又失去了理智。

编辑

为提问者提供更多详细信息。

导入

# basic utility libraries
import numpy as np
import pandas as pd
import time
import datetime
import pickle
from matplotlib import pyplot as plt
%matplotlib notebook

# keras
from keras.datasets import mnist
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Input, BatchNormalization
from keras.optimizers import SGD
from keras.callbacks import Callback
from keras.models import load_model

# learning and optimisation helper libraries
from sklearn.model_selection import KFold
from hyperopt import fmin, tpe, Trials, hp, rand
from hyperopt.pyll.stochastic import sample

单次评估

def evaluate_model(trainX, trainY, testX, testY, max_epochs, learning_rate, momentum, batch_size, model=None, callbacks=[]):
    if model == None:
        model = define_model(learning_rate, momentum)
    history = model.fit(trainX, trainY, epochs=max_epochs, batch_size=batch_size, validation_data=(testX, testY), verbose=0, callbacks = callbacks)
    return model, history

交叉验证

def evaluate_model_cross_validation(trainX, trainY, max_epochs, learning_rate, momentum, batch_size, n_folds=5):
    scores, histories = list(), list()
    # prepare cross validation
    kfold = KFold(n_folds, shuffle=True, random_state=1)
    # enumerate splits
    for trainFold_ix, testFold_ix in kfold.split(trainX):
        # select rows for train and test
        trainFoldsX, trainFoldsY, testFoldX, testFoldY = trainX[trainFold_ix], trainY[trainFold_ix], trainX[testFold_ix], trainY[testFold_ix]
        # fit model
        model = define_model(learning_rate, momentum)
        history = model.fit(trainFoldsX, trainFoldsY, epochs=max_epochs, batch_size=batch_size, validation_data=(testFoldX, testFoldY), verbose=0)
        # evaluate model
        _, acc = model.evaluate(testFoldX, testFoldY, verbose=0)
        # stores scores
        scores.append(acc)
        histories.append(history)
    return scores, histories

如何设置贝叶斯优化(或随机搜索)

def selective_search(kind, space, max_evals, batch_size=32):

    trainX, trainY, testX, testY = prep_data()

    histories = list()
    hyperparameter_sets = list()
    scores = list()

    def objective(params):
        lr, momentum = params['lr'], params['momentum']
        accuracies, _ = evaluate_model_cross_validation(trainX, trainY, max_epochs=10, learning_rate=lr, momentum=momentum, batch_size=batch_size, n_folds=5)
        score = np.log10(1 - np.mean(accuracies))
        scores.append(score)
        with open('{}_scores.pickle'.format(kind), 'wb') as file:
            pickle.dump(scores, file)
        hyperparameter_sets.append({'learning_rate': lr, 'momentum': momentum, 'batch_size': batch_size})
        with open('{}_hpsets.pickle'.format(kind), 'wb') as file:
            pickle.dump(hyperparameter_sets, file)
        return score

    if kind == 'bayesian':
        tpe_best = fmin(fn=objective, space=space, algo=tpe.suggest, trials=Trials(), max_evals=max_evals)
    elif kind == 'random':
        tpe_best = fmin(fn=objective, space=space, algo=rand.suggest, trials=Trials(), max_evals=max_evals)
    else:
        raise BaseError('First parameter "kind" must be either "bayesian" or "random"')

    return histories, hyperparameter_sets, scores

然后我如何实际运行贝叶斯优化。

space = {'lr': hp.loguniform('lr', np.log(np.sqrt(10)*1e-4), np.log(1e-1)), 'momentum': 1 - hp.loguniform('momentum', np.log(np.sqrt(10)*1e-3), np.log(np.sqrt(10)*1e-1))}

histories, hyperparameter_sets, scores = selective_search(kind='bayesian', space=space, max_evals=100, batch_size=32)

Answer 1

这是我的进展更新，并在一定程度上回答了我的问题。标题是我没有运行足够的迭代。

1. 迭代得分和 2.迭代获得最佳得分

   • 正如拟合线所示，我们确实观察到了准确性提高的趋势。这可能较少，因为最小值正在改进，而更多，因为算法花费更少的时间评估超参数，而这些超参数显然不是最佳性能的候选者。

2. 迭代学习率和4.相应的箱线图和须线图

   • 我们在这里看到的一个奇怪的事情是试验超参数的收敛和发散。我的猜测是因为统计偏差产生的噪音不允许算法可靠地绘制地形。它无法确定最小值，因为每次测试一组特定的超参数时，它都会得到略有不同的答案。
   • 尽管如此，我们确实看到了一些迹象，表明该算法将其搜索空间限制在比整个范围更窄的邻域内，正如预期的那样。

3. 迭代动量和 6.相应的箱线图和须线图

   • 在这里，我们对学习率进行了类似的观察。有趣的是平均值随着学习率趋于收敛和发散的方式。请记住我之前提到过，随着动量的增加，我们需要降低学习率以保持良好的模型训练性能。因此，如果我们试图保持良好的性能，动量和学习率之间就会存在某种耦合。这就是优化算法在这里为我们演示的内容!