数据科学和人工智能技术笔记十八、Keras

十八、Keras

作者：Chris Albon

译者：飞龙

协议：CC BY-NC-SA 4.0

添加丢弃

image

# 加载库
import numpy as np
from keras.datasets import imdb
from keras.preprocessing.text import Tokenizer
from keras import models
from keras import layers

# 设置随机数种子
np.random.seed(0)

# 使用 TensorFlow 后端

# 设置我们想要的特征数量
number_of_features = 1000

# 从电影评论数据加载数据和目标向量
(train_data, train_target), (test_data, test_target) = imdb.load_data(num_words=number_of_features)

# 将电影评论数据转换为单热编码的特征矩阵
tokenizer = Tokenizer(num_words=number_of_features)
train_features = tokenizer.sequences_to_matrix(train_data, mode='binary')
test_features = tokenizer.sequences_to_matrix(test_data, mode='binary')

在 Keras 中，我们可以通过在我们的网络架构中添加Dropout层来实现丢弃。每个Dropout层将丢弃每批中的一定数量的上一层单元，它是由用户定义的超参数。请记住，在 Keras 中，输入层被假定为第一层，而不是使用add添加。因此，如果我们想要将丢弃添加到输入层，我们在其中添加的图层是一个丢弃层。该层包含输入层单元的比例，即0.2和input_shape，用于定义观测数据的形状。接下来，在每个隐藏层之后添加一个带有0.5的丢弃层。

# 创建神经网络
network = models.Sequential()

# 为输入层添加丢弃层
network.add(layers.Dropout(0.2, input_shape=(number_of_features,)))

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu'))

# 为先前的隐藏层添加丢弃层
network.add(layers.Dropout(0.5))

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu'))

# 为先前的隐藏层添加丢弃层
network.add(layers.Dropout(0.5))

# 添加带有 Sigmoid 激活函数的全连接层
network.add(layers.Dense(units=1, activation='sigmoid'))

# 编译神经网络
network.compile(loss='binary_crossentropy', # 交叉熵
                optimizer='rmsprop', # RMSProp
                metrics=['accuracy']) # 准确率表现度量

# 训练神经网络
history = network.fit(train_features, # 特征
                      train_target, # 目标向量
                      epochs=3, # 迭代数量
                      verbose=0, # 无输出
                      batch_size=100, # 每个批量的观测数量
                      validation_data=(test_features, test_target)) # 用于评估的数据

卷积神经网络

import numpy as np
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.utils import np_utils
from keras import backend as K 

# 设置颜色通道值优先
K.set_image_data_format('channels_first')

# 设置种子
np.random.seed(0)

# 使用 TensorFlow 后端

# 设置图像信息
channels = 1
height = 28
width = 28

# 从 MNIST 数据集加载数据和目标
(train_data, train_target), (test_data, test_target) = mnist.load_data()

# 将训练图像数据的形状变为特征
train_data = train_data.reshape(train_data.shape[0], channels, height, width)

# 将测试图像数据的形状变为特征
test_data = test_data.reshape(test_data.shape[0], channels, height, width)

# 将像素缩放到 0 和 1 之间
train_features = train_data / 255
test_features = test_data / 255

# 将目标单热编码
train_target = np_utils.to_categorical(train_target)
test_target = np_utils.to_categorical(test_target)
number_of_classes = test_target.shape[1]

卷积神经网络（也称为 ConvNets）是一种流行的网络类型，已被证明在计算机视觉上非常有效（例如识别猫狗，飞机甚至热狗）。前馈神经网络完全可以在图像上使用，其中每个像素都是一个特征。但是，这样做时我们遇到了两个主要问题。

首先，前馈神经网络不考虑像素的空间结构。例如，在 10x10 的像素图像中，我们可以将其转换为 100 个像素特征的矢量，并且在这种情况下，前馈将认为第一特征（例如像素值）与第十个和第十一个特征具有相同的关系。然而，实际上，第 10 个特征表示第一个特征的远侧的像素，而第 11 个特征表示紧邻第一个特征的像素。

其次，与之相关，前馈神经网络学习特征中的全局关系而不是局部规律。在更实际的术语中，这意味着前馈神经网络无法检测到对象，无论它出现在图像中哪个位置。例如，假设我们正在训练神经网络识别面部，这些面部可能出现在图像的任何位置，从右上角到中间到左下角。卷积神经网络的威力就是它们处理这两个问题（和其他问题）的能力。

