种子搜刮 器神器_种子搜刮 器2021（种子搜寻器）

摘要： 　　原文：How to Grid Search Hyperparameters for Deep Learning Models in Python With Keras 　　作者...

　　原文：How to Grid Search Hyperparameters for Deep Learning Models in Python With Keras

　　作者：Jason Brownlee

　　翻译：刘崇鑫

　　责编：周建丁（zhoujd@csdn.net）

　　超参数优化是深度学习中的紧张 构成 部分 。其缘故起因 在于，神经网络是公认的难以设置 ，而又有很多 参数必要 设置。最紧张 的是，个别模子 的练习 非常迟钝 。

　　在这篇文章中，你会相识 到怎样 利用 scikit-learn python呆板 学习库中的网格搜刮 功能调解 Keras深度学习模子 中的超参数。

　　阅读本文后，你就会相识 ：

　　怎样 包装Keras模子 以便在scikit-learn中利用 ，以及怎样 利用 网格搜刮 。怎样 网格搜刮 常见的神经网络参数，如学习速率、 dropout 率、epochs 和神经元数量 。怎样 计划 本身 的超参数优化实行 。

　　概述

　　本文重要 想为各人 先容 怎样 利用 scikit-learn网格搜刮 功能，并给出一套代码实例。你可以将代码复制粘贴到本身 的项目中，作为项目起始。

　　下文所涉及的议题列表：

　　如安在 scikit-learn模子 中利用 Keras。如安在 scikit-learn模子 中利用 网格搜刮 。怎样 调优批尺寸和练习 epochs。怎样 调优优化算法。怎样 调优学习率和动量因子。怎样 确定网络权值初始值。怎样 选择神经元激活函数。怎样 调优Dropout正则化。怎样 确定隐蔽 层中的神经元的数量 。

　　如安在 scikit-learn模子 中利用 Keras

　　通过用KerasClassifier或KerasRegressor类包装Keras模子 ，可将其用于scikit-learn。

　　要利用 这些包装，必须界说 一个函数，以便按次序 模式创建并返回Keras，然后当构建KerasClassifier类时，把该函数转达 给build_fn参数。

　　比方 ：

　　defcreate_model():... returnmodel model = KerasClassifier(build_fn=create_model)

　　KerasClassifier类的构建器为可以采取 默认参数，并将其被转达 给model.fit()的调用函数，比如 epochs数量 和批尺寸（batch size)。

　　比方 ：

　　defcreate_model():... returnmodel model = KerasClassifier(build_fn=create_model, nb_epoch=10)

　　KerasClassifier类的构造也可以利用 新的参数，使之可以或许 转达 给自界说 的create_model()函数。这些新的参数，也必须由利用 默认参数的 create_model() 函数的署名 界说 。

　　比方 ：

　　defcreate_model(dropout_rate=0.0):... returnmodel model = KerasClassifier(build_fn=create_model, dropout_rate=0.2)

　　您可以在Keras API文档中，相识 到更多关于scikit-learn包装器的知识。

　　如安在 scikit-learn模子 中利用 网格搜刮

　　网格搜刮 （grid search）是一项模子 超参数优化技能 。

　　在scikit-learn中，该技能 由GridSearchCV类提供。

　　当构造该类时，你必须提供超参数字典，以便用来评价param_grid参数。这是模子 参数名称和大量列值的表示 图。

　　默认环境 下，正确 度是优化的核心 ，但其他核心 可指定用于GridSearchCV构造函数的score参数。

　　默认环境 下，网格搜刮 只利用 一个线程。在GridSearchCV构造函数中，通过将 n_jobs参数设置为-1，则进程 将利用 盘算 机上的全部 内核。这取决于你的Keras后端，并大概 干扰主神经网络的练习 过程。

　　当构造并评估一个模子 中各个参数的组适时 ，GridSearchCV会起作用。利用 交错 验证评估每个单个模子 ，且默认利用 3层交错 验证，只管 通过将cv参数指定给 GridSearchCV构造函数时，有大概 将其覆盖。

　　下面是界说 一个简单 的网格搜刮 示例：

　　param_grid = dict(nb_epochs=[10,20,30])grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1)grid_result = grid.fit(X, Y)

　　一旦完成，你可以访问网格搜刮 的输出，该输出来自结果 对象，由grid.fit()返回。best_score_成员提供优化过程期间观察到的最好的评分， best_params_形貌 了已取得最佳结果 的参数的组合。

