神經(jīng)網(wǎng)絡(luò)在通信行業(yè)和研究中的使用十分常見，但令人遺憾的是，大部分應(yīng)用都未能產(chǎn)出足以運行其他算法的高性能網(wǎng)絡(luò)。

應(yīng)用數(shù)學(xué)家在開發(fā)新型優(yōu)化算法時，喜歡進行功能測試，有時也被稱為人造景觀。人造景觀有助于從以下方面比較各算法的性能：

· 收斂（算出答案的速度）

· 精準(zhǔn)度（與正確答案的接近程度）

· 穩(wěn)健性（是否所有功能表現(xiàn)優(yōu)良，或僅一小部分如此）

· 綜合表現(xiàn)（如概念復(fù)雜度）

瀏覽有關(guān)功能優(yōu)化測試的維基詞條，就會發(fā)現(xiàn)有些功能很難對付。很多功能因找出優(yōu)化算法的問題而被廣泛使用。但本文將討論一項看似微不足道的功能——Beale功能。

Beale功能

Beale功能如下圖所示：

Beale功能是測試功能的原因在于，它能在坡度極小的平坦區(qū)域內(nèi)評估調(diào)優(yōu)算法的性能。在這種情況下，基于坡度的優(yōu)化算法程序難以有效地學(xué)習(xí)，因此很難達到最小值。

本文接下來將按照GitHub庫里的Jupyter筆記本教程開展討論，以得出解決人造景觀的可行方式。該景觀類似于神經(jīng)網(wǎng)絡(luò)的損失平面。訓(xùn)練神經(jīng)網(wǎng)絡(luò)的目的是通過某種形式的優(yōu)化找到損失平面上的最小值——典型的隨機坡度減少。

在學(xué)習(xí)使用高難度的優(yōu)化功能后，本文讀者能充分應(yīng)對施行神經(jīng)網(wǎng)絡(luò)時遇到的實際問題場景。

測試神經(jīng)網(wǎng)絡(luò)前，首先需要給功能下定義能并找出最小值（否則無法確定為正確答案）。第一步（引進相關(guān)軟件包后），在筆記本中定義Beale功能：

# define Beale‘s function which we want to minimize

def objective（X）：

x = X［0］; y = X［1］

return （1.5 - x + x*y）**2 + （2.25 - x + x*y**2）**2 + （2.625 - x + x*y**3）**2

已知此案例中（由我們構(gòu)想）最小值的大概范圍及柵極網(wǎng)孔的步長，第二步設(shè)置功能邊界值。

# function boundaries

xmin， xmax， xstep = -4.5， 4.5， .9

ymin， ymax， ystep = -4.5， 4.5， .9

根據(jù)以上信息制作一組點狀網(wǎng)孔柵極，就可以找出最小值。

# Let’s create some points

x1， y1 = np.meshgrid（np.arange（xmin， xmax + xstep， xstep）， np.arange（ymin， ymax + ystep， ystep））

現(xiàn)在，得出（非常）初步的結(jié)論。

# initial guess

x0 = ［4.， 4.］

f0 = objective（x0）

print （f0）

然后使用scipy.optimize功能，得出答案。

bnds = （（xmin， xmax）， （ymin， ymax））

minimum = minimize（objective， x0， bounds=bnds）

print（minimum）

答案結(jié)果如下：

答案似乎是（3，0.5）。如果把這些值填入等式，這確實是最小值（維基上也顯示如此）。

接下來進入神經(jīng)網(wǎng)絡(luò)部分。

神經(jīng)網(wǎng)絡(luò)的優(yōu)化

神經(jīng)網(wǎng)絡(luò)可以被定義為一個結(jié)合輸入并猜測輸出的系統(tǒng)。幸運的話，在得出被稱作“地面實況”的結(jié)果后，將之與神經(jīng)網(wǎng)絡(luò)的各種輸出進行比對，就能計算錯誤。因此，神經(jīng)網(wǎng)絡(luò)首先進行猜測，然后計算錯誤功能；再次猜測，將錯誤最小化；再次猜測，直到錯誤最小化。這就是優(yōu)化。

神經(jīng)網(wǎng)絡(luò)中最常使用的優(yōu)化算法是GD（gradient descent，坡降）類型。坡降中使用的客觀功能正是想縮至最小的損失功能。