# 创建神经网络
network = Sequential()

# 添加卷积层，带有 64 个过滤器
# 5x5 窗口和 ReLU 激活函数
network.add(Conv2D(filters=64, kernel_size=(5, 5), input_shape=(channels, width, height), activation='relu'))

# 添加带有 2x2 窗口的最大池化层
network.add(MaxPooling2D(pool_size=(2, 2)))

# 添加丢弃层
network.add(Dropout(0.5))

# 添加展开输入的层
network.add(Flatten())

# 添加带有 ReLU 激活函数的 128 个单元的全连接层
network.add(Dense(128, activation='relu'))

# 添加丢弃层
network.add(Dropout(0.5))

# 添加带有 softmax 激活函数的全连接层
network.add(Dense(number_of_classes, activation='softmax'))

# 编译神经网络
network.compile(loss='categorical_crossentropy', # 交叉熵
                optimizer='rmsprop', # RMSProp
                metrics=['accuracy']) # 准确率表现度量

# 训练神经网络
network.fit(train_features, # 特征
            train_target, # 目标
            epochs=2, # 迭代数量
            verbose=0, # 不要在每个迭代之后打印描述
            batch_size=1000, # 每个批量的观测数
            validation_data=(test_features, test_target)) # 用于评估的数据

# <keras.callbacks.History at 0x103f9b8d0>

用于二分类的前馈神经网络

# 加载库
import numpy as np
from keras.datasets import imdb
from keras.preprocessing.text import Tokenizer
from keras import models
from keras import layers

# 设置随机数种子
np.random.seed(0)

# 使用 TensorFlow 后端

# 设置我们希望的特征数
number_of_features = 1000

# 从电影评论数据集加载数据和目标向量
(train_data, train_target), (test_data, test_target) = imdb.load_data(num_words=number_of_features)

# 将电影评论数据转换为单热编码的特征矩阵
tokenizer = Tokenizer(num_words=number_of_features)
train_features = tokenizer.sequences_to_matrix(train_data, mode='binary')
test_features = tokenizer.sequences_to_matrix(test_data, mode='binary')

因为这是二元分类问题，所以一种常见的选择是在单个单元的输出层中使用 sigmoid 激活函数。

# 创建神经网络
network = models.Sequential()

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu', input_shape=(number_of_features,)))

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu'))

# 添加带有 Sigmoid 激活函数的全连接层
network.add(layers.Dense(units=1, activation='sigmoid'))

# 编译神经网络
network.compile(loss='binary_crossentropy', # 交叉熵
                optimizer='rmsprop', # RMSProp
                metrics=['accuracy']) # 准确率表现度量

在Keras，我们使用fit方法训练我们的神经网络。需要定义六个重要参数。前两个参数是训练数据的特征和目标向量。

epochs参数定义训练数据时要使用的迭代数。 verbose确定在训练过程中输出多少信息，0没有输出，1输出进度条，2在每个迭代输出一行日志。 batch_size设置在更新参数之前通过网络传播的观测数。

最后，我们提供了一组用于评估模型的测试数据。这些测试特征和目标向量可以是validation_data的参数，它们将使用它们进行评估。或者，我们可以使用validation_split来定义，我们想要进行评估训练数据的哪一部分。

在 scikit-learn 中fit方法返回一个训练好的模型，但是在 Keras 中，fit方法返回一个History对象，包含每个迭代的损失值和表现指标。

# 训练神经网络
history = network.fit(train_features, # 特征
                      train_target, # 目标向量
                      epochs=3, # 迭代数量
                      verbose=1, # 每个迭代之后打印描述
                      batch_size=100, # 每个批量的观测数
                      validation_data=(test_features, test_target)) # 用于评估的数据

'''
Train on 25000 samples, validate on 25000 samples
Epoch 1/3
25000/25000 [==============================] - 2s - loss: 0.4215 - acc: 0.8102 - val_loss: 0.3385 - val_acc: 0.8558
Epoch 2/3
25000/25000 [==============================] - 1s - loss: 0.3241 - acc: 0.8646 - val_loss: 0.3261 - val_acc: 0.8626
Epoch 3/3
25000/25000 [==============================] - 2s - loss: 0.3120 - acc: 0.8700 - val_loss: 0.3268 - val_acc: 0.8593 
'''

用于多分类的前馈神经网络