　　您可以在scikit-learn API文档中相识 更多关于GridSearchCV类的知识。

　　题目 形貌

　　如今 我们知道了怎样 利用 scikit-learn 的Keras模子 ，怎样 利用 scikit-learn 的网格搜刮 。如今 一起看看下面的例子。

　　全部 的例子都将在一个小型的标准 呆板 学习数据集上来演示，该数据集被称为Pima Indians onset of diabetes 分类数据集。该小型数据集包罗 了全部 轻易 工作的数值属性。

　　下载数据集，并把它放置在你如今 工作目次 下，定名 为：pima-indians-diabetes.csv。

　　当我们按照本文中的例子举行 ，可以或许 得到 最佳参数。由于 参数可相互影响，以是 这不是网格搜刮 的最佳方法，但出于演示目标 ，它是很好的方法。

　　留意 并行化网格搜刮

　　全部 示例的设置 为了实现并行化（n_jobs=-1）。

　　假如 表现 像下面如许 的错误：

　　INFO (theano.gof.compilelock): Waiting forexisting lock by process '55614'(I am process '55613') INFO (theano.gof.compilelock): To manually release the lock, delete ...

　　竣事 进程 ，并修改代码，以便不并行地实行 网格搜刮 ，设置n_jobs=1。

　　怎样 调优批尺寸和练习 epochs

　　在第一个简单 的例子中，当调解 网络时，我们着眼于调解 批尺寸和练习 epochs。

　　迭代梯度降落 的批尺寸巨细 是权重更新之前表现 给网络的模式数量 。它也是在网络练习 的优选法，界说 一次读取的模式数并保持在内存中。

　　练习 epochs是练习 期间整个练习 数据集表现 给网络的次数。有些网络对批尺寸巨细 敏感，如LSTM复发性神经网络和卷积神经网络。

　　在这里，我们将以20的步长，从10到100渐渐 评估差别 的微型批尺寸。

　　完备 代码如下：

　　# Use scikit-learn to grid search the batch size and epochsimportnumpy fromsklearn.grid_search importGridSearchCV fromkeras.models importSequential fromkeras.layers importDense fromkeras.wrappers.scikit_learn importKerasClassifier # Function to create model, required for KerasClassifierdefcreate_model():# create modelmodel = Sequential() model.add(Dense(12, input_dim=8, activation='relu')) model.add(Dense(1, activation='sigmoid')) # Compile modelmodel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) returnmodel # fix random seed for reproducibilityseed = 7numpy.random.seed(seed) # load datasetdataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") # split into input (X) and output (Y) variablesX = dataset[:,0:8] Y = dataset[:,8] # create modelmodel = KerasClassifier(build_fn=create_model, verbose=0) # define the grid search parametersbatch_size = [10, 20, 40, 60, 80, 100] epochs = [10, 50, 100] param_grid = dict(batch_size=batch_size, nb_epoch=epochs) grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1) grid_result = grid.fit(X, Y) # summarize resultsprint("Best: %f using %s"% (grid_result.best_score_, grid_result.best_params_)) forparams, mean_score, scores ingrid_result.grid_scores_: print("%f (%f) with: %r"% (scores.mean(), scores.std(), params))

　　运行之后输出如下：

　　Best: 0.686198using{'nb_epoch': 100, 'batch_size': 20} 0.348958(0.024774) with: {'nb_epoch': 10, 'batch_size': 10} 0.348958(0.024774) with: {'nb_epoch': 50, 'batch_size': 10} 0.466146(0.149269) with: {'nb_epoch': 100, 'batch_size': 10} 0.647135(0.021236) with: {'nb_epoch': 10, 'batch_size': 20} 0.660156(0.014616) with: {'nb_epoch': 50, 'batch_size': 20} 0.686198(0.024774) with: {'nb_epoch': 100, 'batch_size': 20} 0.489583(0.075566) with: {'nb_epoch': 10, 'batch_size': 40} 0.652344(0.019918) with: {'nb_epoch': 50, 'batch_size': 40} 0.654948(0.027866) with: {'nb_epoch': 100, 'batch_size': 40} 0.518229(0.032264) with: {'nb_epoch': 10, 'batch_size': 60} 0.605469(0.052213) with: {'nb_epoch': 50, 'batch_size': 60} 0.665365(0.004872) with: {'nb_epoch': 100, 'batch_size': 60} 0.537760(0.143537) with: {'nb_epoch': 10, 'batch_size': 80} 0.591146(0.094954) with: {'nb_epoch': 50, 'batch_size': 80} 0.658854(0.054904) with: {'nb_epoch': 100, 'batch_size': 80} 0.402344(0.107735) with: {'nb_epoch': 10, 'batch_size': 100} 0.652344(0.033299) with: {'nb_epoch': 50, 'batch_size': 100} 0.542969(0.157934) with: {'nb_epoch': 100, 'batch_size': 100}

