介绍 Keras

本章向读者介绍Keras，它是一个功能强大、内容抽象的图书馆。              构建深度学习网络的基础。Keras提供的构建块使用              （前面已经介绍）以及张量流（它是用于构建计算的              图形、自动导出渐变等）。keras同时支持CPU和GPU计算，是一个              快速原型化想法的好工具。              我们将介绍Keras提供的一些关键构建块，然后构建CNN和LSTM              使用KRAS。              让我们从一个简单的单层神经网络开始。清单7-1提供了代码和图7-1              给出了计算图。应注意以下几点：

1。模型是使用顺序结构定义的，它允许用户              添加/配置层。              

2。使用此功能，用户可以添加一个或多个层并构建网络。              致密层基本上是一个完全连接的层（导致矢量矩阵或              向量向量积），我们之前已经看到过。            

3。当第一层              定义。在这种情况下，模型将采用维数为500的输入，并且              生成维度1的输出。              

4。在这一层之后，我们添加了一个**函数，在本例中是一个乙状结肠。            

 5。一旦定义了模型，就需要显式编译，此时，我们              提供损失函数、优化算法和我们需要的其他指标              计算。              

6。考虑到手头的任务，需要选择适当的损失函数；在此              如果我们有一个二进制分类问题，我们选择二进制              

交叉熵              

7。需要选择适当的优化算法，这通常是              随机梯度下降的变化（在后面的章节中包含）。            

 8。编译后，我们可以通过提供数据和评估模型来适应模型。 

import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.utils.visualize_util import plot
model = Sequential()
model.add(Dense(1, input_dim=500))
model.add(Activation(activation='sigmoid'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])
data = np.random.random((1000, 500))
labels = np.random.randint(2, size=(1000, 1))
score = model.evaluate(data,labels, verbose=0)
print "Before Training:", zip(model.metrics_names, score)
model.fit(data, labels, nb_epoch=10, batch_size=32, verbose=0)
score = model.evaluate(data,labels, verbose=0)
print "After Training:", zip(model.metrics_names, score)
plot(model, to_file='s1.png', show_shapes=True)
# Before Training: [('loss', 0.76832762384414677), ('acc', 0.50700000000000001)]
# After Training: [('loss', 0.67270196056365972), ('acc', 0.56299999999999994)]

Figure 7-1. Single Layer Neural Network (Binary Classification)

import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.utils.visualize_util import plot
model = Sequential()
model.add(Dense(32, input_dim=500))
model.add(Activation(activation='sigmoid'))
model.add(Dense(1))
model.add(Activation(activation='sigmoid'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])
data = np.random.random((1000, 500))
labels = np.random.randint(2, size=(1000, 1))
score = model.evaluate(data,labels, verbose=0)
print "Before Training:", zip(model.metrics_names, score)
model.fit(data, labels, nb_epoch=10, batch_size=32, verbose=0)
score = model.evaluate(data,labels, verbose=0)
print "After Training:", zip(model.metrics_names, score)
plot(model, to_file='s2.png', show_shapes=True)
# Before Training: [('loss', 0.73012506151199341), ('acc', 0.51200000000000001)]
# After Training: [('loss', 0.6588478517532349), ('acc', 0.52700000000000002)]

现在让我们来看一个两层的神经网络。清单7-2提供了代码，图7-2给出了              计算图。应注意以下几点：            

 1。使用顺序构造定义模型。              

2。我们添加第一层，使用稠密，并指定输入维数。在这              如果模型的输入为维数500，则输出为              尺寸32。             3。我们定义一个**功能，选择乙状结肠。              

4。然后我们用稠密定义第二层。这里我们定义输出              维度为1。但是请注意，我们不需要定义输入              维度，因为它与              前一层。              

5。和以前一样，我们定义优化和损失函数，编译、培训和评估。

图7-2。双层神经网络（二进制分类）              现在让我们来看一个用于多类分类的两层神经网络。清单7-3提供了代码              图7-3给出了计算图。应注意以下几点：              

1。使用顺序构造定义模型。              

2。我们添加第一层，使用稠密，并指定输入维数。在这              如果模型的输入为维数500，则输出为              尺寸32。             3。我们定义一个**功能，选择乙状结肠。              

4。然后我们用稠密定义第二层。这里我们定义输出              尺寸为10。请注意，这正好等于类的数目              我们的数据集中有。              

