Keras基本用法

参考 Keras基本用法 - 云+社区 - 腾讯云

Keras是目前使用最为广泛的深度学习工具之一,它的底层可以支持TensorFlow、MXNet、CNTK和Theano。如今,Keras更是被直接引入了TensorFlow的核心代码库,成为TensorFlow官网提供的高层封装之一。下面首先介绍最基本的Keras API,下面给出一个简单的样例,然后介绍如何使用Keras定义更加复杂的模型以及如何将Keras和原生态TensorFlow结合起来。

1、Keras基本用法

和TFLearn API类似,Keras API也对模型定义、损失函数、训练过程等进行了封装,而且封装之后的整个训练过程和TFLearn是基本一致的,可以分为数据处理、模型定义和模型训练三个部分。使用原生态的Keras API需要先安装Keras包,安装的方法如下:

pip install keras

以下代码展示了如何使用原生态Keras在MNIST数据集上实现LeNet-5模型。

# -*- coding: utf-8 -*-

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Flatten, Conv2D, MaxPooling2D
from keras import backend as K

num_classes = 10
img_rows, img_cols = 28, 28


(trainX, trainY), (testX, testY) = mnist.load_data()


if K.image_data_format() == 'channels_first':
   trainX = trainX.reshape(trainX.shape[0], 1, img_rows, img_cols)
   testX = testX.reshape(testX.shape[0], 1, img_rows, img_cols)
   input_shape = (1, img_rows, img_cols)
else:
   trainX = trainX.reshape(trainX.shape[0], img_rows, img_cols, 1)
   testX = testX.reshape(testX.shape[0], img_rows, img_cols, 1)
   input_shapes = (img_rows, img_cols, 1)

trainX = trainX.astype('float32')
testX = testX.astype('float32')
trainX /= 255.0
testX  /= 255.0


trainY = keras.utils.to_categorical(trainY, num_classes)
testY = keras.utils.to_categorical(testY, num_classes)


model = Sequential()


model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Conv2D(64, (5,5), activation='relu'))

model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Flatten())

model.add(Dense(500, activation='relu'))

model.add(Dense(num_classes, activation='softmax'))


model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer = keras.optimizers.SGD(),
              metrics = ['accuracy'])

model.fit(trainX, trainY, batch_size=128, epochs=20, validation_data=(testX, testY))

score = model.evaluate(testX, testY)
print('Test loss:',score[0])
print('Test accuracy', score[1])






-------------------------------------------------------------
Output:

   32/10000 [..............................] - ETA: 0s
  608/10000 [>.............................] - ETA: 0s
 1152/10000 [==>...........................] - ETA: 0s
 1664/10000 [===>..........................] - ETA: 0s
 2112/10000 [=====>........................] - ETA: 0s
 2560/10000 [======>.......................] - ETA: 0s
 3008/10000 [========>.....................] - ETA: 0s
 3424/10000 [=========>....................] - ETA: 0s
 3840/10000 [==========>...................] - ETA: 0s
 4256/10000 [===========>..................] - ETA: 0s
 4704/10000 [=============>................] - ETA: 0s
 5152/10000 [==============>...............] - ETA: 0s
 5600/10000 [===============>..............] - ETA: 0s
 6112/10000 [=================>............] - ETA: 0s
 6624/10000 [==================>...........] - ETA: 0s
 6944/10000 [===================>..........] - ETA: 0s
 7104/10000 [====================>.........] - ETA: 0s
 7232/10000 [====================>.........] - ETA: 0s
 7360/10000 [=====================>........] - ETA: 0s
 7488/10000 [=====================>........] - ETA: 0s
 7648/10000 [=====================>........] - ETA: 0s
 7840/10000 [======================>.......] - ETA: 0s
 8096/10000 [=======================>......] - ETA: 0s
 8256/10000 [=======================>......] - ETA: 0s
 8480/10000 [========================>.....] - ETA: 0s
 8640/10000 [========================>.....] - ETA: 0s
 8864/10000 [=========================>....] - ETA: 0s
 9120/10000 [==========================>...] - ETA: 0s
 9280/10000 [==========================>...] - ETA: 0s
 9408/10000 [===========================>..] - ETA: 0s
 9664/10000 [===========================>..] - ETA: 0s
 9824/10000 [============================>.] - ETA: 0s
 9984/10000 [============================>.] - ETA: 0s
10000/10000 [==============================] - 2s 178us/step
Test loss: 0.09795796233266592
Test accuracy 0.970300018787384
-------------------------------------------------------------------