　　我们可以看到，批尺寸为20、100 epochs可以或许 得到 最好的结果 ，正确 度约68％。

　　怎样 调优练习 优化算法

　　Keras提供了一套开始 辈 的差别 的优化算法。

　　在这个例子中，我们调解 用来练习 网络的优化算法，每个都用默认参数。

　　这个例子有点奇怪 ，由于 每每 你会先选择一种方法，而不是将重点放在调解 题目 参数上（拜见 下一个示例）。

　　在这里，我们将评估Keras API支持的整套优化算法。

　　完备 代码如下：

　　# Use scikit-learn to grid search the batch size and epochsimportnumpy fromsklearn.grid_search importGridSearchCV fromkeras.models importSequential fromkeras.layers importDense fromkeras.wrappers.scikit_learn importKerasClassifier # Function to create model, required for KerasClassifierdefcreate_model(optimizer='adam'):# create modelmodel = Sequential() model.add(Dense(12, input_dim=8, activation='relu')) model.add(Dense(1, activation='sigmoid')) # Compile modelmodel.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy']) returnmodel # fix random seed for reproducibilityseed = 7numpy.random.seed(seed) # load datasetdataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") # split into input (X) and output (Y) variablesX = dataset[:,0:8] Y = dataset[:,8] # create modelmodel = KerasClassifier(build_fn=create_model, nb_epoch=100, batch_size=10, verbose=0) # define the grid search parametersoptimizer = ['SGD', 'RMSprop', 'Adagrad', 'Adadelta', 'Adam', 'Adamax', 'Nadam'] param_grid = dict(optimizer=optimizer) grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1) grid_result = grid.fit(X, Y) # summarize resultsprint("Best: %f using %s"% (grid_result.best_score_, grid_result.best_params_)) forparams, mean_score, scores ingrid_result.grid_scores_: print("%f (%f) with: %r"% (scores.mean(), scores.std(), params))

　　运行之后输出如下：

　　Best: 0.704427using{'optimizer': 'Adam'} 0.348958(0.024774) with: {'optimizer': 'SGD'} 0.348958(0.024774) with: {'optimizer': 'RMSprop'} 0.471354(0.156586) with: {'optimizer': 'Adagrad'} 0.669271(0.029635) with: {'optimizer': 'Adadelta'} 0.704427(0.031466) with: {'optimizer': 'Adam'} 0.682292(0.016367) with: {'optimizer': 'Adamax'} 0.703125(0.003189) with: {'optimizer': 'Nadam'}

　　结果 表明，ATOM优化算法结果 最好，正确 度约为70％。

　　怎样 优化学习速率和动量因子？

　　预先选择一个优化算法来练习 你的网络和参数调解 黑白 常 常见的。如今 ，最常用的优化算法是平凡 的随机梯度降落 法（Stochastic Gradient Descent，SGD），由于 它非常 易于明白 。在本例中，我们将着眼于优化SGD的学习速率和动量因子（momentum）。

　　学习速率控制每批（batch）竣事 时更新的权重，动量因子控制前次 权重的更新对本次权重更新的影响程度 。

　　我们选取了一组较小的学习速率和动量因子的取值范围：从0.2到0.8，步长为0.2，以及0.9（实际 中常用参数值）。

　　一样平常 来说，在优化算法中包罗 epoch的数量 是一个好主意，由于 每批（batch）学习量（学习速率）、每个 epoch更新的数量 （批尺寸）和 epoch的数量 之间都具有相干 性。

　　完备 代码如下：