# 加载库
import numpy as np
from keras.datasets import reuters
from keras.utils.np_utils import to_categorical
from keras.preprocessing.text import Tokenizer
from keras import models
from keras import layers

# 设置随机数种子
np.random.seed(0)

# 使用 TensorFlow 后端

# 设置我们希望的特征数
number_of_features = 5000

# 加载特征和目标数据
(train_data, train_target_vector), (test_data, test_target_vector) = reuters.load_data(num_words=number_of_features)

# 将特征数据转换为单热编码的特征矩阵
tokenizer = Tokenizer(num_words=number_of_features)
train_features = tokenizer.sequences_to_matrix(train_data, mode='binary')
test_features = tokenizer.sequences_to_matrix(test_data, mode='binary')

# 单热编码目标向量来创建目标矩阵
train_target = to_categorical(train_target_vector)
test_target = to_categorical(test_target_vector)

在这个例子中，我们使用适合于多类分类的损失函数，分类交叉熵损失函数，categorical_crossentropy。

# 创建神经网络
network = models.Sequential()

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=100, activation='relu', input_shape=(number_of_features,)))

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=100, activation='relu'))

# 添加带有 Softmax 激活函数的全连接层
network.add(layers.Dense(units=46, activation='softmax'))

# 编译神经网络
network.compile(loss='categorical_crossentropy', # 交叉熵
                optimizer='rmsprop', # RMSProp
                metrics=['accuracy']) # 准确率表现度量

# 训练神经网络
history = network.fit(train_features, # 特征
                      train_target, # 目标向量
                      epochs=3, # 三个迭代
                      verbose=0, # 没有输出
                      batch_size=100, # 每个批量的观测数
                      validation_data=(test_features, test_target)) # 用于评估的数据

用于回归的前馈神经网络

# 加载库
import numpy as np
from keras.preprocessing.text import Tokenizer
from keras import models
from keras import layers
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn import preprocessing

# 设置随机数种子
np.random.seed(0)

# 使用 TensorFlow 后端

# 生成特征矩阵和目标向量
features, target = make_regression(n_samples = 10000,
                                   n_features = 3,
                                   n_informative = 3,
                                   n_targets = 1,
                                   noise = 0.0,
                                   random_state = 0)

# 将我们的数据划分为训练和测试集
train_features, test_features, train_target, test_target = train_test_split(features, 
                                                                            target, 
                                                                            test_size=0.33, 
                                                                            random_state=0)

# 创建神经网络
network = models.Sequential()

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=32, activation='relu', input_shape=(train_features.shape[1],)))

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=32, activation='relu'))

# 添加没有激活函数的全连接层
network.add(layers.Dense(units=1))

因为我们正在训练回归，所以我们应该使用适当的损失函数和评估度量，在我们的例子中是均方误差：

$\operatorname {MSE}={\frac {1}{n}}\sum_{{i=1}}^{n}({\hat {y_{i}}}-y_{i})^{2}$

