在Keras中评估深度学习模型的性能

根据经验评估网络配置

当设计或者配置深度网络模型时，我们的决策如超参数的设置会影响整个网络的性能。
当我们复制或者改进别人的网络架构时，通常可以帮助我们屏蔽掉一些底层的错误配置，最好的方式就是设计一些小的实验模型架构，并通过真实的数据去评估该模型。
这个过程涉及到两个层面的决策：高层决策，例如网络中层的数量，大小和类型。 它还包括较低级别的决策，例如损失函数的选择，激活函数，优化过程和时期数的选择。
深度学习通常用于具有非常大的数据集的问题。 那就是成千上万的实例。
因此，我们需要具有强大的测试工具，利用不可见的大量数据估算给定配置的性能，并将性能与其他配置可靠地进行比较。

数据划分

大量的数据和模型的复杂性要求非常长的训练时间。
我们通常是将数据简单地分为训练和测试数据集或训练和验证数据集。
Keras提供了三种方便的方式来评估深度学习算法：

• 使用自动验证数据集
• 使用手动验证数据集
• 手动 k-Fold 交叉验证

自动验证数据集

Keras 依据某一比例将训练数据集划分为验证数据集，然后利用验证数据集在每一个 epoch 运行结束时评估模型的性能。
我们可以在 fit() 函数的参数 validation_split 中指定某一比例训练。
以下是一个使用案例：

# MLP with automatic validation set
from keras.models import Sequential
from keras.layers import Dense
import numpy
# fix random seed for reproducibility
numpy.random.seed(7)
# load pima indians dataset
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
# create model
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# Compile model
model.compile(
			loss='binary_crossentropy', 
			optimizer='adam', 
			metrics=['accuracy'])
# Fit the model
model.fit(
			X, 
			Y, 
			validation_split=0.33, 
			epochs=150, 
			batch_size=10)

注意：由于算法或评估程序的随机性，或者数值精度的差异，您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。
训练及测试过程如下：

...
Epoch 145/150
514/514 [==============================] - 0s - loss: 0.5252 - acc: 0.7335 - val_loss: 0.5489 - val_acc: 0.7244
Epoch 146/150
514/514 [==============================] - 0s - loss: 0.5198 - acc: 0.7296 - val_loss: 0.5918 - val_acc: 0.7244
Epoch 147/150
514/514 [==============================] - 0s - loss: 0.5175 - acc: 0.7335 - val_loss: 0.5365 - val_acc: 0.7441
Epoch 148/150
514/514 [==============================] - 0s - loss: 0.5219 - acc: 0.7354 - val_loss: 0.5414 - val_acc: 0.7520
Epoch 149/150
514/514 [==============================] - 0s - loss: 0.5089 - acc: 0.7432 - val_loss: 0.5417 - val_acc: 0.7520
Epoch 150/150
514/514 [==============================] - 0s - loss: 0.5148 - acc: 0.7490 - val_loss: 0.5549 - val_acc: 0.7520

手动验证数据集

利用 train_test_split() 函数将数据划分为训练和测试数据集。

# MLP with manual validation set
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_split
import numpy
# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)
# load pima indians dataset
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
# split into 67% for train and 33% for test
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=seed)
# create model
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# Compile model
model.compile(
			loss='binary_crossentropy', 
			optimizer='adam', 
			metrics=['accuracy'])
# Fit the model
model.fit(
		X_train, 
		y_train, 
		validation_data=(X_test,y_test), 
		epochs=150, 
		batch_size=10)

...
Epoch 145/150
514/514 [==============================] - 0s - loss: 0.4847 - acc: 0.7704 - val_loss: 0.5668 - val_acc: 0.7323
Epoch 146/150
514/514 [==============================] - 0s - loss: 0.4853 - acc: 0.7549 - val_loss: 0.5768 - val_acc: 0.7087
Epoch 147/150
514/514 [==============================] - 0s - loss: 0.4864 - acc: 0.7743 - val_loss: 0.5604 - val_acc: 0.7244
Epoch 148/150
514/514 [==============================] - 0s - loss: 0.4831 - acc: 0.7665 - val_loss: 0.5589 - val_acc: 0.7126
Epoch 149/150
514/514 [==============================] - 0s - loss: 0.4961 - acc: 0.7782 - val_loss: 0.5663 - val_acc: 0.7126
Epoch 150/150
514/514 [==============================] - 0s - loss: 0.4967 - acc: 0.7588 - val_loss: 0.5810 - val_acc: 0.6929

手动 k-Fold 交叉验证

手动 K-Fold 交叉验证是机器学习模型评估的金标准。通过将训练数据集划分为k个子集并轮流对所有子集（除了一个被保留的子集）进行训练模型，并在保留的验证数据集上评估模型性能来实现。 重复该过程，直到所有子集都有机会成为保留的验证集。 然后，对所创建的所有模型的性能指标取平均值。
交叉验证通常不用于评估深度学习模型，因为其计算量更大。 例如，通常使用5倍或10倍的k倍交叉验证。 因此，必须构建和评估5或10个模型，从而大大增加了模型的评估时间。
但是，当问题足够小或您有足够的计算资源时，k倍交叉验证可以使您对模型性能的估计偏差较小。
在下面的示例中，我们使用scikit-learn Python机器学习库中方便的StratifiedKFold类将训练数据集分成10折。 折叠是分层的，这意味着算法会尝试平衡每个折叠中每个类的实例数量。
该示例使用10个数据拆分创建并评估10个模型，并收集所有分数。通过将 verbose = 0 传递给模型上的 fit() 和 evaluate() 函数，可以关闭每个时期的详细输出。
打印每个模型的性能评估将其存储。 然后，在运行结束时打印模型性能的平均和标准偏差，以提供对模型准确性的可靠估计。

# MLP for Pima Indians Dataset with 10-fold cross validation
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import StratifiedKFold
import numpy
# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)
# load pima indians dataset
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
# define 10-fold cross validation test harness
kfold = StratifiedKFold(
						n_splits=10, 
						shuffle=True, 
						random_state=seed)
cvscores = []
for train, test in kfold.split(X, Y):
  # create model
	model = Sequential()
	model.add(Dense(12, input_dim=8, activation='relu'))
	model.add(Dense(8, activation='relu'))
	model.add(Dense(1, activation='sigmoid'))
	# Compile model
	model.compile(
				loss='binary_crossentropy', 
				optimizer='adam', 
				metrics=['accuracy'])
	# Fit the model
	model.fit(
			X[train], 
			Y[train], 
			epochs=150, 
			batch_size=10, 
			verbose=0)
	# evaluate the model
	scores = model.evaluate(X[test], Y[test], verbose=0)
	print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
	cvscores.append(scores[1] * 100)
print("%.2f%% (+/- %.2f%%)" % (numpy.mean(cvscores), numpy.std(cvscores)))

acc: 77.92%
acc: 68.83%
acc: 72.73%
acc: 64.94%
acc: 77.92%
acc: 35.06%
acc: 74.03%
acc: 68.83%
acc: 34.21%
acc: 72.37%
64.68% (+/- 15.50%)