　　# Use scikit-learn to grid search the learning rate and momentumimportnumpy fromsklearn.grid_search importGridSearchCV fromkeras.models importSequential fromkeras.layers importDense fromkeras.wrappers.scikit_learn importKerasClassifier fromkeras.optimizers importSGD # Function to create model, required for KerasClassifierdefcreate_model(learn_rate=0.01, momentum=0):# create modelmodel = Sequential() model.add(Dense(12, input_dim=8, activation='relu')) model.add(Dense(1, activation='sigmoid')) # Compile modeloptimizer = SGD(lr=learn_rate, momentum=momentum) model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy']) returnmodel # fix random seed for reproducibilityseed = 7numpy.random.seed(seed) # load datasetdataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") # split into input (X) and output (Y) variablesX = dataset[:,0:8] Y = dataset[:,8] # create modelmodel = KerasClassifier(build_fn=create_model, nb_epoch=100, batch_size=10, verbose=0) # define the grid search parameterslearn_rate = [0.001, 0.01, 0.1, 0.2, 0.3] momentum = [0.0, 0.2, 0.4, 0.6, 0.8, 0.9] param_grid = dict(learn_rate=learn_rate, momentum=momentum) grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1) grid_result = grid.fit(X, Y) # summarize resultsprint("Best: %f using %s"% (grid_result.best_score_, grid_result.best_params_)) forparams, mean_score, scores ingrid_result.grid_scores_: print("%f (%f) with: %r"% (scores.mean(), scores.std(), params))

　　运行之后输出如下：

　　Best: 0.680990using{'learn_rate': 0.01, 'momentum': 0.0} 0.348958(0.024774) with: {'learn_rate': 0.001, 'momentum': 0.0} 0.348958(0.024774) with: {'learn_rate': 0.001, 'momentum': 0.2} 0.467448(0.151098) with: {'learn_rate': 0.001, 'momentum': 0.4} 0.662760(0.012075) with: {'learn_rate': 0.001, 'momentum': 0.6} 0.669271(0.030647) with: {'learn_rate': 0.001, 'momentum': 0.8} 0.666667(0.035564) with: {'learn_rate': 0.001, 'momentum': 0.9} 0.680990(0.024360) with: {'learn_rate': 0.01, 'momentum': 0.0} 0.677083(0.026557) with: {'learn_rate': 0.01, 'momentum': 0.2} 0.427083(0.134575) with: {'learn_rate': 0.01, 'momentum': 0.4} 0.427083(0.134575) with: {'learn_rate': 0.01, 'momentum': 0.6} 0.544271(0.146518) with: {'learn_rate': 0.01, 'momentum': 0.8} 0.651042(0.024774) with: {'learn_rate': 0.01, 'momentum': 0.9} 0.651042(0.024774) with: {'learn_rate': 0.1, 'momentum': 0.0} 0.651042(0.024774) with: {'learn_rate': 0.1, 'momentum': 0.2} 0.572917(0.134575) with: {'learn_rate': 0.1, 'momentum': 0.4} 0.572917(0.134575) with: {'learn_rate': 0.1, 'momentum': 0.6} 0.651042(0.024774) with: {'learn_rate': 0.1, 'momentum': 0.8} 0.651042(0.024774) with: {'learn_rate': 0.1, 'momentum': 0.9} 0.533854(0.149269) with: {'learn_rate': 0.2, 'momentum': 0.0} 0.427083(0.134575) with: {'learn_rate': 0.2, 'momentum': 0.2} 0.427083(0.134575) with: {'learn_rate': 0.2, 'momentum': 0.4} 0.651042(0.024774) with: {'learn_rate': 0.2, 'momentum': 0.6} 0.651042(0.024774) with: {'learn_rate': 0.2, 'momentum': 0.8} 0.651042(0.024774) with: {'learn_rate': 0.2, 'momentum': 0.9} 0.455729(0.146518) with: {'learn_rate': 0.3, 'momentum': 0.0} 0.455729(0.146518) with: {'learn_rate': 0.3, 'momentum': 0.2} 0.455729(0.146518) with: {'learn_rate': 0.3, 'momentum': 0.4} 0.348958(0.024774) with: {'learn_rate': 0.3, 'momentum': 0.6} 0.348958(0.024774) with: {'learn_rate': 0.3, 'momentum': 0.8} 0.348958(0.024774) with: {'learn_rate': 0.3, 'momentum': 0.9}

　　可以看到，SGD在该题目 上相对表现 不是很好，但当学习速率为0.01、动量因子为0.0时可取得最好的结果 ，精确 率约为68%。

　　怎样 调优网络权值初始化

　　神经网络权值初始化一度非常 简单 ：采取 小的随机数即可。

　　如今 ，有很多 差别 的技能 可供选择。点击此处查察 Keras 提供的清单。

　　在本例中，我们将着眼于通过评估全部 可用的技能 ，来调优网络权值初始化的选择。

