Keras - 模型编译

前面我们学习了如何使用Sequential和Functional API创建模型的基础知识。本章解释如何编译模型。编译是创建模型的最后一步。编译完成后，我们可以进入训练阶段。

让我们学习一些有助于更好地理解编译过程的概念。

损失函数 (Loss)

在机器学习中，损失函数用于查找学习过程中的误差或偏差。Keras在模型编译过程中需要损失函数。

Keras在losses模块中提供了相当多的损失函数，它们如下：

均方误差 (mean_squared_error)
平均绝对误差 (mean_absolute_error)
平均绝对百分比误差 (mean_absolute_percentage_error)
均方对数误差 (mean_squared_logarithmic_error)
平方铰链损失 (squared_hinge)
铰链损失 (hinge)
分类铰链损失 (categorical_hinge)
对数余弦损失 (logcosh)
Huber损失 (huber_loss)
分类交叉熵 (categorical_crossentropy)
稀疏分类交叉熵 (sparse_categorical_crossentropy)
二元交叉熵 (binary_crossentropy)
Kullback-Leibler 散度 (kullback_leibler_divergence)
泊松损失 (poisson)
余弦相似度 (cosine_proximity)
is_categorical_crossentropy

所有上述损失函数都接受两个参数：

y_true - 真实标签（张量）
y_pred - 预测值，形状与y_true相同

使用损失函数前，请按如下所示导入losses模块：

from keras import losses

优化器 (Optimizer)

在机器学习中，优化是一个重要的过程，它通过比较预测值和损失函数来优化输入权重。Keras提供了一些优化器，它们位于optimizers模块中，如下所示：

SGD - 随机梯度下降优化器。

keras.optimizers.SGD(learning_rate = 0.01, momentum = 0.0, nesterov = False)

RMSprop - RMSProp 优化器。

keras.optimizers.RMSprop(learning_rate = 0.001, rho = 0.9)

Adagrad - Adagrad 优化器。

keras.optimizers.Adagrad(learning_rate = 0.01)

Adadelta - Adadelta 优化器。

keras.optimizers.Adadelta(learning_rate = 1.0, rho = 0.95)

Adam - Adam 优化器。

keras.optimizers.Adam(
   learning_rate = 0.001, beta_1 = 0.9, beta_2 = 0.999, amsgrad = False
)

Adamax - 来自Adam的Adamax优化器。