本教程的重頭戲是Keras，因此再回顧一下。

Keras復(fù)習(xí)

Keras是一個深度學(xué)習(xí)Python庫，可同時在Theano和TensorFlow上運行，它們也是兩個強大的快速數(shù)字計算Python庫，分別在臉書和谷歌上創(chuàng)建發(fā)布。

Keras旨在開發(fā)盡可能快捷簡單的深度學(xué)習(xí)模型，以運用在研究和實用程序中。Keras使用Python 2.7或3.5語言運行，可無縫切換至GPU和CPU運行。

Keras基于一個模型的概念。在其核心有一些按順序線性排列的層級，稱為順序模型。Keras還提供功能性界面，可定義復(fù)雜模型，如多產(chǎn)出模型、定向非循環(huán)圖以及有共有層級的模型。

可使用順序模型總結(jié)Keras的深度學(xué)習(xí)模型構(gòu)建，如下所示：

1. 定義模型：創(chuàng)建順序模型，增加層級。

2. 編譯模型：具體設(shè)置損失功能和優(yōu)化器，調(diào)用the .compile（）功能。

3. 調(diào)試模型：調(diào)用the .fit（） 功能用數(shù)據(jù)測試模型。

4. 進行預(yù)測：通過調(diào)用.evaluate（） 和.predict（）功能，使用該模型對新數(shù)據(jù)生成新預(yù)測。

有些人可能會疑惑——如何在運行模型過程中檢測其性能？這是個好問題，答案就是使用回叫。

回叫：訓(xùn)練模型過程中進行監(jiān)測

通過使用回叫，可在訓(xùn)練的任何階段監(jiān)測模型。回叫是指對訓(xùn)練程序中特定階段使用的一系列功能。使用回叫，可在訓(xùn)練過程中觀察模型內(nèi)部狀態(tài)及數(shù)據(jù)。可向順序或模型分類的the .fit（）方法傳輸一系列回叫（作為關(guān)鍵詞變元回叫）。回叫的相關(guān)方法將會在訓(xùn)練的每一個階段使用。

· 大眾所熟悉的Keras回叫功能是keras.callbacks.History（）。這是.fit（）方法自帶的。

· keras.callbacks.ModelCheckpoint也很有用，可在訓(xùn)練中存儲特定階段模型的重量。如果模型長時間運行且出現(xiàn)系統(tǒng)故障，該功能會很有效果。使用該功能后任何數(shù)據(jù)都不會遺失。比如，只有當(dāng)累加器計算且觀測到改進時，存儲模型重量才是適宜的做法。

· 可監(jiān)測的大批錯誤停止改進時，keras.callbacks.EarlyStopping功能停止訓(xùn)練。

· keras.callbacks.LearningRateScheduler功能將改變訓(xùn)練過程中的學(xué)習(xí)速度。

之后將應(yīng)用一些回叫。

首先需要引進很多不同的功能，以方便操作。

import tensorflow as tf

import keras

from keras import layers

from keras import models

from keras import utils

from keras.layers import Dense

from keras.models import Sequential

from keras.layers import Flatten

from keras.layers import Dropout

from keras.layers import Activation

from keras.regularizers import l2

from keras.optimizers import SGD

from keras.optimizers import RMSprop

from keras import datasets

from keras.callbacks import LearningRateScheduler

from keras.callbacks import History

from keras import losses

from sklearn.utils import shuffle

print（tf.VERSION）

print（tf.keras.__version__）

如果想要網(wǎng)絡(luò)使用隨機數(shù)字但結(jié)果可重復(fù)，還可以執(zhí)行的一個步驟是使用隨機種子。隨機種子每次產(chǎn)出同樣順序的數(shù)字，哪怕它們是偽隨機的（有助于比較模型和測試可復(fù)制性）。

# fix random seed for reproducibility

np.random.seed（5）

第一步——確定網(wǎng)絡(luò)拓?fù)洌ú灰欢ㄊ莾?yōu)化，但也至關(guān)重要）

這一步將使用MNIST數(shù)據(jù)集，其包含手寫數(shù)字（0到9）的灰度圖，28×28像素維度。每個像素是8位數(shù)，因此其數(shù)值范圍在0到255之間。

