神經網絡在通信行業和研究中的使用十分常見，但令人遺憾的是，大部分應用都未能產出足以運行其他算法的高性能網絡。

應用數學家在開發新型優化算法時，喜歡進行功能測試，有時也被稱為人造景觀。人造景觀有助于從以下方面比較各算法的性能：

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

· 精準度（與正確答案的接近程度）

· 穩健性（是否所有功能表現優良，或僅一小部分如此）

· 綜合表現（如概念復雜度）

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

Beale功能

Beale功能如下圖所示：

Beale功能是測試功能的原因在于，它能在坡度極小的平坦區域內評估調優算法的性能。在這種情況下，基于坡度的優化算法程序難以有效地學習，因此很難達到最小值。

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

在學習使用高難度的優化功能后，本文讀者能充分應對施行神經網絡時遇到的實際問題場景。

測試神經網絡前，首先需要給功能下定義能并找出最小值（否則無法確定為正確答案）。第一步（引進相關軟件包后），在筆記本中定義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

已知此案例中（由我們構想）最小值的大概范圍及柵極網孔的步長，第二步設置功能邊界值。

# function boundaries

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

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

根據以上信息制作一組點狀網孔柵極，就可以找出最小值。

# Let’s create some points

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

現在，得出（非常）初步的結論。

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

答案結果如下：

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

接下來進入神經網絡部分。

神經網絡的優化

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

神經網絡中最常使用的優化算法是GD（gradient descent，坡降）類型。坡降中使用的客觀功能正是想縮至最小的損失功能。

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

Keras復習

Keras是一個深度學習Python庫，可同時在Theano和TensorFlow上運行，它們也是兩個強大的快速數字計算Python庫，分別在臉書和谷歌上創建發布。

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

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

可使用順序模型總結Keras的深度學習模型構建，如下所示：

1. 定義模型：創建順序模型，增加層級。

2. 編譯模型：具體設置損失功能和優化器，調用the .compile（）功能。

3. 調試模型：調用the .fit（） 功能用數據測試模型。

4. 進行預測：通過調用.evaluate（） 和.predict（）功能，使用該模型對新數據生成新預測。

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

回叫：訓練模型過程中進行監測

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

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

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

· 可監測的大批錯誤停止改進時，keras.callbacks.EarlyStopping功能停止訓練。

· keras.callbacks.LearningRateScheduler功能將改變訓練過程中的學習速度。

之后將應用一些回叫。

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

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

如果想要網絡使用隨機數字但結果可重復，還可以執行的一個步驟是使用隨機種子。隨機種子每次產出同樣順序的數字，哪怕它們是偽隨機的（有助于比較模型和測試可復制性）。

# fix random seed for reproducibility

np.random.seed（5）

第一步——確定網絡拓撲（不一定是優化，但也至關重要）

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

Keras有此內置功能，因此能便捷地獲取數據集。

mnist = keras.datasets.mnist

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

x_train.shape， y_train.shape

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

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

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

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

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

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

有60，000個訓練圖像和10，000個測試圖像。之后要預處理數據。

預處理數據

運行神經網絡前，需要預處理數據（以下步驟可任意替換順序）：

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

· 然后需要將像素值調至正常狀態（將數值調整為0到1之間），轉換如下：

在案例中，最小值為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］

現在數據中需要一個獨熱碼。

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

第二步——調整學習速度

最常用的優化算法之一是隨機坡降（SGD）。其中可調優的超參數是學習速度，動量，衰變和nesterov項。

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

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

學習速度超參數會存在于優化功能中，如下所示。 Keras在SGDoptimizer中具有默認學習速度調度器，會通過隨機坡降的優化算法降低學習速度。 學習速度隨著以下公式降低：

lr=lr×1/（1+decayepoch）

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

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）

接下來開始構建神經網絡：

# 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=［‘acc’］）

現在可以運行模型，看看它的表現如何。機器花費了大約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））

運行完畢后，可以把準確度和損失功能繪制為訓練和測試集的時期函數，以查看網絡運行情況。

# 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［‘acc’］）， ‘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）

損失函數圖如下：

準確度如下：

現在應用自定義學習速度。

使用LearningRateScheduler改變自定義學習速度

編寫一個執行指數學習速度衰變的函數，如下公式所示：

=0×^（ - ）

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

# 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=［‘acc’］）

# 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函數，以及它在LearningRateScheduler函數中的使用。注意本次還選擇向模型添加一些回叫。

現在可以將學習速度和損失功能繪制為時期數量的函數。學習速度圖非常平穩，因為它符合預定義的指數衰變函數。

與之前相比，損失函數更為平穩。

這表明開發學習速度調度程序有助于提高神經網絡的性能。

第三步——選擇優化器和損失函數

在構建模型并使用它進行預測時，如為圖像（“貓”，“平面”等）加標簽，希望通過定義“損失”函數來衡量成敗（或目標函數）。優化目標是有效計算使該損失函數最小化的參數/權重。Keras提供各種類型的損失函數。

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

距離

· 歐幾里德（Euclidean）

· 曼哈頓（Manhattan）

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

損失函數

· 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=［‘acc’］）

第4步——確定批量大小和時期數量

批量大小定義通過網絡傳播的樣本數。

例如，有1000個訓練樣本，并且要設置batch_size為100。算法從訓練數據集中獲取前100個樣本（從第1到第100個）訓練網絡。接下來，需要另外100個樣本（從第101到第200）并再次訓練網絡。此過程需一直執行直至傳播完樣本。

使用批量大小的優點《所有樣本數量的優點：

· 所需內存更小。由于使用較少樣本訓練網絡，整體訓練過程需要較小的內存。如果無法將整個數據集放入機器的內存中，那么這一點尤為重要。

· 通常，使用小批量的網絡培訓得更快，原因是每次傳播后會更新權重。

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

· 批次越小，梯度的估計就越不準確。

時期數是一個超參數，定義學習算法在整個訓練數據集中的工作次數。

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

選擇批量大小或時期數沒有硬性和快速的規則，并且增加時期數不一定比較少時期數產生更好的結果。

%%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［‘acc’］）， ‘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中實現，但可以通過更改keras.callbacks.LearningRateScheduler輕松完成。本文將此作為練習留給讀者，它主要是在有限時期數之后重置學習速度。

使用交叉驗證調整超參數

現在無需手動嘗試不同值，而可使用Scikit-Learn的GridSearchCV，為超參數嘗試幾個值，并比較結果。

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

以下為兩個包裝器：

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

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

import numpy

from sklearn.model_selection import GridSearchCV

from keras.wrappers.scikit_learn import KerasClassifier

嘗試不同的權重初始化

將嘗試通過交叉驗證進行優化的第一個超參數是不同的權重初始化。

# 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結果如下：

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

將神經網絡模型保存為JSON

分層數據格式（HDF5）用于存儲大陣列數據，包括神經網絡中權重的值。

可以安裝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”）

使用多個超參數進行交叉驗證

通常人們對一個參數變化的方式不感興趣，而對多個參數變化如何影響結果感到好奇。可以同時對多個參數進行交叉驗證，嘗試它們的組合。

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

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

· 批量大小

· 時期數量

· 初始化模式

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

現在對批量大小、時期數和初始化程序組合執行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=［‘accuracy’］）

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中必須循環的參數數量和值的數量特別大，該怎么辦？

這可能是一個棘手的問題。想象一下，有5個參數以及為每個參數選擇的10個可能值。可能組合的數量是10，這意味著必須訓練一個龐大的網絡。顯然，這種操作會很瘋狂，所以通常使用RandomizedCV。

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