　　我们将在每一层采取 雷同 的权值初始化方法。抱负 环境 下，根据每层利用 的激活函数选用差别 的权值初始化方法结果 大概 更好。在下面的例子中，我们在隐蔽 层利用 了整流器（rectifier）。由于 猜测 是二进制，因此在输出层利用 了sigmoid函数。

　　完备 代码如下：

　　# Use scikit-learn to grid search the weight initializationimportnumpy fromsklearn.grid_search importGridSearchCV fromkeras.models importSequential fromkeras.layers importDense fromkeras.wrappers.scikit_learn importKerasClassifier # Function to create model, required for KerasClassifierdefcreate_model(init_mode='uniform'):# create modelmodel = Sequential() model.add(Dense(12, input_dim=8, init=init_mode, activation='relu')) model.add(Dense(1, init=init_mode, activation='sigmoid')) # Compile modelmodel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) returnmodel # fix random seed for reproducibilityseed = 7numpy.random.seed(seed) # load datasetdataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") # split into input (X) and output (Y) variablesX = dataset[:,0:8] Y = dataset[:,8] # create modelmodel = KerasClassifier(build_fn=create_model, nb_epoch=100, batch_size=10, verbose=0) # define the grid search parametersinit_mode = ['uniform', 'lecun_uniform', 'normal', 'zero', 'glorot_normal', 'glorot_uniform', 'he_normal', 'he_uniform'] param_grid = dict(init_mode=init_mode) grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1) grid_result = grid.fit(X, Y) # summarize resultsprint("Best: %f using %s"% (grid_result.best_score_, grid_result.best_params_)) forparams, mean_score, scores ingrid_result.grid_scores_: print("%f (%f) with: %r"% (scores.mean(), scores.std(), params))

　　运行之后输出如下：

　　Best: 0.720052using{'init_mode': 'uniform'} 0.720052(0.024360) with: {'init_mode': 'uniform'} 0.348958(0.024774) with: {'init_mode': 'lecun_uniform'} 0.712240(0.012075) with: {'init_mode': 'normal'} 0.651042(0.024774) with: {'init_mode': 'zero'} 0.700521(0.010253) with: {'init_mode': 'glorot_normal'} 0.674479(0.011201) with: {'init_mode': 'glorot_uniform'} 0.661458(0.028940) with: {'init_mode': 'he_normal'} 0.678385(0.004872) with: {'init_mode': 'he_uniform'}

　　我们可以看到，当采取 匀称 权值初始化方案（uniform weight initialization ）时取得最好的结果 ，可以实现约72%的性能。

　　怎样 选择神经元激活函数

　　激活函数控制着单个神经元的非线性以及何时激活。

　　通常来说，整流器（rectifier）的激活功能是最受欢迎 的，但应对差别 的题目 ， sigmoid函数和tanh 函数大概 是更好的选择。

　　在本例中，我们将探究 、评估、比力 Keras提供的差别 范例 的激活函数。我们仅在隐层中利用 这些函数。思量 到二元分类题目 ，必要 在输出层利用 sigmoid激活函数。

　　通常而言，为差别 范围的转达 函数预备 数据是一个好主意，但在本例中我们不会这么做。

　　完备 代码如下：

　　# Use scikit-learn to grid search the activation functionimportnumpy fromsklearn.grid_search importGridSearchCV fromkeras.models importSequential fromkeras.layers importDense fromkeras.wrappers.scikit_learn importKerasClassifier # Function to create model, required for KerasClassifierdefcreate_model(activation='relu'):# create modelmodel = Sequential() model.add(Dense(12, input_dim=8, init='uniform', activation=activation)) model.add(Dense(1, init='uniform', activation='sigmoid')) # Compile modelmodel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) returnmodel # fix random seed for reproducibilityseed = 7numpy.random.seed(seed) # load datasetdataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") # split into input (X) and output (Y) variablesX = dataset[:,0:8] Y = dataset[:,8] # create modelmodel = KerasClassifier(build_fn=create_model, nb_epoch=100, batch_size=10, verbose=0) # define the grid search parametersactivation = ['softmax', 'softplus', 'softsign', 'relu', 'tanh', 'sigmoid', 'hard_sigmoid', 'linear'] param_grid = dict(activation=activation) grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1) grid_result = grid.fit(X, Y) # summarize resultsprint("Best: %f using %s"% (grid_result.best_score_, grid_result.best_params_)) forparams, mean_score, scores ingrid_result.grid_scores_: print("%f (%f) with: %r"% (scores.mean(), scores.std(), params))

　　运行之后输出如下：