Keras有此內(nèi)置功能，因此能便捷地獲取數(shù)據(jù)集。

mnist = keras.datasets.mnist

（x_train， y_train），（x_test， y_test） = mnist.load_data（）

x_train.shape， y_train.shape

X和Y數(shù)據(jù)的產(chǎn)出分別是（60000， 28， 28）和（60000，1）。建議打印一些數(shù)據(jù)，檢驗數(shù)值（同時需要數(shù)據(jù)類型）。

可通過觀察每個數(shù)字的圖像來檢查訓(xùn)練數(shù)據(jù)，以確保數(shù)據(jù)中沒有任何遺漏的。

plt.figure（figsize=（10，10））

for i in range（10）：

plt.subplot（5，5，i+1）

plt.xticks（［］）

plt.yticks（［］）

plt.grid（False）

plt.imshow（x_train［i］， cmap=plt.cm.binary）

plt.xlabel（y_train［i］）

最后一項檢查是針對訓(xùn)練維度和測試集，這一步驟操作相對簡單：

print（f‘We have {x_train.shape［0］} train samples’）

print（f‘We have {x_test.shape［0］} test samples’）

有60，000個訓(xùn)練圖像和10，000個測試圖像。之后要預(yù)處理數(shù)據(jù)。

預(yù)處理數(shù)據(jù)

運行神經(jīng)網(wǎng)絡(luò)前，需要預(yù)處理數(shù)據(jù)（以下步驟可任意替換順序）：

· 首先，需要將2D圖像陣列轉(zhuǎn)為1D（扁平化）?？墒褂胣umpy.reshape（）功能進行陣列重塑，或使用Keras的方法：keras.layers.Flatten層級，可將2D陣列（28×28像素）圖像轉(zhuǎn)化為1D陣列圖像（28 * 28 = 784像素）。

· 然后需要將像素值調(diào)至正常狀態(tài)（將數(shù)值調(diào)整為0到1之間），轉(zhuǎn)換如下：

在案例中，最小值為0，最大值為255，因此公式為：：=/255。

# normalize the data

x_train， x_test = x_train / 255.0， x_test / 255.0

# reshape the data into 1D vectors

x_train = x_train.reshape（60000， 784）

x_test = x_test.reshape（10000， 784）

num_classes = 10

# Check the column length

x_train.shape［1］

現(xiàn)在數(shù)據(jù)中需要一個獨熱碼。

# Convert class vectors to binary class matrices

y_train = keras.utils.to_categorical（y_train， num_classes）

y_test = keras.utils.to_categorical（y_test， num_classes）

第二步——調(diào)整學(xué)習(xí)速度

最常用的優(yōu)化算法之一是隨機坡降（SGD）。其中可調(diào)優(yōu)的超參數(shù)是學(xué)習(xí)速度，動量，衰變和nesterov項。

學(xué)習(xí)速度在每批結(jié)束時控制重量，并且動量控制先前重量如何影響當(dāng)前重量。衰變表示每次更新時學(xué)習(xí)速度的下降幅度。nesterov取值“True”或“False”取決于是否要應(yīng)用Nesterov動量。

這些超參數(shù)的通常數(shù)值是lr = 0.01，衰變= 1e-6，動量= 0.9，nesterov = True。

學(xué)習(xí)速度超參數(shù)會存在于優(yōu)化功能中，如下所示。 Keras在SGDoptimizer中具有默認(rèn)學(xué)習(xí)速度調(diào)度器，會通過隨機坡降的優(yōu)化算法降低學(xué)習(xí)速度。 學(xué)習(xí)速度隨著以下公式降低：

lr=lr×1/（1+decayepoch）

接下來在Keras中實施學(xué)習(xí)速度適應(yīng)時間表。 先從SGD開始，學(xué)習(xí)速度數(shù)值為0.1。 然后針對模型訓(xùn)練60個時期并將衰變參數(shù)設(shè)置為0.0016（0.1 / 60）。其中還包括動量值0.8，因為它在使用、適應(yīng)學(xué)習(xí)速度時運作良好。

pochs=60

learning_rate = 0.1

decay_rate = learning_rate / epochs

momentum = 0.8

sgd = SGD（lr=learning_rate， momentum=momentum， decay=decay_rate， nesterov=False）

