# 如何使用 Python 和 Keras 网格搜索深度学习模型的超参数

> 原文： [https://machinelearningmastery.com/grid-search-hyperparameters-deep-learning-models-python-keras/](https://machinelearningmastery.com/grid-search-hyperparameters-deep-learning-models-python-keras/)

超参数优化是深度学习的重要组成部分。

众所周知的原因之一是神经网络很难配置，并且要设置很多参数，最重要的是，单个模型的训练速度可能非常慢。

在这篇文章中，您将了解如何使用 scikit-learn python 机器学习库中的网格搜索功能来调整 Keras 深度学习模型的超参数。

阅读这篇文章后你会知道：

*   如何封装 Keras 模型用于 scikit-learn 以及如何使用网格搜索。
*   如何网格搜索常见的神经网络参数，如学习率，dropout率，迭代次数和神经元数量。
*   如何在自己的项目中定义自己的超参数调整实验。

让我们开始吧！

*   **2016 年 11 月更新**：修复了在代码示例中显示网格搜索结果的小问题。
*   **2016 年 10 月更新**：更新了 Keras 1.1.0，TensorFlow 0.10.0 和 scikit-learn v0.18 的示例。
*   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
*   **2017 年 9 月更新**：更新了使用 Keras 2“epochs”代替 Keras 1“nb_epochs”的示例。
*   **更新 March / 2018** ：添加了备用链接以下载数据集，因为原始图像已被删除。

![How to Grid Search Hyperparameters for Deep Learning Models in Python With Keras](img/4ae90ba8e51222dd47048dad32a96128.png)


照片由 [3V Photo](https://www.flickr.com/photos/107439982@N02/10635372184/)提供 ，并保留所属权利。

## 概述

在这篇文章中，我想向您展示如何使用 scikit-learn 网格搜索功能，并为您提供一组示例，您可以将这些示例复制并粘贴到您自己的项目中作为学习的起点。

以下是我们将要讨论的主题列表：

1.  如何在 scikit-learn 中使用 Keras 模型。
2.  如何在 scikit-learn 中使用网格搜索。
3.  如何调整批量大小和训练迭代次数。
4.  如何调整优化算法。
5.  如何调整学习率和冲量单元。
6.  如何调整网络权重参数初始化。
7.  如何调整激活函数。
8.  如何调节dropout正则化。
9.  如何调整隐藏层中的神经元数量。

## 如何在 scikit-learn 中使用 Keras 模型

Keras 模型可以通过 **KerasClassifier** 或 **KerasRegressor** 类封装来使用 scikit-learn。

要使用这些封装器，您必须定义一个创建并返回 Keras 顺序模型的函数，然后在构造 **KerasClassifier** 类时将此函数传递给 **build_fn** 参数。

例如：

```py
def create_model():
	...
	return model

model = KerasClassifier(build_fn=create_model)
```

**KerasClassifier** 类的构造函数可以使用传递给 `model.fit()`的调用的默认参数，例如迭代数和批量大小。

例如：

```py
def create_model():
	...
	return model

model = KerasClassifier(build_fn=create_model, epochs=10)
```

**KerasClassifier** 类的构造函数也可以采用传递给自定义 `create_model()`函数的新参数。这些新参数也必须在 `create_model()`函数的签名中使用默认参数进行定义。

例如：

```py
def create_model(dropout_rate=0.0):
	...
	return model

model = KerasClassifier(build_fn=create_model, dropout_rate=0.2)
```

您可以在 Keras API 文档中了解有关 [scikit-learn 封装器的更多信息。](http://keras.io/scikit-learn-api/)

## 如何在 scikit-learn 中使用网格搜索

网格搜索是一种模型超参数优化技术。

在 scikit-learn 中，这种技术由 **GridSearchCV** 类提供。

构造此类时，必须提供一个超参数字典，以便在 **param_grid** 参数中进行评估，这是模型参数名称和要尝试的值所组成数组的一种映射。

默认情况下，精度是需要优化的分数，但其他评分标准也可以在 **GridSearchCV** 构造函数的**分数**参数中指定。

默认情况下，网格搜索仅使用一个线程，通过将 **GridSearchCV** 构造函数中的 **n_jobs** 参数设置为-1，该进程将使用计算机上的所有计算资源，根据您的 Keras 后端，这种方法可能会干扰主要的神经网络训练过程。

然后，**GridSearchCV**流程将为每种参数组合构建和评估一个模型。 尽管可以通过为**GridSearchCV**构造函数指定cv参数来覆盖交叉验证，但是交叉验证用于评估每个单独的模型，并且使用默认的三折交叉验证。

下面是定义简单网格搜索的示例：

```py
param_grid = dict(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 类的更多信息。](http://scikit-learn.org/stable/modules/generated/sklearn.grid_search.GridSearchCV.html#sklearn.grid_search.GridSearchCV)

## 问题描述

既然我们知道如何使用 scras 模型学习 keras 模型以及如何在 scikit-learn 中使用网格搜索，那么让我们看看一堆例子。

所有例子都将在一个名为 [Pima Indians 糖尿病分类数据集](http://archive.ics.uci.edu/ml/datasets/Pima+Indians+Diabetes)的小型标准机器学习数据集上进行演示。这是一个包含所有数字属性的小型数据集，易于使用。

1.  [下载数据集](http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data)并将其直接放入您当前正在使用的名称 **pima-indians-diabetes.csv** （更新：[从这里下载](https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv)）。

在我们继续本文中的示例时，我们将汇总最佳参数。这不是网格搜索的最佳方式，因为参数可以交互，但它有利于演示目的。

### 并行化网格搜索的注意事项

所有示例都配置为使用并行性（ **n_jobs = -1** ）.

如果您收到如下错误：

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

终止进程并更改代码以不并行执行网格搜索，设置 **n_jobs = 1** 。

## 如何调整批量大小和迭代次数

在第一个简单的例子中，我们考虑调整批大小和网络拟合时的迭代次数。

[迭代梯度下降](https://en.wikipedia.org/wiki/Stochastic_gradient_descent#Iterative_method)中的批大小是在更新权重之前向网络显示的模式数，它也是网络训练的优化，定义了一次读取多少个模式并保留在内存中。

迭代次数是训练期间整个训练数据集显示给网络的次数，一些网络对批量大小敏感，例如 LSTM 递归神经网络和卷积神经网络。

在这里，我们将评估一套不同的迷你批量大小，从 10 到 100，并且将其步长设为 20。

完整的代码清单如下。

```py
# 使用sklearn网格化搜索批大小和迭代次数
import numpy
from sklearn.model_selection import GridSearchCV
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasClassifier
# KerasClassifier所需的创建模型的函数
def create_model():
	# 创建模型
	model = Sequential()
	model.add(Dense(12, input_dim=8, activation='relu'))
	model.add(Dense(1, activation='sigmoid'))
	# 编译模型
	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
	return model
# 固定随机种子再现性
seed = 7
numpy.random.seed(seed)
# 加载数据集
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
# 创建模型
model = KerasClassifier(build_fn=create_model, verbose=0)
# 定义为网络搜索模式
batch_size = [10, 20, 40, 60, 80, 100]
epochs = [10, 50, 100]
param_grid = dict(batch_size=batch_size, epochs=epochs)
grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1)
grid_result = grid.fit(X, Y)
# 结果汇总
print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) with: %r" % (mean, stdev, param))
```

运行此示例将生成以下输出：

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

我们可以看到批大小为20，迭代次数为100时达到了 68％准确度的最佳结果。

## 如何调整训练优化算法

Keras 提供一套不同的最先进的优化算法。

在此示例中，我们调整用于训练网络的优化算法，每个算法都使用默认参数。

这是一个奇怪的例子，因为通常您会先选择一种方法，而不是专注于调整问题的参数（例如，参见下一个例子）。

在这里，我们将评估 Keras API 支持的[优化算法套件。](http://keras.io/optimizers/)

完整的代码清单如下。

```py
# 使用sklearn网格化搜索批大小和迭代次数
import numpy
from sklearn.model_selection import GridSearchCV
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasClassifier
#  KerasClassifier类所需要的创建模型的函数
def create_model(optimizer='adam'):
	# 创建模型
	model = Sequential()
	model.add(Dense(12, input_dim=8, activation='relu'))
	model.add(Dense(1, activation='sigmoid'))
	# Compile model
	model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
	return model
# 固定随机种子再现性
seed = 7
numpy.random.seed(seed)
# 加载数据集
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# 将数据集分割为输入变量和输出变量
X = dataset[:,0:8]
Y = dataset[:,8]
# 创建模型
model = KerasClassifier(build_fn=create_model, epochs=100, batch_size=10, verbose=0)
# 定义为网格化搜索参数
optimizer = ['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)
# 汇总结果
print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) with: %r" % (mean, stdev, param))
```

运行此示例将生成以下输出。

```py
Best: 0.704427 using {'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'}
```

结果表明 ADAM 优化算法是最好的，准确度大约为 70％。

## 如何调整学习率和冲量单元

通常会预先选择优化算法来训练您的网络并调整其参数。

到目前为止，最常见的优化算法是普通的老式[随机梯度下降](http://keras.io/optimizers/#sgd)（SGD），因为它非常清晰。在这个例子中，我们将研究优化 SGD 学习率和冲量单元。

学习率控制在每次迭代结束时更新权重的程度，并且冲量单元控制允许上一个更新影响当前权重更新的量。

我们将尝试一套小的标准学习率和 0.2 到 0.8 的冲量单元，步长为 0.2，以及 0.9（因为它在实践中可能是一个受欢迎的值）。

通常，在这样的优化中也包括迭代次数是个好主意，因为每个迭代学习量（学习率），每次迭代的更新数量（批量大小）和迭代次数存在依赖关系。

完整的代码清单如下。

```py
# 使用sklearn网格化搜索学习率和冲量单元
import numpy
from sklearn.model_selection import GridSearchCV
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasClassifier
from keras.optimizers import SGD
#KerasClassifier类所需要的创建模型的函数
def create_model(learn_rate=0.01, momentum=0):
	# 创建模型
	model = Sequential()
	model.add(Dense(12, input_dim=8, activation='relu'))
	model.add(Dense(1, activation='sigmoid'))
	# 编译模型
	optimizer = SGD(lr=learn_rate, momentum=momentum)
	model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
	return model
# 固定随机种子再现性
seed = 7
numpy.random.seed(seed)
# load dataset
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# 将数据划分为输入变量和输出变量
X = dataset[:,0:8]
Y = dataset[:,8]
# 创建模型
model = KerasClassifier(build_fn=create_model, epochs=100, batch_size=10, verbose=0)
# 定义网格化搜索参数
learn_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)
# 结果汇总
print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) with: %r" % (mean, stdev, param))
```

运行此示例将生成以下输出。

```py
Best: 0.680990 using {'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 提供清单](http://keras.io/initializations/)。

在此示例中，我们将通过评估所有可用技术来调整网络权重初始化的选择。

我们将在每一层使用相同的权重初始化方法，理想情况下，根据每层使用的激活函数，使用不同的权重初始化方案可能更好，在下面的示例中，因为是二分类预测，我们使用线性修正单元作为隐藏层，并且我们使用 sigmoid 作为输出层。

完整的代码清单如下。

```py
# 使用sklearn网格化搜索权重参数初始化
import numpy
from sklearn.model_selection import GridSearchCV
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasClassifier
#  KerasClassifier需要的创建模型的函数
def create_model(init_mode='uniform'):
	# 创建模型
	model = Sequential()
	model.add(Dense(12, input_dim=8, kernel_initializer=init_mode, activation='relu'))
	model.add(Dense(1, kernel_initializer=init_mode, activation='sigmoid'))
	# 编译模型
	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
	return model
# 固定随机种子再现性
seed = 7
numpy.random.seed(seed)
# 加载数据集
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# 将输入化为·输入变量X和输出变量y
X = dataset[:,0:8]
Y = dataset[:,8]
# 创建模型
model = KerasClassifier(build_fn=create_model, epochs=100, batch_size=10, verbose=0)
#定义网格化搜索的参数
init_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)
# 汇总结果
print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) with: %r" % (mean, stdev, param))
```

运行此示例将生成以下输出。

```py
Best: 0.720052 using {'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'}
```

我们可以看到，使用均匀权重初始化方案实现了最佳结果，能够达到大概72%的表现。

## 如何调整神经元激活函数

激活功能控制各个神经元的非线性以及何时触发。

通常，线性修正激活函数是最流行的，过去则是 sigmoid 和 tanh 函数，这些函数可能仍然更适合于不同的问题。

在这个例子中，我们将评估 Keras 中可用的[不同激活函数套件。我们将仅在隐藏层中使用这些函数，因为我们在输出中需要 sigmoid 激活函数以用于二分类问题。](http://keras.io/activations/)

通常，将数据准备到不同传递函数的范围是一个好主意，在这种情况下我们不需要这样做。

完整的代码清单如下。

```py
# 使用sklearn网格化搜索激活函数
import numpy
from sklearn.model_selection import GridSearchCV
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasClassifier
#  KerasClassifier所需要的创建模型函数
def create_model(activation='relu'):
	# 创建模型
	model = Sequential()
	model.add(Dense(12, input_dim=8, kernel_initializer='uniform', activation=activation))
	model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
	# 编译模型
	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
	return model
# 固定随机种子再现性
seed = 7
numpy.random.seed(seed)
# 加载数据集
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
# 创建模型
model = KerasClassifier(build_fn=create_model, epochs=100, batch_size=10, verbose=0)
# 定义网格化搜索参数
activation = ['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)
# 结果汇总
print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) with: %r" % (mean, stdev, param))
```

运行此示例将生成以下输出。

```py
Best: 0.722656 using {'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'}
```

令人惊讶的是（至少对我而言），“线性”激活功能获得了最佳结果，精确度约为 72％。

## 如何调整dropout正则化

在这个例子中，我们将研究调整正则化的dropout率，以限制过拟合并提高模型的推广能力。

为了获得良好的结果，dropout最好与权重约束相结合，例如最大范数约束。

有关在 Keras 深度学习模型中使用 dropout 的更多信息，请参阅帖子：

*   [具有 Keras 的深度学习模型中的丢失正则化](http://machinelearningmastery.com/dropout-regularization-deep-learning-models-keras/)

这涉及拟合dropout率和权重约束，们将尝试 0.0 到 0.9 之间的dropout失百分比（1.0 没有意义）和 0 到 5 之间的 maxnorm 权重约束值。

完整的代码清单如下。

```py
#使用sklearn网格化搜索dropout率
import numpy
from sklearn.model_selection import GridSearchCV
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.wrappers.scikit_learn import KerasClassifier
from keras.constraints import maxnorm
# KerasClassifier需要的创建模型的函数
def create_model(dropout_rate=0.0, weight_constraint=0):
	# 创建模型
	model = Sequential()
	model.add(Dense(12, input_dim=8, kernel_initializer='uniform', activation='linear', kernel_constraint=maxnorm(weight_constraint)))
	model.add(Dropout(dropout_rate))
	model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
	# 编译模型
	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
	return model
# 固定随机种子再现性
seed = 7
numpy.random.seed(seed)
# 加载数据集
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
# 创建模型
model = KerasClassifier(build_fn=create_model, epochs=100, batch_size=10, verbose=0)
# 定义网格化搜索参数
weight_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)
# 结果汇总
print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) with: %r" % (mean, stdev, param))
```

运行此示例将生成以下输出。

```py
Best: 0.723958 using {'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}
```

我们可以看到，20％的dropout率和 4 的最大权重约束能够达到最佳精确度约为 72％。

## 如何调整隐藏层中的神经元数量

层中神经元的数量是调整的重要参数。通常，层中的神经元的数量控制网络的表示能力，至少在拓扑中的那个点处。

此外，通常，足够大的单层网络可以近似于任何其他神经网络，[至少在理论上](https://en.wikipedia.org/wiki/Universal_approximation_theorem)。

在这个例子中，我们将研究调整单个隐藏层中的神经元数量，我们将以 5 的步长尝试 1 到 30 的值。

较大的网络需要更多的训练，并且至少批大小和迭代次数应理想地用神经元的数量来优化。

完整的代码清单如下。

```py
# 使用sklearn网格化搜索神经元数量
import numpy
from sklearn.model_selection import GridSearchCV
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.wrappers.scikit_learn import KerasClassifier
from keras.constraints import maxnorm
# KerasClassifier所需要的创建模型的函数
def create_model(neurons=1):
	# 创建模型
	model = Sequential()
	model.add(Dense(neurons, input_dim=8, kernel_initializer='uniform', activation='linear', kernel_constraint=maxnorm(4)))
	model.add(Dropout(0.2))
	model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
	# 编译模型
	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
	return model
# 固定随机种子再现性
seed = 7
numpy.random.seed(seed)
# 加载数据集
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
#将数据集划分为输入变量X和输出变量y
X = dataset[:,0:8]
Y = dataset[:,8]
# 创建模型
model = KerasClassifier(build_fn=create_model, epochs=100, batch_size=10, verbose=0)
# 定义网格化搜索的参数
neurons = [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)
# 结果汇总
print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) with: %r" % (mean, stdev, param))
```

运行此示例将生成以下输出。

```py
Best: 0.714844 using {'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 折交叉验证**：您可以看到本文中示例的结果显示出一些差异，使用默认的3折交叉验证，但是 k = 5 或 k = 10 可能更稳定，请仔细选择交叉验证配置以确保结果稳定。
*   **回顾整个网格**：不要只关注最佳结果，检查整个结果网格并寻找支持配置决策的趋势。
*   **并行化**：如果可以的话，使用你所有的核心，神经网络训练很慢，我们经常想尝试很多不同的参数，考虑搞砸很多 [AWS 实例](http://machinelearningmastery.com/develop-evaluate-large-deep-learning-models-keras-amazon-web-services/)。
*   **使用数据集样本**：因为网络训练很慢，所以尝试在训练数据集的较小样本上训练它们，只是为了了解参数的一般方向而不是最佳配置。
*   **从粗网格开始**：从粗粒度网格开始，一旦缩小范围，就可以缩放到更细粒度的网格。
*   **不转移结果**:结果通常是特定于问题的。尝试在您看到的每个新问题上避免喜欢的配置。您在一个问题上发现的最佳结果不太可能转移到您的下一个项目，而是寻找更广泛的趋势，例如层数或参数之间的关系。
*   **再现性是一个问题**:虽然我们在 NumPy 中为随机数生成器设置种子，但结果不是 100％可重复的,当网格搜索包装 Keras 模型时，重复性要高于本文中提供的内容。

## 摘要

在这篇文章中，您了解了如何使用 Keras 和 scikit-learn 在 Python 中调整深度学习网络的超参数。

具体来说，你学到了：

*   如何包装 Keras 模型用于 scikit-learn 以及如何使用网格搜索
*   如何为 Keras 模型网格搜索一套不同的标准神经网络参数
*   如何设计自己的超参数优化实验

你有调整大型神经网络超参数的经验吗？请在下面分享您的故事。

您对神经网络的超参数优化还是关于这篇文章有什么疑问？在评论中提出您的问题，我会尽力回答。