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

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

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

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

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

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

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

Beale功能

Beale功能如下圖所示：

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

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

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

測(cè)試神經(jīng)網(wǎng)絡(luò)前，首先需要給功能下定義能并找出最小值（否則無(wú)法確定為正確答案）。第一步（引進(jìn)相關(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)孔的步長(zhǎng)，第二步設(shè)置功能邊界值。

# function boundaries

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

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

根據(jù)以上信息制作一組點(diǎn)狀網(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）。如果把這些值填入等式，這確實(shí)是最小值（維基上也顯示如此）。

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

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

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

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

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

Keras復(fù)習(xí)

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

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

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

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

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

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

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

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

有些人可能會(huì)疑惑——如何在運(yùn)行模型過(guò)程中檢測(cè)其性能？這是個(gè)好問(wèn)題，答案就是使用回叫。

回叫：訓(xùn)練模型過(guò)程中進(jìn)行監(jiān)測(cè)

通過(guò)使用回叫，可在訓(xùn)練的任何階段監(jiān)測(cè)模型?；亟惺侵笇?duì)訓(xùn)練程序中特定階段使用的一系列功能。使用回叫，可在訓(xùn)練過(guò)程中觀察模型內(nèi)部狀態(tài)及數(shù)據(jù)?？上蝽樞蚧蚰Ｐ头诸惖膖he .fit（）方法傳輸一系列回叫（作為關(guān)鍵詞變?cè)亟校??；亟械南嚓P(guān)方法將會(huì)在訓(xùn)練的每一個(gè)階段使用。

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

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

· 可監(jiān)測(cè)的大批錯(cuò)誤停止改進(jìn)時(shí)，keras.callbacks.EarlyStopping功能停止訓(xùn)練。

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

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

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

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ò)使用隨機(jī)數(shù)字但結(jié)果可重復(fù)，還可以執(zhí)行的一個(gè)步驟是使用隨機(jī)種子。隨機(jī)種子每次產(chǎn)出同樣順序的數(shù)字，哪怕它們是偽隨機(jī)的（有助于比較模型和測(cè)試可復(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像素維度。每個(gè)像素是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ù)，檢驗(yàn)數(shù)值（同時(shí)需要數(shù)據(jù)類型）。

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

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］）

最后一項(xiàng)檢查是針對(duì)訓(xùn)練維度和測(cè)試集，這一步驟操作相對(duì)簡(jiǎn)單：

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

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

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

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

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

· 首先，需要將2D圖像陣列轉(zhuǎn)為1D（扁平化）?？墒褂胣umpy.reshape（）功能進(jìn)行陣列重塑，或使用Keras的方法：keras.layers.Flatten層級(jí)，可將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ù)中需要一個(gè)獨(dú)熱碼。

# 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)化算法之一是隨機(jī)坡降（SGD）。其中可調(diào)優(yōu)的超參數(shù)是學(xué)習(xí)速度，動(dòng)量，衰變和nesterov項(xiàng)。

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

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

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

lr=lr×1/（1+decayepoch）

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

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）

接下來(lái)開(kāi)始構(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)在可以運(yùn)行模型，看看它的表現(xiàn)如何。機(jī)器花費(fèi)了大約20分鐘，各人的機(jī)器運(yùn)行速度不一。

%%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））

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

# 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í)速度

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

=0×^（ - ）

這與之前非常相似，因此會(huì)在一個(gè)代碼塊中執(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ù)量的函數(shù)。學(xué)習(xí)速度圖非常平穩(wěn)，因?yàn)樗项A(yù)定義的指數(shù)衰變函數(shù)。

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

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

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

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

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

距離

· 歐幾里德（Euclidean）

· 曼哈頓（Manhattan）

· 如漢明等距離用于測(cè)量弦之間的距離。 “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í)期數(shù)量

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

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

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

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

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

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

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

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

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

選擇批量大小或時(shí)期數(shù)沒(méi)有硬性和快速的規(guī)則，并且增加時(shí)期數(shù)不一定比較少時(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步——隨機(jī)重啟

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

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

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

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

以下為兩個(gè)包裝器：

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

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

import numpy

from sklearn.model_selection import GridSearchCV

from keras.wrappers.scikit_learn import KerasClassifier

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

將嘗試通過(guò)交叉驗(yàn)證進(jìn)行優(yōu)化的第一個(gè)超參數(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）用于存儲(chǔ)大陣列數(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”）

使用多個(gè)超參數(shù)進(jìn)行交叉驗(yàn)證

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

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

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

· 批量大小

· 時(shí)期數(shù)量

· 初始化模式

選項(xiàng)被指定到字典中并傳遞給GridSearchCV。

現(xiàn)在對(duì)批量大小、時(shí)期數(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}‘）

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

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

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