接下來開始構(gòu)建神經(jīng)網(wǎng)絡(luò)：

# build the model

input_dim = x_train.shape［1］

lr_model = Sequential（）

lr_model.add（Dense（64， activation=tf.nn.relu， kernel_initializer=‘uniform’，

input_dim = input_dim））

lr_model.add（Dropout（0.1））

lr_model.add（Dense（64， kernel_initializer=‘uniform’， activation=tf.nn.relu））

lr_model.add（Dense（num_classes， kernel_initializer=‘uniform’， activation=tf.nn.softmax））

# compile the model

lr_model.compile（loss=‘categorical_crossentropy’，

optimizer=sgd，

metrics=［‘a(chǎn)cc’］）

現(xiàn)在可以運行模型，看看它的表現(xiàn)如何。機器花費了大約20分鐘，各人的機器運行速度不一。

%%time

# Fit the model

batch_size = int（input_dim/100）

lr_model_history = lr_model.fit（x_train， y_train，

batch_size=batch_size，

epochs=epochs，

verbose=1，

validation_data=（x_test， y_test））

運行完畢后，可以把準(zhǔn)確度和損失功能繪制為訓(xùn)練和測試集的時期函數(shù)，以查看網(wǎng)絡(luò)運行情況。

# Plot the loss function

fig， ax = plt.subplots（1， 1， figsize=（10，6））

ax.plot（np.sqrt（lr_model_history.history［‘loss’］）， ‘r’， label=‘train’）

ax.plot（np.sqrt（lr_model_history.history［‘val_loss’］）， ‘b’ ，label=‘val’）

ax.set_xlabel（r‘Epoch’， fontsize=20）

ax.set_ylabel（r‘Loss’， fontsize=20）

ax.legend（）

ax.tick_params（labelsize=20）

# Plot the accuracy

fig， ax = plt.subplots（1， 1， figsize=（10，6））

ax.plot（np.sqrt（lr_model_history.history［‘a(chǎn)cc’］）， ‘r’， label=‘train’）

ax.plot（np.sqrt（lr_model_history.history［‘val_acc’］）， ‘b’ ，label=‘val’）

ax.set_xlabel（r‘Epoch’， fontsize=20）

ax.set_ylabel（r‘Accuracy’， fontsize=20）

ax.legend（）

ax.tick_params（labelsize=20）

損失函數(shù)圖如下：

準(zhǔn)確度如下：

現(xiàn)在應(yīng)用自定義學(xué)習(xí)速度。

使用LearningRateScheduler改變自定義學(xué)習(xí)速度

編寫一個執(zhí)行指數(shù)學(xué)習(xí)速度衰變的函數(shù)，如下公式所示：

=0×^（ - ）

這與之前非常相似，因此會在一個代碼塊中執(zhí)行此操作，并描述差異。

# solution

epochs = 60

learning_rate = 0.1 # initial learning rate

decay_rate = 0.1

momentum = 0.8

# define the optimizer function

sgd = SGD（lr=learning_rate， momentum=momentum， decay=decay_rate， nesterov=False）

input_dim = x_train.shape［1］

num_classes = 10

batch_size = 196

# build the model

exponential_decay_model = Sequential（）

exponential_decay_model.add（Dense（64， activation=tf.nn.relu， kernel_initializer=‘uniform’， input_dim = input_dim））

exponential_decay_model.add（Dropout（0.1））

exponential_decay_model.add（Dense（64， kernel_initializer=‘uniform’， activation=tf.nn.relu））

exponential_decay_model.add（Dense（num_classes， kernel_initializer=‘uniform’， activation=tf.nn.softmax））

# compile the model

exponential_decay_model.compile（loss=‘categorical_crossentropy’，

optimizer=sgd，

metrics=［‘a(chǎn)cc’］）

# define the learning rate change

def exp_decay（epoch）：

lrate = learning_rate * np.exp（-decay_rate*epoch）

return lrate

# learning schedule callback

loss_history = History（）

lr_rate = LearningRateScheduler（exp_decay）

callbacks_list = ［loss_history， lr_rate］

# you invoke the LearningRateScheduler during the .fit（） phase

exponential_decay_model_history = exponential_decay_model.fit（x_train， y_train，

batch_size=batch_size，

epochs=epochs，

callbacks=callbacks_list，