　　Best: 0.722656using{'activation': 'linear'} 0.649740(0.009744) with: {'activation': 'softmax'} 0.720052(0.032106) with: {'activation': 'softplus'} 0.688802(0.019225) with: {'activation': 'softsign'} 0.720052(0.018136) with: {'activation': 'relu'} 0.691406(0.019401) with: {'activation': 'tanh'} 0.680990(0.009207) with: {'activation': 'sigmoid'} 0.691406(0.014616) with: {'activation': 'hard_sigmoid'} 0.722656(0.003189) with: {'activation': 'linear'}

　　令人惊奇 的是（至少对我来说是），“线性（linear）”激活函数取得了最好的结果 ，正确 率约为72%。

　　怎样 调优Dropout正则化

　　在本例中，我们将着眼于调解 正则化中的dropout速率，以限期 制过拟合（overfitting）和进步 模子 的泛化本领 。为了得到较好的结果 ，dropout最好连合 一个如最大范数束缚 之类的权值束缚 。

　　相识 更多dropout在深度学习框架Keras的利用 请查察 下面这篇文章：

　　基于Keras/Python的深度学习模子 Dropout正则项

　　它涉及到拟合dropout率和权值束缚 。我们选定dropout percentages取值范围是：0.0-0.9（1.0偶然 义）；最大范数权值束缚 （ maxnorm weight constraint）的取值范围是0-5。

　　完备 代码如下：

　　# Use scikit-learn to grid search the dropout rateimportnumpy fromsklearn.grid_search importGridSearchCV fromkeras.models importSequential fromkeras.layers importDense fromkeras.layers importDropout fromkeras.wrappers.scikit_learn importKerasClassifier fromkeras.constraints importmaxnorm # Function to create model, required for KerasClassifierdefcreate_model(dropout_rate=0.0, weight_constraint=0):# create modelmodel = Sequential() model.add(Dense(12, input_dim=8, init='uniform', activation='linear', W_constraint=maxnorm(weight_constraint))) model.add(Dropout(dropout_rate)) model.add(Dense(1, init='uniform', activation='sigmoid')) # Compile modelmodel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) returnmodel # fix random seed for reproducibilityseed = 7numpy.random.seed(seed) # load datasetdataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") # split into input (X) and output (Y) variablesX = dataset[:,0:8] Y = dataset[:,8] # create modelmodel = KerasClassifier(build_fn=create_model, nb_epoch=100, batch_size=10, verbose=0) # define the grid search parametersweight_constraint = [1, 2, 3, 4, 5] dropout_rate = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] param_grid = dict(dropout_rate=dropout_rate, weight_constraint=weight_constraint) grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1) grid_result = grid.fit(X, Y) # summarize resultsprint("Best: %f using %s"% (grid_result.best_score_, grid_result.best_params_)) forparams, mean_score, scores ingrid_result.grid_scores_: print("%f (%f) with: %r"% (scores.mean(), scores.std(), params))

　　运行之后输出如下：

