Keras 简明教程

Keras - Model Compilation

我们之前已经学习了如何使用顺序 API 和函数 API 来创建模型的基础。本章将讲解如何编译模型。编译是创建模型的最后一步。编译完成后，我们就可以继续进入训练阶段了。

让我们学习一些概念，以更好地了解编译过程。

Loss

在机器学习中， 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_loss
categorical_crossentropy
sparse_categorical_crossentropy
binary_crossentropy
kullback_leibler_divergence
poisson
cosine_proximity
is_categorical_crossentropy

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

y_true − 真实标签作为张量
y_pred − 与 y_true 形状相同的预测

在使用损失函数之前导入损失模块，如下所示：

from keras import losses

Optimizer

在机器学习中， Optimization 是一个通过比较预测与损失函数来优化输入权重的重要过程。Keras 提供了很多优化模块，即优化器，如下所示：

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)

在使用优化器之前导入优化器模块，如下所示：

from keras import optimizers

Metrics

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

accuracy
binary_accuracy
categorical_accuracy
sparse_categorical_accuracy
top_k_categorical_accuracy
sparse_top_k_categorical_accuracy
cosine_proximity
clone_metric

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

y_true − 真实标签作为张量
y_pred − 与 y_true 形状相同的预测

在使用指标之前，导入指标模块，如下所示 −

from keras import metrics

Compile the model

Keras 模型提供 compile() 方法来编译模型。 compile() 方法的参数和默认值为以下内容

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

重要参数如下 −

loss function
Optimizer
metrics

编译模式的示例代码如下 −

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

Model Training

模型通过 fit() 使用 NumPy 数组进行训练。此拟合函数的主要目的是根据训练评估您的模型。它还可以用于绘制模型性能。它具有以下语法 −

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

在此，

X, y − 它是一个元组，用于评估您的数据。
epochs − 在培训期间需要对模型进行评估的次数。
batch_size − training instances.

让我们以上述概念为例，使用 numpy 随机数据。

Create data

让我们借助下面提到的命令使用 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))

Create model

让我们创建简单的顺序模型 −

from keras.models import Sequential model = Sequential()

Add layers

创建图层以添加模型 −

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'))

compile model

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

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

Apply fit()

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

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

Create a Multi-Layer Perceptron ANN

我们已经学会创建、编译和训练 Keras 模型。

让我们应用所学知识并创建一个基于 MPL 的简单神经网络。

Dataset module

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

CIFAR10 small image classification
CIFAR100 small image classification
IMDB 电影评论情感分类
Reuters newswire topics classification
手写数字的 MNIST 数据库
时尚文章的 Fashion-MNIST 数据库
波士顿住房价格回归数据集

让我们使用 MNIST database of handwritten digits （或 minst）作为我们的输入。minst 是 60,000 个 28x28 灰度图像的集合。它包含 10 位数字。它还包含 10,000 个测试图像。

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

from keras.datasets import mnist

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

其中

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

还可以使用类似的 API 获取其他数据集，每个 API 也返回类似的数据，但数据形状除外。数据的形状取决于数据类型。

Create a model

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

该模型的核心功能如下：

输入层由 784 个值（28 x 28 = 784）组成。
第一个隐藏层 Dense 由 512 个神经元组成，并使用“relu”激活函数。
第二个隐藏层 Dropout 的值为 0.2。
第三个隐藏层再次为 Dense，由 512 个神经元组成，并使用“relu”激活函数。
第四个隐藏层 Dropout 的值为 0.2。
第五个也是最后一个层由 10 个神经元组成，并使用“softmax”激活函数。
将 categorical_crossentropy 用作损失函数。
Use RMSprop() as Optimizer.
Use accuracy as metrics.
使用 128 作为批量大小。
Use 20 as epochs.

Step 1 − Import the modules

让我们导入必需的模块。

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

Step 2 − Load data

让我们导入 mnist 数据集。

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

Step 3 − Process the 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)

其中

reshape 用于将输入从 (28, 28) 元组重新整形为 (784, )
to_categorical 用于将向量转换为二进制矩阵

Step 4 − Create the model

让我们创建实际模型。

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'))

Step 5 − Compile the model

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

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

Step 6 − Train the model

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

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

Final thoughts

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

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