verbose=1，

validation_data=（x_test， y_test））

此處看到，唯一改變的是被定義的exp_decay函數(shù)，以及它在LearningRateScheduler函數(shù)中的使用。注意本次還選擇向模型添加一些回叫。

現(xiàn)在可以將學(xué)習(xí)速度和損失功能繪制為時期數(shù)量的函數(shù)。學(xué)習(xí)速度圖非常平穩(wěn)，因為它符合預(yù)定義的指數(shù)衰變函數(shù)。

與之前相比，損失函數(shù)更為平穩(wěn)。

這表明開發(fā)學(xué)習(xí)速度調(diào)度程序有助于提高神經(jīng)網(wǎng)絡(luò)的性能。

第三步——選擇優(yōu)化器和損失函數(shù)

在構(gòu)建模型并使用它進行預(yù)測時，如為圖像（“貓”，“平面”等）加標(biāo)簽，希望通過定義“損失”函數(shù)來衡量成?。ɑ蚰繕?biāo)函數(shù)）。優(yōu)化目標(biāo)是有效計算使該損失函數(shù)最小化的參數(shù)/權(quán)重。Keras提供各種類型的損失函數(shù)。

有時“損失”函數(shù)可以測量“距離”，通過符合問題或數(shù)據(jù)集的各種方式在兩個數(shù)據(jù)點之間定義這個“距離”。使用的距離取決于數(shù)據(jù)類型和正在處理的特定問題。例如，在自然語言處理（分析文本數(shù)據(jù)）中，漢明距離的使用更為常見。

距離

· 歐幾里德（Euclidean）

· 曼哈頓（Manhattan）

· 如漢明等距離用于測量弦之間的距離。 “carolin”和“cathrin”之間的漢明距離為3。

損失函數(shù)

· MSE（用于回歸）

· 分類交叉熵（用于分類）

· 二元交叉熵（用于分類）

# build the model

input_dim = x_train.shape［1］

model = Sequential（）

model.add（Dense（64， activation=tf.nn.relu， kernel_initializer=‘uniform’，

input_dim = input_dim）） # fully-connected layer with 64 hidden units

model.add（Dropout（0.1））

model.add（Dense（64， kernel_initializer=‘uniform’， activation=tf.nn.relu））

model.add（Dense（num_classes， kernel_initializer=‘uniform’， activation=tf.nn.softmax））

# defining the parameters for RMSprop （I used the keras defaults here）

rms = RMSprop（lr=0.001， rho=0.9， epsilon=None， decay=0.0）

model.compile（loss=‘categorical_crossentropy’，

optimizer=rms，

metrics=［‘a(chǎn)cc’］）

第4步——確定批量大小和時期數(shù)量

批量大小定義通過網(wǎng)絡(luò)傳播的樣本數(shù)。

例如，有1000個訓(xùn)練樣本，并且要設(shè)置batch_size為100。算法從訓(xùn)練數(shù)據(jù)集中獲取前100個樣本（從第1到第100個）訓(xùn)練網(wǎng)絡(luò)。接下來，需要另外100個樣本（從第101到第200）并再次訓(xùn)練網(wǎng)絡(luò)。此過程需一直執(zhí)行直至傳播完樣本。

使用批量大小的優(yōu)點《所有樣本數(shù)量的優(yōu)點：

· 所需內(nèi)存更小。由于使用較少樣本訓(xùn)練網(wǎng)絡(luò)，整體訓(xùn)練過程需要較小的內(nèi)存。如果無法將整個數(shù)據(jù)集放入機器的內(nèi)存中，那么這一點尤為重要。

· 通常，使用小批量的網(wǎng)絡(luò)培訓(xùn)得更快，原因是每次傳播后會更新權(quán)重。

使用批量大小的缺點《所有樣本的數(shù)量的缺點：

· 批次越小，梯度的估計就越不準(zhǔn)確。

時期數(shù)是一個超參數(shù)，定義學(xué)習(xí)算法在整個訓(xùn)練數(shù)據(jù)集中的工作次數(shù)。

一個時期意味著訓(xùn)練數(shù)據(jù)集中的每個樣本都有機會更新內(nèi)部模型參數(shù)。時期由一個或多個批次組成。