　　Best: 0.723958using{'dropout_rate': 0.2, 'weight_constraint': 4} 0.696615(0.031948) with: {'dropout_rate': 0.0, 'weight_constraint': 1} 0.696615(0.031948) with: {'dropout_rate': 0.0, 'weight_constraint': 2} 0.691406(0.026107) with: {'dropout_rate': 0.0, 'weight_constraint': 3} 0.708333(0.009744) with: {'dropout_rate': 0.0, 'weight_constraint': 4} 0.708333(0.009744) with: {'dropout_rate': 0.0, 'weight_constraint': 5} 0.710937(0.008438) with: {'dropout_rate': 0.1, 'weight_constraint': 1} 0.709635(0.007366) with: {'dropout_rate': 0.1, 'weight_constraint': 2} 0.709635(0.007366) with: {'dropout_rate': 0.1, 'weight_constraint': 3} 0.695312(0.012758) with: {'dropout_rate': 0.1, 'weight_constraint': 4} 0.695312(0.012758) with: {'dropout_rate': 0.1, 'weight_constraint': 5} 0.701823(0.017566) with: {'dropout_rate': 0.2, 'weight_constraint': 1} 0.710938(0.009568) with: {'dropout_rate': 0.2, 'weight_constraint': 2} 0.710938(0.009568) with: {'dropout_rate': 0.2, 'weight_constraint': 3} 0.723958(0.027126) with: {'dropout_rate': 0.2, 'weight_constraint': 4} 0.718750(0.030425) with: {'dropout_rate': 0.2, 'weight_constraint': 5} 0.721354(0.032734) with: {'dropout_rate': 0.3, 'weight_constraint': 1} 0.707031(0.036782) with: {'dropout_rate': 0.3, 'weight_constraint': 2} 0.707031(0.036782) with: {'dropout_rate': 0.3, 'weight_constraint': 3} 0.694010(0.019225) with: {'dropout_rate': 0.3, 'weight_constraint': 4} 0.709635(0.006639) with: {'dropout_rate': 0.3, 'weight_constraint': 5} 0.704427(0.008027) with: {'dropout_rate': 0.4, 'weight_constraint': 1} 0.717448(0.031304) with: {'dropout_rate': 0.4, 'weight_constraint': 2} 0.718750(0.030425) with: {'dropout_rate': 0.4, 'weight_constraint': 3} 0.718750(0.030425) with: {'dropout_rate': 0.4, 'weight_constraint': 4} 0.722656(0.029232) with: {'dropout_rate': 0.4, 'weight_constraint': 5} 0.720052(0.028940) with: {'dropout_rate': 0.5, 'weight_constraint': 1} 0.703125(0.009568) with: {'dropout_rate': 0.5, 'weight_constraint': 2} 0.716146(0.029635) with: {'dropout_rate': 0.5, 'weight_constraint': 3} 0.709635(0.008027) with: {'dropout_rate': 0.5, 'weight_constraint': 4} 0.703125(0.011500) with: {'dropout_rate': 0.5, 'weight_constraint': 5} 0.707031(0.017758) with: {'dropout_rate': 0.6, 'weight_constraint': 1} 0.701823(0.018688) with: {'dropout_rate': 0.6, 'weight_constraint': 2} 0.701823(0.018688) with: {'dropout_rate': 0.6, 'weight_constraint': 3} 0.690104(0.027498) with: {'dropout_rate': 0.6, 'weight_constraint': 4} 0.695313(0.022326) with: {'dropout_rate': 0.6, 'weight_constraint': 5} 0.697917(0.014382) with: {'dropout_rate': 0.7, 'weight_constraint': 1} 0.697917(0.014382) with: {'dropout_rate': 0.7, 'weight_constraint': 2} 0.687500(0.008438) with: {'dropout_rate': 0.7, 'weight_constraint': 3} 0.704427(0.011201) with: {'dropout_rate': 0.7, 'weight_constraint': 4} 0.696615(0.016367) with: {'dropout_rate': 0.7, 'weight_constraint': 5} 0.680990(0.025780) with: {'dropout_rate': 0.8, 'weight_constraint': 1} 0.699219(0.019401) with: {'dropout_rate': 0.8, 'weight_constraint': 2} 0.701823(0.015733) with: {'dropout_rate': 0.8, 'weight_constraint': 3} 0.684896(0.023510) with: {'dropout_rate': 0.8, 'weight_constraint': 4} 0.696615(0.017566) with: {'dropout_rate': 0.8, 'weight_constraint': 5} 0.653646(0.034104) with: {'dropout_rate': 0.9, 'weight_constraint': 1} 0.677083(0.012075) with: {'dropout_rate': 0.9, 'weight_constraint': 2} 0.679688(0.013902) with: {'dropout_rate': 0.9, 'weight_constraint': 3} 0.669271(0.017566) with: {'dropout_rate': 0.9, 'weight_constraint': 4} 0.669271(0.012075) with: {'dropout_rate': 0.9, 'weight_constraint': 5}

　　我们可以看到，当 dropout率为0.2%、最大范数权值束缚 （ maxnorm weight constraint）取值为4时，可以取得正确 率约为72%的最好结果 。

　　怎样 确定隐蔽 层中的神经元的数量

　　每一层中的神经元数量 是一个非常紧张 的参数。通常环境 下，一层之中的神经元数量 控制着网络的代表性容量，至少是拓扑布局 某一节点的容量。

　　别的 ，一样平常 来说，一个充足 大的单层网络是靠近 于任何神经网络的，至少在理论上创建 。

　　在本例中，我们将着眼于调解 单个隐蔽 层神经元的数量 。取值范围是：1—30，步长为5。

　　一个大型网络要求更多的练习 ，别的 ，至少批尺寸（batch size）和 epoch的数量 应该与神经元的数量 优化。

　　完备 代码如下：

