全文共7002字，預計學習時長14分鐘或更長
神經網絡在通信行業和研究中的使用十分常見，但令人遺憾的是，大部分應用都未能產出足以運行其他算法的高性能網絡。
應用數學家在開發新型優化算法時，喜歡進行功能測試，有時也被稱為人造景觀。人造景觀有助於從以下方面比較各算法的性能：
· 收斂（算出答案的速度）
· 精準度（與正確答案的接近程度）
· 穩健性（是否所有功能表現優良，或僅一小部分如此）
· 綜合表現（如概念複雜度）
瀏覽有關功能優化測試的維基詞條，就會發現有些功能很難對付。很多功能因找出優化算法的問題而被廣泛使用。但本文將討論一項看似微不足道的功能——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允許人們指定所有可能的參數。對於交叉驗證中的每個摺疊，它選擇用於當前模型的隨機參數子集。最後，用戶可以選擇最佳參數集並將其用作近似解。
留言 點讚 關注我們一起分享AI學習與發展的乾貨歡迎關注全平臺AI垂類自媒體 「讀芯術」