5。接下来，我们使用SoftMax**和分类熵作为损失。              功能（前面一章介绍了为什么这是一个好的选择）。            

6。我们像以前一样编译、培训和评估模型。 

import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.utils.np_utils import to_categorical
from keras.utils.visualize_util import plot
model = Sequential()
model.add(Dense(32, input_dim=500))
model.add(Activation(activation='relu'))
model.add(Dense(10))
model.add(Activation(activation='softmax'))
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['categorical_
accuracy'])
data = np.random.random((1000, 500))
labels = to_categorical(np.random.randint(10, size=(1000, 1)))
score = model.evaluate(data,labels, verbose=0)
print "Before Training:", zip(model.metrics_names, score)
model.fit(data, labels, nb_epoch=10, batch_size=32, verbose=0)
score = model.evaluate(data,labels, verbose=0)
print "After Training:", zip(model.metrics_names, score)
plot(model, to_file='s3.png', show_shapes=True)
# Before Training: [('loss', 2.4697211952209472), ('categorical_accuracy',
0.092999999999999999)]
# After Training: [('loss', 2.1891849689483642), ('categorical_accuracy',
0.19400000000000001)]

现在让我们来看一个用于回归的两层神经网络。清单7-4提供了代码和图7-4              给出了计算图。应注意以下几点：              1。使用顺序构造定义模型。              

2。我们添加第一层，使用稠密，并指定输入维数。在这              如果模型的输入为维数500，则输出为              尺寸32。             3。我们定义一个**功能，选择乙状结肠。            

 4。然后，我们使用稠密定义第二层，生成              维度1。              

5。我们选择**为乙状结肠，选择均方误差，即              适用于回归。              

6。我们编译、培训和评估模型。            

 图7 -3。多类分类 

import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.utils.visualize_util import plot
model = Sequential()
model.add(Dense(32, input_dim=500))
model.add(Activation(activation='sigmoid'))
model.add(Dense(1))
model.add(Activation(activation='sigmoid'))
model.compile(optimizer='rmsprop', loss='mse', metrics=['mean_squared_error'])
data = np.random.random((1000, 500))
labels = np.random.randint(2, size=(1000, 1))
score = model.evaluate(data,labels, verbose=0)
print "Before Training:", zip(model.metrics_names, score)
model.fit(data, labels, nb_epoch=10, batch_size=32, verbose=0)
score = model.evaluate(data,labels, verbose=0)
print "After Training:", zip(model.metrics_names, score)
plot(model, to_file='s4.png', show_shapes=True)
# Before Training: [('loss', 0.26870122766494753), ('mean_squared_error',
0.26870122766494753)]
# After Training: [('loss', 0.22180086207389832), ('mean_squared_error',
0.22180086207389832)]

现在让我们暂停一下，看看Keras如何允许快速迭代思想。          

   1。新模型可以快速定义、训练和评估              构建。            

 2。层输入/输出维数的参数可以很容易地修改。            

  3。我们可以很容易地比较**函数的多种选择。清单7～6              说明如何比较**函数的效果。              

4。我们可以很容易地比较优化算法的多种选择。清单7～5              

说明如何比较不同**选择的效果              算法。 

 

Listing 7-5. Optimisers
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation
def train_given_optimiser(optimiser):
model = Sequential()
model.add(Dense(1, input_dim=500))
model.add(Activation(activation='sigmoid'))
model.compile(optimizer=optimiser, loss='binary_crossentropy', metrics=['accuracy'])
data = np.random.random((1000, 500))
labels = np.random.randint(2, size=(1000, 1))
score = model.evaluate(data,labels, verbose=0)
print "Optimiser: ", optimiser
print "Before Training:", zip(model.metrics_names, score)