　　# Use scikit-learn to grid search the number of neuronsimportnumpy fromsklearn.grid_search importGridSearchCV fromkeras.models importSequential fromkeras.layers importDense fromkeras.layers importDropout fromkeras.wrappers.scikit_learn importKerasClassifier fromkeras.constraints importmaxnorm # Function to create model, required for KerasClassifierdefcreate_model(neurons=1):# create modelmodel = Sequential() model.add(Dense(neurons, input_dim=8, init='uniform', activation='linear', W_constraint=maxnorm(4))) model.add(Dropout(0.2)) model.add(Dense(1, init='uniform', activation='sigmoid')) # Compile modelmodel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) returnmodel # fix random seed for reproducibilityseed = 7numpy.random.seed(seed) # load datasetdataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") # split into input (X) and output (Y) variablesX = dataset[:,0:8] Y = dataset[:,8] # create modelmodel = KerasClassifier(build_fn=create_model, nb_epoch=100, batch_size=10, verbose=0) # define the grid search parametersneurons = [1, 5, 10, 15, 20, 25, 30] param_grid = dict(neurons=neurons) grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1) grid_result = grid.fit(X, Y) # summarize resultsprint("Best: %f using %s"% (grid_result.best_score_, grid_result.best_params_)) forparams, mean_score, scores ingrid_result.grid_scores_: print("%f (%f) with: %r"% (scores.mean(), scores.std(), params))

　　运行之后输出如下：

　　Best: 0.714844using{'neurons': 5} 0.700521(0.011201) with: {'neurons': 1} 0.714844(0.011049) with: {'neurons': 5} 0.712240(0.017566) with: {'neurons': 10} 0.705729(0.003683) with: {'neurons': 15} 0.696615(0.020752) with: {'neurons': 20} 0.713542(0.025976) with: {'neurons': 25} 0.705729(0.008027) with: {'neurons': 30}

　　我们可以看到，当网络中隐蔽 层内神经元的个数为5时，可以到达 最佳结果 ，正确 性约为71%。

　　超参数优化的小本领

　　本节摆列 了一些神经网络超参数调解 时常用的小本领 。

　　K层交错 查验 （k-fold Cross Validation），你可以看到，本文中的差别 示例的结果 存在一些差别 。利用 了默认的3层交错 验证，但大概 K=5大概 K=10时会更加稳固 。认真选择您的交错 验证设置 ，以确保您的结果 是稳固 的。 检察 整个网络。不要只留意 最好的结果 ，检察 整个网络的结果 ，并探求 支持设置 决定 的趋势。 并行（Parallelize），假如 可以，利用 全部的CPU，神经网络练习 非常 迟钝 ，而且 我们常常 想实行 差别 的参数。参考AWS实例。 利用 数据集的样本。由于神经网路的练习 非常 迟钝 ，实行 练习 在您练习 数据会合 较小样本，得到总方向的一样平常 参数即可，并非寻求 最佳的设置 。 从粗网格入手。从粗粒度网格入手，而且 一旦缩小范围，就细化为细粒度网格。 不要转达 结果 。结果 通常是特定题目 。只管 克制 在每一个新题目 上都采取 您最喜好 的设置 。你不大概 将一个题目 的最佳结果 转移到另一个题目 之上。相反地，你应该归纳更广泛的趋势，比方 层的数量 大概 是参数之间的关系。 再现性（Reproducibility）是一个题目 。在NumPy中，只管 我们为随机数发生器设置了种子，但结果 并非百分百重现。网格搜刮 wrapped Keras模子 将比本文中所示Keras模子 显现 更多可重复性（reproducibility）。

　　总结

　　在这篇文章中，你可以相识 到怎样 利用 Keras和scikit-learn/Python调优神经网络中的超参数。

　　尤其是可以学到：

　　怎样 包装Keras模子 以便在scikit-learn利用 以及怎样 利用 网格搜刮 。怎样 网格搜刮 Keras 模子 中差别 标准 的神经网络参数。怎样 计划 本身 的超参数优化实行 。

　　您有过大型神经网络超参数调优的履历 吗？假如 有，请投稿至zhoujd@csdn.net分享您的故事和履历 。

　　CCAI 2016中国人工智能大会将于8月26-27日在京举行，AAAI主席，国表里 浩繁 院士，MIT、微软、大疆、百度、微信、滴滴专家领衔环球 技能 首脑 和财产 前锋 打造国内人工智能前沿平台，8个重磅主题陈诉 ，4大专题论坛，1000+高质量参会高朋 ，探究 人机交互、呆板 学习、模式辨认 及财产 实战。 大会门票已经剩余不多，与大牛对话，灵敏 抢票！