从以上代码中可以看出使用Keras API训练模型可以先定义一个Sequential类,然后在Sequential实例中通过add函数添加网络层。Keras把卷积层、池化层、RNN结构(LSTM、GRU),全连接层等常用的神经网络结构都做了封装,可以很方便地实现深层神经网络。在神经网络结构定义好之后,Sequential实例可以通过compile函数,指定优化函数、损失函数以及训练过程中需要监控等指标。Keras对优化函数、损失函数以及监控指标都有封装,同时也支持使用自定义的方式,在Keras的API文档中有详细的介绍,这里不再赘述。最后在网络结构、损失函数和优化函数都定义好之后,Sequential实例可以通过fit函数来训练模型。类似TFLearn中的fit函数,Keras的fit函数只需给出训练数据,batch大小和训练轮数,Keras就可以自动完成模型训练的整个过程。

除了能够很方便地处理图像问题,Keras对训练神经网络的支持也是非常出色的。有了Keras APA,循环神经网络的训练体系也可以通过简单的一句命令完成。以下代码给出了如何通过Keras实现自然语言感情分类问题。使用循环网络判断语言的感情(比如在以下例子中需要判断一个评价是好评还是差评)和自然语言建模问题类似,唯一的区别在于除了最后一个时间点的输出是有意义的,其他时间点的输出都可以忽略,下图展示了使用循环网络处理感情分析问题的模型结构。

                            Keras基本用法_第1张图片

# -*- coding: utf-8 -*-

from keras.preprocessing import sequence
from keras.models import Sequential
from keras.layers import Dense, Embedding
from keras.layers import LSTM
from keras.datasets import imdb

# 最多使用的单词数。
max_features = 20000
# 循环神经网络的截断长度。
maxlen = 80
batch_size = 32
# 加载数据并将单词转化为ID, max_features给出了最多使用的单词数。和自然语言模型类似,会将出现频率 # 较低的单词替换为统一的ID,通过Keras封装的API生成25000条训练数据和25000条测试数据,每一条数据可以
# 摆看成一段话,并且每段话都有一个好评或者差评的标签。
(trainX, trainY), (testX, testY) = imdb.load_data(num_words=max_features)
print(len(trainX), 'train sequences')
print(len(trainY), 'test_sequences')

# 在自然语言处理中,每一段话的长度都是不一样的,但循环神经网络的循环长度是固定的,所以这里需要首先
# 将所有段落统一成固定长度。对于长度不够的段落,要使用默认值0来填充,对于超过长度
# 的段落则直接忽略掉超过的部分。
trainX = sequence.pad_sequences(trainX, maxlen = maxlen)
testX  = sequence.pad_sequences(testX, maxlen=mexlen)

# 输出统一长度之后的数据维度:
# ('x_train shape:', (25000, 80))
# ('x_test shape:', (25000, 80))
print('trainX shape:', trainX.shape)
print('testX shape:', trainX.shape)

# 再完成数据预处理之后的模型结构
model = Sequential()
# 构建embedding层。128代表了embedding层的向量维度。
model.add(Embedding(max_features, 128))
# 构建LSTM层。
model.add(LSTM(128,dropout=0.2))
# 构建最后的全连接层。注意在上面构建LSTM层时只会得到最后一个节点输出,
# 如果需要输出每个时间点的结果,那么可以将return_sequence参数设置为true。
model.add(Dense(1, activation='sigmoid'))

# 与MNIST样例类似地指定损失函数,优化函数和评测指标。
model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])
# 与MNIST样例类似地指定训练数据,训练轮数,batch大小以及验证数据。
model.fitt(trainX, trainY, batch_size=batch_size, epochs=15, validation_data=(testX, testY))

# 在测试数据上评测模型
score = model.evaluate(testX, testY, batch_size=batch_size)
print('Test loss:', score[0])
print('Test accuracy:',score[1])

以上两个样例针对Keras的基本用法做了详细的介绍。虽然Keras的封装,很多经典的神经网络结构能很快地被实现,不过要实现一些更加灵活的网络结构、损失函数或者数据输入方法,就需要对Keras的高级用法有更多的了解。

2、Keras高级用法

上面样例中最重要的封装就是Sequential类,所有的神经网络定义和训练都是通过Sequential实例来实现的。然而从这个类的名称可以看出,它只支持顺序模型的定义。类似Inception这样的模型结构,通过Sequential类就不容易直接实现了。为了支持更加灵活的模型定义方法,Keras支持以返回值的形式定义网络层结构。以下代码展示了如何使用这种方式定义模型。