odel.fit(data, labels, nb_epoch=10, batch_size=32, verbose=0)
score = model.evaluate(data,labels, verbose=0)
print "After Training:", zip(model.metrics_names, score)
train_given_optimiser("sgd")
train_given_optimiser("rmsprop")
train_given_optimiser("adagrad")
train_given_optimiser("adadelta")
train_given_optimiser("adam")
train_given_optimiser("adamax")
train_given_optimiser("nadam")
# Optimiser: sgd
# Before Training: [('loss', 0.76416229248046874), ('acc', 0.51800000000000002)]
# After Training: [('loss', 0.6759231286048889), ('acc', 0.56899999999999995)]
# Optimiser: rmsprop
# Before Training: [('loss', 0.77773557662963866), ('acc', 0.52600000000000002)]
# After Training: [('loss', 0.727150842666626), ('acc', 0.53500000000000003)]
# Optimiser: adagrad
# Before Training: [('loss', 0.9275067367553711), ('acc', 0.49099999999999999)]
# After Training: [('loss', 0.66770141410827633), ('acc', 0.57599999999999996)]
# Optimiser: adadelta
# Before Training: [('loss', 0.76523585319519039), ('acc', 0.48799999999999999)]
# After Training: [('loss', 0.70753741836547857), ('acc', 0.51700000000000002)]
# Optimiser: adam
# Before Training: [('loss', 0.76974405097961429), ('acc', 0.51100000000000001)]
# After Training: [('loss', 0.66079518222808842), ('acc', 0.59399999999999997)]
# Optimiser: adamax
# Before Training: [('loss', 0.76244759178161625), ('acc', 0.49399999999999999)]
# After Training: [('loss', 0.67273861455917361), ('acc', 0.58499999999999996)]
# Optimiser: nadam
# Before Training: [('loss', 0.71690645027160649), ('acc', 0.50600000000000001)]
# After Training: [('loss', 0.62006913089752203), ('acc', 0.68799999999999994)]
 

Keras实施了许多乐观主义者，即坚忍的梯度下降（SGD）、rmsprop，              Adagrad、Adatadelta、Adam、Adamax和Nadam。第8章主要介绍了这些（SGD及其变体）              细节，解释每个人的直觉。在本章的背景下，可以说是喀拉斯做到了这一点。              用户可以很容易地用这些优化程序进行试验，而编码工作很少。 

Listing 7-6. Activation Functions
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation
def train_given_activation(activation):
model = Sequential()
model.add(Dense(1, input_dim=500))
model.add(Activation(activation=activation))
model.compile(optimizer="sgd", loss='binary_crossentropy', metrics=['accuracy'])

data = np.random.random((1000, 500))
labels = np.random.randint(2, size=(1000, 1))
score = model.evaluate(data,labels, verbose=0)
print "Activation: ", activation
print "Before Training:", zip(model.metrics_names, score)
model.fit(data, labels, nb_epoch=10, batch_size=32, verbose=0)
score = model.evaluate(data,labels, verbose=0)
print "After Training:", zip(model.metrics_names, score)
train_given_activation("relu")
train_given_activation("tanh")
train_given_activation("sigmoid")
train_given_activation("hard_sigmoid")
train_given_activation("linear")
# Activation: relu
# Before Training: [('loss', 2.6973885402679443), ('acc', 0.48899999999999999)]
# After Training: [('loss', 7.7373054656982418), ('acc', 0.505)]
# Activation: tanh
# Before Training: [('loss', 5.0640698051452633), ('acc', 0.41699999999999998)]
# After Training: [('loss', 7.6523446731567386), ('acc', 0.52000000000000002)]
# Activation: sigmoid
# Before Training: [('loss', 0.70816111516952518), ('acc', 0.52500000000000002)]
# After Training: [('loss', 0.67464308834075926), ('acc', 0.58199999999999996)]
# Activation: hard_sigmoid
# Before Training: [('loss', 0.70220352411270137), ('acc', 0.52100000000000002)]
# After Training: [('loss', 0.67294596910476689), ('acc', 0.58099999999999996)]
# Activation: linear
# Before Training: [('loss', 3.5439299507141113), ('acc', 0.47799999999999998)]
# After Training: [('loss', 8.2581552581787108), ('acc', 0.0)]

Keras执行许多**功能，即tanh、sigmoid、hard_sigmoid、linear、              和relu（整流线性单元）。**功能及其对给定任务的适当性（分类，              第3章详细介绍了多分类、回归等。就本章而言，              可以说，Keras使用户可以很容易地用              编码工作很少。              现在让我们来看一下Keras提供的构建卷积神经网络的构造。              在第5章中。我们将使用的数据集是mnist数据集，这是一个常用的基准数据。              准备深入学习。数据集包括手写数字（60000个培训示例和10000个测试）              例子）。目前的任务是根据图像预测数字，所以这是一个多分类问题。              有十个班。

Listing 7-7. CNN
import numpy as np
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Convolution2D, MaxPooling2D