其中 $n$ 是观测数量， $y_{i}$ 是我们试图预测的目标 $y$ 对于观测 $i$ 的真实值， ${\hat{y_{i}}$ 是 $y_{i}$ 的模型预测值。

# 编译神经网络
network.compile(loss='mse', # MSE
                optimizer='RMSprop', # 优化算法
                metrics=['mse']) # MSE

# 训练神经网络
history = network.fit(train_features, # 特征
                      train_target, # 目标向量
                      epochs=10, # 迭代数量
                      verbose=0, # 无输出
                      batch_size=100, # 每个批量的观测数
                      validation_data=(test_features, test_target)) # 用于评估的数据

LSTM 循环神经网络

通常我们拥有我们想要分类的文本数据。虽然可以使用一种卷积网络，但我们将专注于一种更流行的选择：循环神经网络。循环神经网络的关键特征，是信息在网络中循环。这为循环神经网络提供了一种存储器，可用于更好地理解序列数据。流行的循环神经网络类型是长期短期记忆（LSTM）网络，它允许信息在网络中向后循环。

# 加载库
import numpy as np
from keras.datasets import imdb
from keras.preprocessing import sequence
from keras import models
from keras import layers

# 设置随机数种子
np.random.seed(0)

# 使用 TensorFlow 后端

# 设置我们希望的特征数
number_of_features = 1000

# 从电影评论数据集加载数据和目标向量
(train_data, train_target), (test_data, test_target) = imdb.load_data(num_words=number_of_features)

# 使用填充或者截断，使每个观测具有 400 个特征
train_features = sequence.pad_sequences(train_data, maxlen=400)
test_features = sequence.pad_sequences(test_data, maxlen=400)

# 查看第一个观测
print(train_data[0])

'''
[1, 14, 22, 16, 43, 530, 973, 2, 2, 65, 458, 2, 66, 2, 4, 173, 36, 256, 5, 25, 100, 43, 838, 112, 50, 670, 2, 9, 35, 480, 284, 5, 150, 4, 172, 112, 167, 2, 336, 385, 39, 4, 172, 2, 2, 17, 546, 38, 13, 447, 4, 192, 50, 16, 6, 147, 2, 19, 14, 22, 4, 2, 2, 469, 4, 22, 71, 87, 12, 16, 43, 530, 38, 76, 15, 13, 2, 4, 22, 17, 515, 17, 12, 16, 626, 18, 2, 5, 62, 386, 12, 8, 316, 8, 106, 5, 4, 2, 2, 16, 480, 66, 2, 33, 4, 130, 12, 16, 38, 619, 5, 25, 124, 51, 36, 135, 48, 25, 2, 33, 6, 22, 12, 215, 28, 77, 52, 5, 14, 407, 16, 82, 2, 8, 4, 107, 117, 2, 15, 256, 4, 2, 7, 2, 5, 723, 36, 71, 43, 530, 476, 26, 400, 317, 46, 7, 4, 2, 2, 13, 104, 88, 4, 381, 15, 297, 98, 32, 2, 56, 26, 141, 6, 194, 2, 18, 4, 226, 22, 21, 134, 476, 26, 480, 5, 144, 30, 2, 18, 51, 36, 28, 224, 92, 25, 104, 4, 226, 65, 16, 38, 2, 88, 12, 16, 283, 5, 16, 2, 113, 103, 32, 15, 16, 2, 19, 178, 32] 
'''

# 查看第一个观测
test_features[0]

'''
array([  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   1,  89,  27,   2,   2,  17, 199, 132,   5,   2,
        16,   2,  24,   8, 760,   4,   2,   7,   4,  22,   2,   2,  16,
         2,  17,   2,   7,   2,   2,   9,   4,   2,   8,  14, 991,  13,
       877,  38,  19,  27, 239,  13, 100, 235,  61, 483,   2,   4,   7,
         4,  20, 131,   2,  72,   8,  14, 251,  27,   2,   7, 308,  16,
       735,   2,  17,  29, 144,  28,  77,   2,  18,  12], dtype=int32) 
'''

# 创建神经网络
network = models.Sequential()

# 添加嵌入层
network.add(layers.Embedding(input_dim=number_of_features, output_dim=128))

# 添加带有 128 个单元的 LSTM 层
network.add(layers.LSTM(units=128))

# 添加带有 Sigmoid 激活函数的全连接层
network.add(layers.Dense(units=1, activation='sigmoid'))

# 编译神经网络
network.compile(loss='binary_crossentropy', # 交叉熵
                optimizer='Adam', # Adam 优化
                metrics=['accuracy']) # 准确率表现度量

# 训练神经网络
history = network.fit(train_features, # 特征
                      train_target, # 目标
                      epochs=3, # 迭代数量
                      verbose=0, # 不在每个迭代之后打印描述
                      batch_size=1000, # 每个批量的观测数
                      validation_data=(test_features, test_target)) # 用于评估的数据

神经网络的提前停止

# 加载库
import numpy as np
from keras.datasets import imdb
from keras.preprocessing.text import Tokenizer
from keras import models
from keras import layers
from keras.callbacks import EarlyStopping, ModelCheckpoint

# 设置随机数种子
np.random.seed(0)

# 使用 TensorFlow 后端

# 设置我们希望的特征数
number_of_features = 1000

# 从电影评论数据集加载数据和目标向量
(train_data, train_target), (test_data, test_target) = imdb.load_data(num_words=number_of_features)

# 将电影评论数据转换为单热编码的特征矩阵
tokenizer = Tokenizer(num_words=number_of_features)
train_features = tokenizer.sequences_to_matrix(train_data, mode='binary')
test_features = tokenizer.sequences_to_matrix(test_data, mode='binary')

# 创建神经网络
network = models.Sequential()

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu', input_shape=(number_of_features,)))

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu'))

# 添加带有 Sigmoid 激活函数的全连接层
network.add(layers.Dense(units=1, activation='sigmoid'))

# 编译神经网络
network.compile(loss='binary_crossentropy', # 交叉熵
                optimizer='rmsprop', # RMSProp
                metrics=['accuracy']) # 准确率表现度量

在 Keras 中，我们可以将提权停止实现为回调函数。回调是可以在训练过程的某些阶段应用的函数，例如在每个迭代结束时。具体来说，在我们的解决方案中，我们包含了EarlyStopping(monitor='val_loss', patience=2)，来定义我们想要监控每个迭代的测试（验证）损失，并且在两个迭代之后如果测试损失没有改善，训练就中断。但是，由于我们设置了patience=2，我们不会得到最好的模型，而是最佳模型两个时代后的模型。因此，可选地，我们可以包含第二个操作，ModelCheckpoint，它在每个检查点之后将模型保存到文件中（如果由于某种原因中断了多天的训练会话，这可能很有用。如果我们设置save_best_only = True，ModelCheckpoint将只保存最佳模型，这对我们有帮助。

# 将回调函数设置为提前停止训练，并保存到目前为止最好的模型
callbacks = [EarlyStopping(monitor='val_loss', patience=2),
             ModelCheckpoint(filepath='best_model.h5', monitor='val_loss', save_best_only=True)]

# 训练神经网络
history = network.fit(train_features, # 特征
                      train_target, # 目标向量
                      epochs=20, # 迭代数量
                      callbacks=callbacks, # 提前停止
                      verbose=0, # 每个迭代之后打印描述
                      batch_size=100, # 每个批量的观测数
                      validation_data=(test_features, test_target)) # 用于评估的数据

神经网络的参数正则化

# 加载库
import numpy as np
from keras.datasets import imdb
from keras.preprocessing.text import Tokenizer
from keras import models
from keras import layers
from keras import regularizers

# 设置随机数种子
np.random.seed(0)

# 使用 TensorFlow 后端

# 设置我们希望的特征数
number_of_features = 1000

# 从电影评论数据集加载数据和目标向量
(train_data, train_target), (test_data, test_target) = imdb.load_data(num_words=number_of_features)

# 将电影评论数据转换为单热编码的特征矩阵
tokenizer = Tokenizer(num_words=number_of_features)
train_features = tokenizer.sequences_to_matrix(train_data, mode='binary')
test_features = tokenizer.sequences_to_matrix(test_data, mode='binary')

在 Keras 中，我们可以通过添加带有kernel_regularizer = regularizers.l2(0.01)的层，来增加权重正则化。在这个例子中，0.01确定我们如何惩罚更高的参数值。

# 创建神经网络
network = models.Sequential()

# 添加带有 ReLU 激活函数和 L2 正则化的全连接层
network.add(layers.Dense(units=16, 
                         activation='relu', 
                         kernel_regularizer=regularizers.l2(0.01),
                         input_shape=(number_of_features,)))

# 添加带有 ReLU 激活函数和 L2 正则化的全连接层
network.add(layers.Dense(units=16, 
                         kernel_regularizer=regularizers.l2(0.01),
                         activation='relu'))

# 添加带有 Sigmoid 激活函数的全连接层
network.add(layers.Dense(units=1, activation='sigmoid'))# 编译神经网络
network.compile(loss='binary_crossentropy', # 交叉熵
                optimizer='rmsprop', # RMSProp
                metrics=['accuracy']) # 准确率表现度量

# 训练神经网络
history = network.fit(train_features, # 特征
                      train_target, # 目标向量
                      epochs=3, # 迭代数量
                      verbose=0, # 无输出
                      batch_size=100, # 每个批量的观测数
                      validation_data=(test_features, test_target)) # 用于评估的数据

为神经网络预处理数据

通常，神经网络的参数被初始化（即，创建）为小的随机数。当特征值远大于参数值时，神经网络通常表现不佳。此外，由于观测的特征值在通过单个单元时将被组合，因此所有特征具有相同的比例是很重要的。

由于这些原因，最佳实践（尽管并非总是必要的，例如当我们的特征都是二元时）是标准化每个特征，使得特征的值均值为 0 和标准差为 1。这可以使用 scikit-learn 的StandardScaler轻松完成。

# 加载库
from sklearn import preprocessing
import numpy as np

# 创建特征
features = np.array([[-100.1, 3240.1], 
                     [-200.2, -234.1], 
                     [5000.5, 150.1], 
                     [6000.6, -125.1], 
                     [9000.9, -673.1]])

# 创建缩放器
scaler = preprocessing.StandardScaler()

# 转换特征
features_standardized = scaler.fit_transform(features)

# 展示特征
features_standardized

'''
array([[-1.12541308,  1.96429418],
       [-1.15329466, -0.50068741],
       [ 0.29529406, -0.22809346],
       [ 0.57385917, -0.42335076],
       [ 1.40955451, -0.81216255]]) 
'''

# 打印均值和标准差
print('Mean:', round(features_standardized[:,0].mean()))
print('Standard deviation:', features_standardized[:,0].std())

'''
Mean: 0.0
Standard deviation: 1.0 
'''

保存模型的训练过程

# 加载库
import numpy as np
from keras.datasets import imdb
from keras.preprocessing.text import Tokenizer
from keras import models
from keras import layers
from keras.callbacks import ModelCheckpoint

# 设置随机数种子
np.random.seed(0)

# 设置我们希望的特征数
number_of_features = 1000

# 从电影评论数据集加载数据和目标向量
(train_data, train_target), (test_data, test_target) = imdb.load_data(num_words=number_of_features)

# 将电影评论数据转换为单热编码的特征矩阵
tokenizer = Tokenizer(num_words=number_of_features)
train_features = tokenizer.sequences_to_matrix(train_data, mode='binary')
test_features = tokenizer.sequences_to_matrix(test_data, mode='binary')

# 创建神经网络
network = models.Sequential()

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu', input_shape=(number_of_features,)))

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu'))

# 添加带有 Sigmoid 激活函数的全连接层
network.add(layers.Dense(units=1, activation='sigmoid'))

# 编译神经网络
network.compile(loss='binary_crossentropy', # 交叉熵
                optimizer='rmsprop', # RMSProp
                metrics=['accuracy']) # 准确率表现度量

在每个得带之后，ModelCheckpoint将模型保存到filepath参数指定的位置。如果我们只包含一个文件名（例如models.hdf5），那么每个迭代都会用最新的模型覆盖该文件。如果我们只想根据某些损失函数的表现保存最佳模型，我们可以设置save_best_only = True和monitor ='val_loss'，如果模型的测试损失比以前更差，则不覆盖文件。或者，我们可以将每个迭代的模型保存到自己的文件，方法是将迭代编号和测试损失得分包含在文件名本身中。例如，如果我们将filepath设置为model_{epoch:02d}_{val_loss:.2f}.hdf5，那么模型的文件名称为 model_10_0.35.hdf5（注意迭代编号的索引从 0 开始），它包含第 11 个迭代之后的测试损失值 0.33。

# 将回调函数设置为提前停止训练
# 并保存目前为止最好的模型
checkpoint = [ModelCheckpoint(filepath='models.hdf5')]

# 训练神经网络
history = network.fit(train_features, # 特征
                      train_target, # 目标向量
                      epochs=3, # 迭代数量
                      callbacks=checkpoint, # Checkpoint
                      verbose=0, # 无输出
                      batch_size=100, # 每个批量的观测数
                      validation_data=(test_features, test_target)) # 用于评估的数据

调优神经网络超参数

# 加载库
import numpy as np
from keras import models
from keras import layers
from keras.wrappers.scikit_learn import KerasClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import make_classification

# 设置随机数种子
np.random.seed(0)

# 使用 TensorFlow 后端

# 特征数
number_of_features = 100

# 生成特征矩阵和目标向量
features, target = make_classification(n_samples = 10000,
                                       n_features = number_of_features,
                                       n_informative = 3,
                                       n_redundant = 0,
                                       n_classes = 2,
                                       weights = [.5, .5],
                                       random_state = 0)

# 创建返回已编译网络的函数
def create_network(optimizer='rmsprop'):

    # 创建神经网络
    network = models.Sequential()

    # 添加带有 ReLU 激活函数的全连接层
    network.add(layers.Dense(units=16, activation='relu', input_shape=(number_of_features,)))

    # 添加带有 ReLU 激活函数的全连接层
    network.add(layers.Dense(units=16, activation='relu'))

    # 添加带有 Sigmoid 激活函数的全连接层
    network.add(layers.Dense(units=1, activation='sigmoid'))

    # 编译神经网络
    network.compile(loss='binary_crossentropy', # 交叉熵
                    optimizer=optimizer, # 优化器
                    metrics=['accuracy']) # 准确率表现度量

    # 返回编译的网络
    return network

# 包装 Keras 模型，使其能够用于 sklearn
neural_network = KerasClassifier(build_fn=create_network, verbose=0)

# 创建超参数空间
epochs = [5, 10]
batches = [5, 10, 100]
optimizers = ['rmsprop', 'adam']

# 创建超参数选项
hyperparameters = dict(optimizer=optimizers, epochs=epochs, batch_size=batches)

# 创建网格搜索
grid = GridSearchCV(estimator=neural_network, param_grid=hyperparameters)

# 拟合网格搜索
grid_result = grid.fit(features, target)

# 查看神经网络的最佳超参数
grid_result.best_params_

# {'batch_size': 5, 'epochs': 5, 'optimizer': 'rmsprop'}

可视化损失历史

# 加载库
import numpy as np
from keras.datasets import imdb
from keras.preprocessing.text import Tokenizer
from keras import models
from keras import layers
import matplotlib.pyplot as plt

# 设置随机数种子
np.random.seed(0)

# 使用 TensorFlow 后端

# 设置我们希望的特征数
number_of_features = 10000

# 从电影评论数据集加载数据和目标向量
(train_data, train_target), (test_data, test_target) = imdb.load_data(num_words=number_of_features)

# 将电影评论数据转换为单热编码的特征矩阵
tokenizer = Tokenizer(num_words=number_of_features)
train_features = tokenizer.sequences_to_matrix(train_data, mode='binary')
test_features = tokenizer.sequences_to_matrix(test_data, mode='binary')

# 创建神经网络
network = models.Sequential()

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu', input_shape=(number_of_features,)))

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu'))

# 添加带有 Sigmoid 激活函数的全连接层
network.add(layers.Dense(units=1, activation='sigmoid'))

# 编译神经网络
network.compile(loss='binary_crossentropy', # 交叉熵
                optimizer='rmsprop', # RMSProp
                metrics=['accuracy']) # 准确率表现度量

# 训练神经网络
history = network.fit(train_features, # 特征
                      train_target, # Target
                      epochs=15, # 迭代数量
                      verbose=0, # 无输出
                      batch_size=1000, # 每个批量的观测数
                      validation_data=(test_features, test_target)) # 用于评估的数据

# 得到训练和测试损失历史
training_loss = history.history['loss']
test_loss = history.history['val_loss']

# 创建迭代数量
epoch_count = range(1, len(training_loss) + 1)

# 可视化损失历史
plt.plot(epoch_count, training_loss, 'r--')
plt.plot(epoch_count, test_loss, 'b-')
plt.legend(['Training Loss', 'Test Loss'])
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.show();

png

可视化神经网络架构

# 加载库
from keras import models
from keras import layers
from IPython.display import SVG
from keras.utils.vis_utils import model_to_dot
from keras.utils import plot_model

# 使用 TensorFlow 后端

# 创建神经网络
network = models.Sequential()

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu', input_shape=(10,)))

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu'))

# 添加带有 Sigmoid 激活函数的全连接层
network.add(layers.Dense(units=1, activation='sigmoid'))

# 可视化网络架构
SVG(model_to_dot(network, show_shapes=True).create(prog='dot', format='svg'))

[图片上传失败...(image-801fce-1546063438772)]

# 将绘图保存到文件
plot_model(network, show_shapes=True, to_file='network.png')

可视化表现历史

# 加载库
import numpy as np
from keras.datasets import imdb
from keras.preprocessing.text import Tokenizer
from keras import models
from keras import layers
import matplotlib.pyplot as plt

# 设置随机数种子
np.random.seed(0)

# 使用 TensorFlow 后端

# 设置我们希望的特征数
number_of_features = 10000

# 从电影评论数据集加载数据和目标向量
(train_data, train_target), (test_data, test_target) = imdb.load_data(num_words=number_of_features)

# 将电影评论数据转换为单热编码的特征矩阵
tokenizer = Tokenizer(num_words=number_of_features)
train_features = tokenizer.sequences_to_matrix(train_data, mode='binary')
test_features = tokenizer.sequences_to_matrix(test_data, mode='binary')

# 创建神经网络
network = models.Sequential()

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu', input_shape=(number_of_features,)))

# 添加带有 ReLU 激活函数的全连接层
network.add(layers.Dense(units=16, activation='relu'))

# 添加带有 Sigmoid 激活函数的全连接层
network.add(layers.Dense(units=1, activation='sigmoid'))

# 编译神经网络
network.compile(loss='binary_crossentropy', # 交叉熵
                optimizer='rmsprop', # RMSProp
                metrics=['accuracy']) # 准确率表现度量

# 训练神经网络
history = network.fit(train_features, # 特征
                      train_target, # Target
                      epochs=15, # 迭代数量
                      verbose=0, # 无输出
                      batch_size=1000, # 每个批量的观测数
                      validation_data=(test_features, test_target)) # 用于评估的数据

具体来说，我们展示神经网络在训练和测试集上的每个迭代的准确率得分。

# 获取训练和测试准确率历史
training_accuracy = history.history['acc']
test_accuracy = history.history['val_acc']

# 创建迭代数量
epoch_count = range(1, len(training_accuracy) + 1)

# 可视化准确率历史
plt.plot(epoch_count, training_accuracy, 'r--')
plt.plot(epoch_count, test_accuracy, 'b-')
plt.legend(['Training Accuracy', 'Test Accuracy'])
plt.xlabel('Epoch')
plt.ylabel('Accuracy Score')
plt.show();

png

神经网络的 K 折交叉验证

如果我们拥有较小的数据，那么利用 k 折叠交叉验证可以最大化我们评估神经网络表现的能力。这在 Keras 中是可能的，因为我们可以“包装”任何神经网络，使其可以使用 scikit-learn 中可用的评估功能，包括 k-fold 交叉验证。为此，我们首先要创建一个返回已编译神经网络的函数。接下来我们使用KerasClassifier（这是分类器的情况，如果我们有一个回归器，我们可以使用KerasRegressor）来包装模型，以便 scikit-learn 可以使用它。在此之后，我们可以像任何其他 scikit-learn 学习算法一样使用我们的神经网络（例如随机森林，逻辑回归）。在我们的解决方案中，我们使用cross_val_score在我们的神经网络上运行三折交叉验证。

# 加载库
import numpy as np
from keras import models
from keras import layers
from keras.wrappers.scikit_learn import KerasClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification

# 设置随机数种子
np.random.seed(0)

# 使用 TensorFlow 后端

# 特征数
number_of_features = 100

# 生成特征矩阵和目标向量
features, target = make_classification(n_samples = 10000,
                                       n_features = number_of_features,
                                       n_informative = 3,
                                       n_redundant = 0,
                                       n_classes = 2,
                                       weights = [.5, .5],
                                       random_state = 0)

# 创建返回已编译网络的函数
def create_network():

    # 创建神经网络
    network = models.Sequential()

    # 添加带有 ReLU 激活函数的全连接层
    network.add(layers.Dense(units=16, activation='relu', input_shape=(number_of_features,)))

    # 添加带有 ReLU 激活函数的全连接层
    network.add(layers.Dense(units=16, activation='relu'))

    # 添加带有 Sigmoid 激活函数的全连接层
    network.add(layers.Dense(units=1, activation='sigmoid'))

    # 编译神经网络
    network.compile(loss='binary_crossentropy', # 交叉熵
                    optimizer='rmsprop', # RMSProp
                    metrics=['accuracy']) # 准确率表现度量

    # 返回编译的网络
    return network

# 包装 Keras 模型，使其能够用于 scikit-learn
neural_network = KerasClassifier(build_fn=create_network, 
                                 epochs=10, 
                                 batch_size=100, 
                                 verbose=0)

# 使用三折交叉验证评估神经网络
cross_val_score(neural_network, features, target, cv=3)

# array([ 0.90491901,  0.77827782,  0.87038704])

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 211,265评论 6赞 490
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 90,078评论 2赞 385
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 156,852评论 0赞 347
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 56,408评论 1赞 283
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 65,445评论 5赞 384
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,772评论 1赞 290
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,921评论 3赞 406
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,688评论 0赞 266
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,130评论 1赞 303
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,467评论 2赞 325
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,617评论 1赞 340
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,276评论 4赞 329
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,882评论 3赞 312
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,740评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,967评论 1赞 265
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,315评论 2赞 360
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,486评论 2赞 348

数据科学和人工智能技术笔记 十八、Keras