keras.optimizers.Adamax(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

Nadam - Nesterov Adam 优化器。

keras.optimizers.Nadam(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

使用优化器前，请按如下所示导入optimizers模块：

from keras import optimizers

指标 (Metrics)

在机器学习中，指标用于评估模型的性能。它类似于损失函数，但不用于训练过程。Keras在metrics模块中提供了相当多的指标，它们如下：

准确率 (accuracy)
二元准确率 (binary_accuracy)
分类准确率 (categorical_accuracy)
稀疏分类准确率 (sparse_categorical_accuracy)
top_k 分类准确率 (top_k_categorical_accuracy)
稀疏 top_k 分类准确率 (sparse_top_k_categorical_accuracy)
余弦相似度 (cosine_proximity)
克隆指标 (clone_metric)

与损失函数类似，指标也接受以下两个参数：

y_true - 真实标签（张量）
y_pred - 预测值，形状与y_true相同

使用指标前，请按如下所示导入metrics模块：

from keras import metrics

编译模型

Keras模型提供了一个方法compile()来编译模型。compile()方法的参数及其默认值如下所示：

compile(
   optimizer, 
   loss = None, 
   metrics = None, 
   loss_weights = None, 
   sample_weight_mode = None, 
   weighted_metrics = None, 
   target_tensors = None
)

重要的参数如下：

损失函数
优化器 (Optimizer)
指标

编译模型的示例代码如下：

from keras import losses 
from keras import optimizers 
from keras import metrics 

model.compile(loss = 'mean_squared_error',  
   optimizer = 'sgd', metrics = [metrics.categorical_accuracy])

其中：

损失函数设置为mean_squared_error
优化器设置为sgd
指标设置为metrics.categorical_accuracy

模型训练

模型使用NumPy数组通过fit()进行训练。此fit函数的主要目的是用于评估模型的训练情况。这也可用于绘制模型性能图。其语法如下：

model.fit(X, y, epochs = , batch_size = )

这里：

X, y - 用于评估数据的元组。
epochs - 训练期间需要评估模型的次数。
batch_size - 训练实例数。

让我们来看一个使用numpy随机数据的简单示例来理解这个概念。

创建数据

让我们使用以下命令使用numpy创建x和y的随机数据：

import numpy as np 

x_train = np.random.random((100,4,8)) 
y_train = np.random.random((100,10))

现在，创建随机验证数据：

x_val = np.random.random((100,4,8)) 
y_val = np.random.random((100,10))

创建模型

让我们创建一个简单的顺序模型：

from keras.models import Sequential model = Sequential()

添加层

创建要添加到模型的层：

from keras.layers import LSTM, Dense 

# add a sequence of vectors of dimension 16 
model.add(LSTM(16, return_sequences = True)) 
model.add(Dense(10, activation = 'softmax'))

编译模型

现在模型已定义。您可以使用以下命令进行编译：

model.compile(
   loss = 'categorical_crossentropy', optimizer = 'sgd', metrics = ['accuracy']
)

应用fit()

现在我们应用fit()函数来训练我们的数据：

model.fit(x_train, y_train, batch_size = 32, epochs = 5, validation_data = (x_val, y_val))

创建多层感知器人工神经网络 (Multi-Layer Perceptron ANN)

我们已经学习了如何创建、编译和训练Keras模型。

让我们运用我们的知识，创建一个基于简单的MPL的人工神经网络。

数据集模块 (Dataset module)

在创建模型之前，我们需要选择一个问题，需要收集所需的数据并将数据转换为NumPy数组。收集数据后，我们可以准备模型并使用收集到的数据进行训练。数据收集是机器学习中最困难的阶段之一。Keras提供了一个特殊的模块datasets，用于下载在线机器学习数据以进行训练。它从在线服务器获取数据，处理数据并将数据作为训练集和测试集返回。让我们检查Keras数据集模块提供的数据。该模块中提供的数据如下：

CIFAR10 小型图像分类
CIFAR100 小型图像分类
IMDB 电影评论情感分类
路透社新闻主题分类
MNIST 手写数字数据库
Fashion-MNIST 时尚服装数据库
波士顿房价回归数据集

让我们使用MNIST 手写数字数据库 (或minst) 作为我们的输入。minst包含60,000张28x28的灰度图像。它包含10个数字。它还包含10,000张测试图像。

可以使用以下代码加载数据集：

from keras.datasets import mnist 

(x_train, y_train), (x_test, y_test) = mnist.load_data()

其中

第1行从keras数据集模块导入minst。
第3行调用load_data函数，该函数将从在线服务器获取数据，并将其作为2个元组返回。第一个元组(x_train, y_train)表示形状为(样本数, 28, 28)的训练数据及其形状为(样本数,)的数字标签。第二个元组(x_test, y_test)表示形状相同的测试数据。

其他数据集也可以使用类似的API获取，并且每个API返回的数据都类似，只是数据的形状不同。数据的形状取决于数据的类型。

创建模型

让我们选择一个简单的多层感知器 (MLP)，如下所示，并尝试使用Keras创建模型。

模型的核心特征如下：

输入层包含784个值 (28 x 28 = 784)。
第一个隐藏层Dense包含512个神经元和“relu”激活函数。
第二个隐藏层Dropout的值为0.2。
第三个隐藏层，同样是Dense，包含512个神经元和“relu”激活函数。
第四个隐藏层Dropout的值为0.2。
第五个也是最后一层包含10个神经元和“softmax”激活函数。
使用categorical_crossentropy作为损失函数。
使用RMSprop()作为优化器。
使用accuracy作为指标。
使用128作为批量大小。
使用20作为轮数。

步骤1 - 导入模块

让我们导入必要的模块。

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout 
from keras.optimizers import RMSprop 
import numpy as np

步骤2 - 加载数据

让我们导入mnist数据集。

(x_train, y_train), (x_test, y_test) = mnist.load_data()

步骤3 - 处理数据

让我们根据我们的模型更改数据集，以便它可以馈送到我们的模型中。

x_train = x_train.reshape(60000, 784) 
x_test = x_test.reshape(10000, 784) 
x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 

y_train = keras.utils.to_categorical(y_train, 10) 
y_test = keras.utils.to_categorical(y_test, 10)

其中

reshape用于将输入从(28, 28)元组重塑为(784,)。
to_categorical用于将向量转换为二元矩阵。

步骤4 - 创建模型

让我们创建实际的模型。

model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu'))
model.add(Dropout(0.2)) 
model.add(Dense(10, activation = 'softmax'))

步骤5 - 编译模型

让我们使用选择的损失函数、优化器和指标来编译模型。

model.compile(loss = 'categorical_crossentropy',     
   optimizer = RMSprop(), 
   metrics = ['accuracy'])

步骤6 - 训练模型

让我们使用fit()方法训练模型。

history = model.fit(
   x_train, y_train, 
   batch_size = 128, 
   epochs = 20, 
   verbose = 1, 
   validation_data = (x_test, y_test)
)

最终想法

我们已经创建了模型，加载了数据，并将数据训练到模型中。我们仍然需要评估模型并预测未知输入的输出，这将在接下来的章节中学习。

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout 
from keras.optimizers import RMSprop 
import numpy as np 

(x_train, y_train), (x_test, y_test) = mnist.load_data() 

x_train = x_train.reshape(60000, 784) 
x_test = x_test.reshape(10000, 784) 
x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 

y_train = keras.utils.to_categorical(y_train, 10) 
y_test = keras.utils.to_categorical(y_test, 10) 

model = Sequential() 
model.add(Dense(512, activation='relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2)) 
model.add(Dense(10, activation = 'softmax'))
model.compile(loss = 'categorical_crossentropy', 
   optimizer = RMSprop(), 
   metrics = ['accuracy']) 

history = model.fit(x_train, y_train, 
   batch_size = 128, epochs = 20, verbose = 1, validation_data = (x_test, y_test))

执行应用程序将给出以下内容作为输出：

Train on 60000 samples, validate on 10000 samples Epoch 1/20 
60000/60000 [==============================] - 7s 118us/step - loss: 0.2453 
- acc: 0.9236 - val_loss: 0.1004 - val_acc: 0.9675 Epoch 2/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.1023 
- acc: 0.9693 - val_loss: 0.0797 - val_acc: 0.9761 Epoch 3/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.0744 
- acc: 0.9770 - val_loss: 0.0727 - val_acc: 0.9791 Epoch 4/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.0599 
- acc: 0.9823 - val_loss: 0.0704 - val_acc: 0.9801 Epoch 5/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0504 
- acc: 0.9853 - val_loss: 0.0714 - val_acc: 0.9817 Epoch 6/20 
60000/60000 [==============================] - 7s 111us/step - loss: 0.0438 
- acc: 0.9868 - val_loss: 0.0845 - val_acc: 0.9809 Epoch 7/20 
60000/60000 [==============================] - 7s 114us/step - loss: 0.0391 
- acc: 0.9887 - val_loss: 0.0823 - val_acc: 0.9802 Epoch 8/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0364 
- acc: 0.9892 - val_loss: 0.0818 - val_acc: 0.9830 Epoch 9/20 
60000/60000 [==============================] - 7s 113us/step - loss: 0.0308 
- acc: 0.9905 - val_loss: 0.0833 - val_acc: 0.9829 Epoch 10/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0289 
- acc: 0.9917 - val_loss: 0.0947 - val_acc: 0.9815 Epoch 11/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0279 
- acc: 0.9921 - val_loss: 0.0818 - val_acc: 0.9831 Epoch 12/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0260 
- acc: 0.9927 - val_loss: 0.0945 - val_acc: 0.9819 Epoch 13/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0257 
- acc: 0.9931 - val_loss: 0.0952 - val_acc: 0.9836 Epoch 14/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0229 
- acc: 0.9937 - val_loss: 0.0924 - val_acc: 0.9832 Epoch 15/20 
60000/60000 [==============================] - 7s 115us/step - loss: 0.0235 
- acc: 0.9937 - val_loss: 0.1004 - val_acc: 0.9823 Epoch 16/20 
60000/60000 [==============================] - 7s 113us/step - loss: 0.0214 
- acc: 0.9941 - val_loss: 0.0991 - val_acc: 0.9847 Epoch 17/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0219 
- acc: 0.9943 - val_loss: 0.1044 - val_acc: 0.9837 Epoch 18/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0190 
- acc: 0.9952 - val_loss: 0.1129 - val_acc: 0.9836 Epoch 19/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0197 
- acc: 0.9953 - val_loss: 0.0981 - val_acc: 0.9841 Epoch 20/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0198 
- acc: 0.9950 - val_loss: 0.1215 - val_acc: 0.9828

打印页面