# -*- coding:utf-8 -*-

import keras
from keras.datasets import mnist
from keras.layers import Input, Dense
from keras.models import Model

# 使用1中介绍的类似方法生成trainingX、trainingY、testX、testY,唯一的
# 不同是这里只使用了全连接层,所以不需要将输入整理成三维矩阵。

...

# 定义输入,这里指定的维度不用考虑batch大小。
inputs = Input(shape=(784,))
# 定义一层全连接,该层有500隐藏节点,使用ReLU激活函数,这一层的输入为inputs。
x = Dense(500, activate='relu')(inputs)
# 定义输出层。注意因为keras封装需要指定softmax作为激活函数。
predictions = Dense(10, activate='softmax')(x)

# 通过Model类创建模型,和Sequential类不同的是Model类在初始化的时候需要指定模型的输入和输出。
model = Model(inputs=inputs, outputs=predictions)

# 与1中类似的方法定义损失函数、优化函数和评测方法。
model.complie(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.SGD(),metrics=['accuracy'])

# 与1中类似的方法训练模型。
model.fit(trainX, trainY, batch_size=128, epoches=20, validation_data=(testX, testY))

通过这样的方式,Keras就可以实现类似Inception这样大的模型结构。以下代码展示了如何通过Keras实现Inception结构。

from keras.layers import Conv2D, MaxPooling2D, Input

# 定义输入图像尺寸
input_img = Input(shape=(256,256,3))

# 定义第一个分支。
tower_1 = Conv2D(64,(1,1),padding='same',activation='relu')(input_img)
tower_1 = COnv2D(64,(3,3),padding='same',activation='relu')(tower_1)

# 定义第二个分支。与顺序模型不同,第二个分支的输入使用的是input_img,而不是第一个分支的输出。
tower_2 = Conv2D(64,(1,1),padding='same',activation='relu')(input_img)
tower_2 = Conv2D(65,(5,5),padding='same',activation='relu')(tower_2)

# 定义第三个分支。类似地,第三个分支的输入也是input_img,
tower_3 = MaxPooling2D((3,3),strides=(1,1),padding='same')(input_img)
tower_3 = Conv2D(64, (1,1), padding='same', activation='relu')(tower_3)

# 将第三个分支通过concatenate的方式拼接在一起
output = keras.layers.concatenate([tower_1, tower_2, tower_3], axis = 1)

除了可以支持顺序模型,Keras也可以支持有多个输入或者输出的模型。以下代码实现了下图所示的网络结构。

                               Keras基本用法_第2张图片

# -*- coding: utf-8 -*-

import keras
from tflearn,layers.core import fully_connected
from keras.datasets import mnist
from keras.layers import Input, Dense
from keras.models import Model

# 类似1的方式生成trainX, trainY, testX, testY
# 定义两个输入,一个输入为原始的图片信息,另一个输入为正确答案。
input1 = Input(shape=(784,), name="input1")
input2 = Input(shape=(10,), name="input2")

# 定义一个只有一个隐藏节点的全连接网络。
x = Dense(1, activation='relu')(input1)
# 定义只使用了一个隐藏节点的网络结构的输出层。
output1 = Desnse(10, activation='softmax',name="output1")(x)

# 将一个隐藏节点的输出和正确答案拼接在一起,这个将作为第二个输出层的输入。
y = keras.layers.concatenate([x, input2])
# 定义第二个输出层。
input3 = Dense(10, activation='softmax', name = "output2")(y)

# 定义一个有多个输入和多个输出的模型。这里只需要将所有的输入和输出给出即可。
model = Model(inputs=[inputs1, inputs2], outputs = [output1, output2])

# 定义损失函数、优化函数和测评方法。若多个输出的损失函数相同,可以只指定一个损失函数。
# 如果多个输出的损失函数不同,则可以通过一个列表或一个字典来指定每一个输出的损失函数。
# 比如可以使用:
# loss = {'output1':binary_crossentropy,'output2':binary_crossentropy}
# 求为不同的输出指定不同的损失函数。类似地,Keras也支持为不同输出产生的损失指定权重,
# 这可以通过loss_weights参数来完成。在下面的定义中,输出output1的权重为1,output2的
# 权重为0.1,所以这个模型会更加偏向于优化的第一个输出。

model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.SGD(), loss_weights = [1,0.1], metrics = ['accuracy'])