from keras.utils import np_utils
from keras.utils.visualize_util import plot
# Image Size
img_rows, img_cols = 28, 28
# Filter
nb_filters = 32
# Pooling
pool_size = (2, 2)
# Kernel
kernel_size = (3, 3)
# Prepare dataset
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1)
X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
nb_classes = 10
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)
# CNN
model = Sequential()
model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1], border_mode='valid',
input_shape=input_shape))
model.add(Activation('relu'))
model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1]))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=pool_size))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes))
model.add(Activation('softmax'))
# Compilation
model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy'])
# Training
batch_size = 128
nb_epoch = 1
model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, validation_
data=(X_test, Y_test))

# Evaluation
score = model.evaluate(X_test, Y_test, verbose=0)
print "Test Metrics:", zip(model.metrics_names, score)
plot(model, to_file='s7.png', show_shapes=True)
# Output
# Train on 60000 samples, validate on 10000 samples
# Epoch 1/1
# 60000/60000 [==============================] - 128s - loss: 0.3964 - acc: 0.8776 - val_
loss: 0.0929 - val_acc: 0.9712
# Test Metrics: [('loss', 0.092853568810969594), ('acc', 0.97119999999999995)]
Figure 7-5. CNN

 Listing 7-7 presents the source code for the convolution neural network and图=1607-5 implorates the              计算图The following points are to be noted:            

 1由两个卷积探测器块组成的总网络          

  一个最大的转动层被两层完全连接            

 Network（refer to chapter 5）.              

二核的大小是3×3。              

三在尺寸2×2的部分上进行了平面操作。              

四这里有一大堆的软骨层，基本上是一种软骨层。              规范（Refer to Chapter 1）and operate by randomly turning off a certain              Number of Units.The parameter 0.25 indicates the partication of inputs that will be              兰多姆・德罗普            

 五平面层将任何尺寸的输入转换为一个尺寸。              Of 1×n.so，for instance，a n input of dimensionality 2×2×3 gets converted to a              Directionality of 1×12.              六输出层是软的，损耗函数是类别熵，如              Appropriate for a multilasification problem（refer to chapter 3）.        

     七The model is fit using Adadelta（refer to chapter 8）and，for the purposes of              

说明一下，我们把第1页放在1页（理想的比这多）。 

Listing 7-8. LSTM
import numpy as np
from keras.preprocessing import sequence
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Embedding
from keras.layers import LSTM
from keras.datasets import imdb
from keras.utils.visualize_util import plot
max_features = 20000
maxlen = 80
batch_size = 32
# Prepare dataset
(X_train, y_train), (X_test, y_test) = imdb.load_data(nb_words=max_features)
X_train = sequence.pad_sequences(X_train, maxlen=maxlen)
X_test = sequence.pad_sequences(X_test, maxlen=maxlen)
# LSTM
model = Sequential()
model.add(Embedding(max_features, 128, dropout=0.2))
model.add(LSTM(128, dropout_W=0.2, dropout_U=0.2))
model.add(Dense(1))
model.add(Activation('sigmoid'))
# Compile
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Training
model.fit(X_train, y_train, batch_size=batch_size, verbose=1, nb_epoch=1, validation_
data=(X_test, y_test))
# Evalaution
score = model.evaluate(X_test, y_test, batch_size=batch_size)
print "Test Metrics:", zip(model.metrics_names, score)
plot(model, to_file='s8.png', show_shapes=True)
# Output
# Train on 25000 samples, validate on 25000 samples
# Epoch 1/1
# 25000/25000 [==============================] - 165s - loss: 0.5286 - acc: 0.7347 - val_
loss: 0.4391 - val_acc: 0.8076
# 25000/25000 [==============================] - 33s
# Test Metrics: [('loss', 0.43908300422668456), ('acc', 0.80759999999999998)]

现在让我们来看看第6章中介绍的Keras为构建LSTM网络提供的构造（请参阅              如清单7-8和图7-6所示。我们将使用的数据集来自IMDB，代表来自IMDB的25000条评论              IMDD分类为正或负，这使得这是一个二进制序列分类问题。数据              被预处理为只包含频繁出现的单词（这些单词实际上被表示为整数）。清单7-8              给出了源代码，图7-6说明了计算图。Keras提供了相当高的水平              为lstms构造，允许用户构造lstm模型。              

总结              

在本章中，我们使用一些小而简单的示例介绍了使用KERA的基本知识。我们              鼓励读者尝试这些例子。Keras有大量的文件，即              建议进一步阅读。