選擇批量大小或時期數(shù)沒有硬性和快速的規(guī)則，并且增加時期數(shù)不一定比較少時期數(shù)產(chǎn)生更好的結(jié)果。

%%time

batch_size = input_dim

epochs = 60

model_history = model.fit（x_train， y_train，

batch_size=batch_size，

epochs=epochs，

verbose=1，

validation_data=（x_test， y_test））

score = model.evaluate（x_test， y_test， verbose=0）print（‘Test loss：’， score［0］）print（‘Test accuracy：’， score［1］）

fig， ax = plt.subplots（1， 1， figsize=（10，6））ax.plot（np.sqrt（model_history.history［‘a(chǎn)cc’］）， ‘r’， label=‘train_acc’）ax.plot（np.sqrt（model_history.history［‘val_acc’］）， ‘b’ ，label=‘val_acc’）ax.set_xlabel（r‘Epoch’， fontsize=20）ax.set_ylabel（r‘Accuracy’， fontsize=20）ax.legend（）ax.tick_params（labelsize=20）

fig， ax = plt.subplots（1， 1， figsize=（10，6））ax.plot（np.sqrt（model_history.history［‘loss’］）， ‘r’， label=‘train’）ax.plot（np.sqrt（model_history.history［‘val_loss’］）， ‘b’ ，label=‘val’）ax.set_xlabel（r‘Epoch’， fontsize=20）ax.set_ylabel（r‘Loss’， fontsize=20）ax.legend（）ax.tick_params（labelsize=20）

第5步——隨機重啟

此方法似乎無法Keras中實現(xiàn)，但可以通過更改keras.callbacks.LearningRateScheduler輕松完成。本文將此作為練習(xí)留給讀者，它主要是在有限時期數(shù)之后重置學(xué)習(xí)速度。

使用交叉驗證調(diào)整超參數(shù)

現(xiàn)在無需手動嘗試不同值，而可使用Scikit-Learn的GridSearchCV，為超參數(shù)嘗試幾個值，并比較結(jié)果。

為使用Keras進行交叉驗證，將運用到Scikit-Learn API的包裝器。其將Sequential Keras模型使用（僅單輸入）作為Scikit-Learn工作流程的一部分。

以下為兩個包裝器：

keras.wrappers.scikit_learn.KerasClassifier（build_fn = None，** sk_params），它實現(xiàn)了Scikit-Learn分類器接口。

keras.wrappers.scikit_learn.KerasRegressor（build_fn = None，** sk_params），它實現(xiàn)了Scikit-Learn回歸量接口。

import numpy

from sklearn.model_selection import GridSearchCV

from keras.wrappers.scikit_learn import KerasClassifier

嘗試不同的權(quán)重初始化

將嘗試通過交叉驗證進行優(yōu)化的第一個超參數(shù)是不同的權(quán)重初始化。

# let‘s create a function that creates the model （required for KerasClassifier）

# while accepting the hyperparameters we want to tune

# we also pass some default values such as optimizer=’rmsprop‘

def create_model（init_mode=’uniform‘）：

# define model

model = Sequential（）

model.add（Dense（64， kernel_initializer=init_mode， activation=tf.nn.relu， input_dim=784））

model.add（Dropout（0.1））

model.add（Dense（64， kernel_initializer=init_mode， activation=tf.nn.relu））

model.add（Dense（10， kernel_initializer=init_mode， activation=tf.nn.softmax））

# compile model

model.compile（loss=’categorical_crossentropy‘，

optimizer=RMSprop（），

metrics=［’accuracy‘］）

return model

%%time

seed = 7

numpy.random.seed（seed）

batch_size = 128

epochs = 10

model_CV = KerasClassifier（build_fn=create_model， epochs=epochs，

batch_size=batch_size， verbose=1）

# define the grid search parameters

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_CV， param_grid=param_grid， n_jobs=-1， cv=3）

grid_result = grid.fit（x_train， y_train）

# print results