# 模型训练过程。因为有两个输入和输出,所以这里提供的数据也需要有两个输入和两个期待的正确答案输出。
# 通过列表的方式提供数据时,Keras会假设数据给出的顺序和定义Model类时输入会给出的顺序是对应的。为 # 了避免顺序不一致导致的问题,推荐使用字典的形式给出:
#  model.fit( 
#          {'input1':trainX, 'input2':trainY}
#          {'output1':trainX, 'output2':trainY}
#          ...)

model.fit([trainX, trainY], [trainY, trainY], batch_size=128, epochs=20, validation_data=([testX, testY], [testX, testY]))

从以上输出可以看出Keras在训练过程中会展示每个输出层的loss和accuracy。因为输出层output1只使用了一个维度为1的隐藏点,所以正确率只有29.85%。虽然输出层output2使用了正确答案作为输入,但是因为在损失函数中权重较低(只有0.1),所以它的收敛速度较慢,在20个epoch时准确率也只有92.1%。如果将两个输出层的损失权重设为一样,那么输出层output1在20个epoch时的准确率将只有27%,而输出层output2的准确率可以达到99.9%。虽然通过返回值的方式已经可以实现大部分的神经网络模型,然而Keras API还存在两大问题。第一,原生态Keras API对训练数据的处理流程支持得不太好,基本上需要一次性将数据全部全部加载到内存。第二,原生态Keras API无法支持分布式训练。为了解决这两个问题,Keras提供了一种与原生态TensorFlow结合地更加紧密的方式。以下代码显示了如何将Keras和原生态TensorFlow API联合起来解决MNIST问题。

# -*- coding: utf-8 -*-

import tensorflow as tf
from tensorflow.example.tutorials.mnist import input_data

mnist_data=input_data.read_data_sets('/path/to/MNIST_data', one_hot=True)

# 通过TensorFlow中的placeholder定义输入。类似的,Keras封装数据的网络层结构也可以支持队列输入。
# 这样可以有效避免一次性加载所有数据的问题。

x = tf.placeholder(tf.float32, shape=(None, 764))
y_ = tf.placeholder(tf.float32, shape=(None, 10))


# 直接使用TensorFlow中提供的Keras API定义网络层结构。
net = tf.keras.layers.Dense(500, activate='relu')(x)
y = tf.keras.layers.Dense(10, activation='softmax')(net)

# 定义损失函数和优化方法。注意这里可以混用Keras的API和原生态TensorFlow的API。
loss = tf.reduce_mean(tf.keras.losses.categorical_crossentropy(y_, y))
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(loss)

# 定义正确的预测率作为指标。
acc_value = tf.reduce_mean(tf.keras.metric.categorical_accuracy(y_, y))

# 使用原生态TensorFlow的方式训练模型。这样就可以有效的实现分布式。
with tf.Session() as sess:
   tf.global_variables_initializer().run()
   for i in range(10000):
       xs, ys = mnist_data.train.next_batch(100)
       _, loss_value = sess.run([train_step, loss], feed_dict={x:xs, y_:ys})
       
       if i % 1000 == 0:
          print("After %d training step(s), loss on training batch is " "%g." % (i,  loss_value))
   print acc_value.eval(feed_dict={x:mnist_data.test.images, y_: mnist_data.test.labels})

3、Keras的主要模块、类和函数

Modules

  • activations module: Built-in activation functions.
  • applications module: Keras Applications are canned architectures with pre-trained weights.
  • backend module: Keras backend API.
  • callbacks module: Callbacks: utilities called at certain points during model training.
  • constraints module: Constraints: functions that impose constraints on weight values.
  • datasets module: Keras built-in datasets.
  • estimator module: Keras estimator API.
  • experimental module: Public API for tf.keras.experimental namespace.
  • initializers module: Keras initializer serialization / deserialization.
  • layers module: Keras layers API.
  • losses module: Built-in loss functions.
  • metrics module: Built-in metrics.
  • mixed_precision module: Public API for tf.keras.mixed_precision namespace.
  • models module: Code for model cloning, plus model-related API entries.
  • optimizers module: Built-in optimizer classes.
  • preprocessing module: Keras data preprocessing utils.
  • regularizers module: Built-in regularizers.
  • utils module: Keras utilities.
  • wrappers module: Wrappers for Keras models, providing compatibility with other frameworks.

Classes

  • class Model: Model groups layers into an object with training and inference features.
  • class Sequential: Linear stack of layers.

Functions

  • Input(...): Input() is used to instantiate a Keras tensor.

你可能感兴趣的:(Keras,计算机视觉,深度学习,机器学习)