如何使用 Keras 在 Python 中網格搜索深度學習模型的超參數 · Machine Learning Mastery 博客文章翻譯

# 如何使用 Keras 在 Python 中網格搜索深度學習模型的超參數 > 原文： [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](https://img.kancloud.cn/75/57/755758e281040efcee1bb1ebdc9a10b9_640x359.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 模型網格搜索一套不同的標準神經網絡參數 * 如何設計自己的超參數優化實驗你有調整大型神經網絡超參數的經驗嗎？請在下面分享您的故事。您對神經網絡的超參數優化還是關于這篇文章有什么疑問？在評論中提出您的問題，我會盡力回答。