print（f’Best Accuracy for {grid_result.best_score_} using {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’ mean={mean：.4}， std={stdev：.4} using {param}‘）

GridSearch結(jié)果如下：

可以看到，從使用lecun_uniform初始化或glorot_uniform初始化的模型中得出最好的結(jié)果，并且可以獲得近97％的準(zhǔn)確度。

將神經(jīng)網(wǎng)絡(luò)模型保存為JSON

分層數(shù)據(jù)格式（HDF5）用于存儲大陣列數(shù)據(jù)，包括神經(jīng)網(wǎng)絡(luò)中權(quán)重的值。

可以安裝HDF5 Python模塊：pip install h5py

Keras有助于使用JSON格式描述和保存任何模型。

from keras.models import model_from_json

# serialize model to JSON

model_json = model.to_json（）

with open（“model.json”， “w”） as json_file：

json_file.write（model_json）

# save weights to HDF5

model.save_weights（“model.h5”）

print（“Model saved”）

# when you want to retrieve the model： load json and create model

json_file = open（’model.json‘， ’r‘）

saved_model = json_file.read（）

# close the file as good practice

json_file.close（）

model_from_json = model_from_json（saved_model）

# load weights into new model

model_from_json.load_weights（“model.h5”）

print（“Model loaded”）

使用多個超參數(shù)進行交叉驗證

通常人們對一個參數(shù)變化的方式不感興趣，而對多個參數(shù)變化如何影響結(jié)果感到好奇?？梢酝瑫r對多個參數(shù)進行交叉驗證，嘗試它們的組合。

注意：神經(jīng)網(wǎng)絡(luò)中的交叉驗證需要大量計算。在實驗之前要三思！將需要驗證的要素數(shù)量相乘，查看有多少組合。使用k折交叉驗證評估每個組合（k是我們選擇的參數(shù)）。

例如，可以選擇搜索不同的值：

· 批量大小

· 時期數(shù)量

· 初始化模式

選項被指定到字典中并傳遞給GridSearchCV。

現(xiàn)在對批量大小、時期數(shù)和初始化程序組合執(zhí)行GridSearch。

# repeat some of the initial values here so we make sure they were not changed

input_dim = x_train.shape［1］

num_classes = 10

# let’s create a function that creates the model （required for KerasClassifier）

# while accepting the hyperparameters we want to tune

# we also pass some default values such as optimizer=‘rmsprop’

def create_model_2（optimizer=‘rmsprop’， init=‘glorot_uniform’）：

model = Sequential（）

model.add（Dense（64， input_dim=input_dim， kernel_initializer=init， activation=‘relu’））

model.add（Dropout（0.1））

model.add（Dense（64， kernel_initializer=init， activation=tf.nn.relu））

model.add（Dense（num_classes， kernel_initializer=init， activation=tf.nn.softmax））

# compile model

model.compile（loss=‘categorical_crossentropy’，

optimizer=optimizer，

metrics=［‘a(chǎn)ccuracy’］）

return model

%%time

# fix random seed for reproducibility （this might work or might not work

# depending on each library‘s implenentation）

seed = 7

numpy.random.seed（seed）

# create the sklearn model for the network

model_init_batch_epoch_CV = KerasClassifier（build_fn=create_model_2， verbose=1）

# we choose the initializers that came at the top in our previous cross-validation！！

init_mode = ［’glorot_uniform‘， ’uniform‘］

batches = ［128， 512］

epochs = ［10， 20］

# grid search for initializer， batch size and number of epochs

param_grid = dict（epochs=epochs， batch_size=batches， init=init_mode）

grid = GridSearchCV（estimator=model_init_batch_epoch_CV，

param_grid=param_grid，

cv=3）

grid_result = grid.fit（x_train， y_train）

# print results

print（f’Best Accuracy for {grid_result.best_score_：.4} using {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’mean={mean：.4}， std={stdev：.4} using {param}‘）

最后一個問題：如果在GridSearchCV中必須循環(huán)的參數(shù)數(shù)量和值的數(shù)量特別大，該怎么辦？

這可能是一個棘手的問題。想象一下，有5個參數(shù)以及為每個參數(shù)選擇的10個可能值?？赡芙M合的數(shù)量是10，這意味著必須訓(xùn)練一個龐大的網(wǎng)絡(luò)。顯然，這種操作會很瘋狂，所以通常使用RandomizedCV。

RandomizedCV允許人們指定所有可能的參數(shù)。對于交叉驗證中的每個折疊，它選擇用于當(dāng)前模型的隨機參數(shù)子集。最后，用戶可以選擇最佳參數(shù)集并將其用作近似解。